Temporizador Stepper Pomodoro: 3 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

O Stepper Pomodoro é um cronômetro de mesa para ajudar a gerenciar sua lista de tarefas diárias, dividindo cada período de trabalho em segmentos de 30 minutos. No entanto, ao contrário de um cronômetro Pomodoro normal, ele não o deixa ansioso, mostrando a quantidade de tempo restante. Em vez disso, ele exibe a hora aproximadamente por meio de qual dos três mostradores está marcando. Por não mostrar o tempo exato, ele permite que você realmente se concentre na tarefa em questão, em vez de verificar constantemente o tempo restante. Este Pomodoro é perfeito para quem precisa de uma estrutura leve e discreta para o gerenciamento de suas tarefas.

Ferramentas

• Ferro de solda

• Decapantes de fio

• Cortador a laser (ou lixadeira, dependendo de como você deseja criar os mostradores do cronômetro)

• Broca (usei uma furadeira para fazer furos grandes o suficiente para os mostradores)

Materiais

• 1 Arduino Uno

• 1 breadboard de meio tamanho

• 3 pontes H (usei DRV8833, um motor blindado me salvou algum tempo e dores de cabeça)

• 3 motores de passo (usei NEMA 17 de passo)

• 1 botão

• 1 resistor de 220-1K ohm (qualquer dentro da faixa é bom)

• Adaptador AC / DC (usei um 12V, provavelmente muito grande para esta quantidade de steppers)

• Divisor de energia

• Fio USB A-B

• Fios da placa de ensaio

• Solda

• Materiais para o recipiente do cronômetro

• Acrílico para mostradores

• Pregos ou pinos de metal para atuar como braço estacionário do cronômetro

Etapa 1: Etapa 1: Soldar e conectar o circuito fora do contêiner

Para esta etapa, comecei soldando todas as minhas pontes H (se você comprar a blindagem do motor, não deve precisar soldá-las. Depois de ter uma ponte H para cada stepper, você pode verificar como seus steppers são conectados.

Os NEMA 17s são conhecidos como motores de passo bipolares, o que significa que eles têm dois (em vez de um) conjunto de bobinas dentro do motor que mudam de polaridade para permitir o movimento preciso do motor. Os steppers bipolares normalmente têm quatro fios e os steppers Polar normalmente têm seis, o que complicou um pouco as instruções online. No entanto, você pode conectar um multímetro a dois fios e ver se eles estão conectados ou não. Os steppers NEMA 17 têm sua ordem de fios na ordem de cores VERMELHO, AMARELO, CINZA, VERDE, com o vermelho e o cinza sendo o primeiro par polar e o amarelo e o verde sendo o segundo par polar. Se em qualquer ponto o stepper começar a se contorcer em vez de completar o movimento esperado, é provável que seus fios não estejam polarizados corretamente para o gêmeo ou um esteja desconectado. Cada passo é controlado por quatro pinos de saída que se conectam às pontes H DRV8833. A ordem da fiação para a entrada do DRV8833 é: IN1, IN2, Alimentação, Terra, IN3, IN4. Para fins de saída, o NEMA se conecta apenas aos quatro pinos do meio dos seis pinos na ordem de: VERMELHO, CINZA, AMARELO, VERDE. Agora vamos conectar a energia. Tenho meus NEMAs nas portas digitais 2–13.

Para alimentá-lo, comprei um adaptador 12V AC / DC com divisor para poder alimentar o Arduino e todos os steppers. AVISO: Não conecte os fios de alimentação e aterramento do Arduino que já está recebendo alimentação da porta para a placa de ensaio que recebe alimentação direta do AC / DC. Isso vai fritar sua prancha. Do adaptador de 12 V conectado na parede, uma parte do divisor foi direto para a porta do Arduino e a outra para o positivo e o negativo da placa de pão.

Por último, é hora de conectar o botão. Um lado do botão precisará de energia (com nosso resistor conectado) e do pino de saída soldado (isso também pode ser feito na placa de ensaio). O outro pino será nosso terreno. Esses três fios devem ser conectados a: alimentação com resistor de 5 V, saída para A0 e aterramento para aterramento, tudo na própria placa Arduino Uno.

A partir daqui, devemos ser capazes de tentar controlar os steppers usando este código de teste de stepper básico encontrado aqui. Esta explicação em Arduino.cc também faz uma explicação mais completa de steppers bi / unipolares, se necessário. Em seguida, vamos entrar no código do Pomodoro!

Etapa 2: Etapa 2: Carregando o código e ajustando-o às suas necessidades

Abaixo está o código do meu Pomodoro com botão, para personalizá-lo de acordo com sua configuração, siga estas etapas:

1. Defina quantos passos por revolução seu tipo de stepper pessoal tem (NEMA 17s tem 200 e está listado no número inteiro constante chamado stepsPerRevolution).

2. Defina onde o botão está inserindo no botão do chamador de número inteiro constante buttonPin.

3. Defina de onde seu arduino deve sair para comandar os steppers (essas partes podem variar mais entre os tipos de ponte H, pois muitos têm diferentes bibliotecas que utilizam).

4. Defina a velocidade de passo em RPMs no.setSpeed (eu tenho o meu definido para 1 rpm ao girar no sentido horário e 30 rpm ao girar no sentido anti-horário).

5. Defina quantas vezes você deseja que cada um de seus steppers gire antes de continuar (meus steppers contam dez minutos, então eles giram dez vezes a 1 RPM).

6 Defina quanto tempo deseja que ele gire para trás.

#incluir

const int stepsPerRevolution = 200; // definindo a constante de quantos passos existem em cada revolução completa dos meus motores de passo

const int buttonPin = A0; // definindo a constante da entrada do meu botão

Stepper firstStepper (stepsPerRevolution, 2, 3, 4, 5); // inicializa a biblioteca de stepper em certos pinos

Stepper secondStepper (stepsPerRevolution, 6, 7, 8, 9); Stepper thirdStepper (stepsPerRevolution, 10, 11, 12, 13); Stepper firstStepperBack (stepsPerRevolution, 2, 3, 4, 5); // reinicializar a biblioteca stepper nesses pinos para poder redefinir o rpm para quando alertar que o tempo expirou Stepper secondStepperBack (stepsPerRevolution, 6, 7, 8, 9); Stepper thirdStepperBack (stepsPerRevolution, 10, 11, 12, 13);

int minutosContador = 0; // int contando as revoluções completas dos steppers

int timerState = LOW; // o estado atual do temporizador Pomodoro (HIGH = on, LOW = off / reset) int buttonState; // a leitura atual do pino de entrada int lastButtonState = HIGH; // a leitura anterior do pino de entrada

// as seguintes variáveis não têm sinais longos porque o tempo, medido em milissegundos, // rapidamente se tornará um número maior do que pode ser armazenado em um int. não assinado long lastDebounceTime = 0; // a última vez que o pino de saída foi alternado unsigned long debounceDelay = 50; // o tempo de debounce; aumentar se a saída piscar

void setup () {

pinMode (buttonPin, INPUT_PULLUP); // define a constante do botão como uma entrada

firstStepper.setSpeed (1); // define a velocidade em 1 rpm para contagem de 10 minutos por stepper secondStepper.setSpeed (1); thirdStepper.setSpeed (1); firstStepperBack.setSpeed (30); // definir a velocidade em 30 rpm para alertar que o tempo expirou depois que o Pomodoro concluiu secondStepperBack.setSpeed (30); thirdStepperBack.setSpeed (30);

Serial.begin (9600); // inicia o monitor serial com uma taxa de transmissão de 9600

}

void loop () {

// lê o estado do switch em uma variável local: int reading = digitalRead (buttonPin);

// verifique se você acabou de pressionar o botão

// (ou seja, a entrada foi de BAIXA para ALTA), e você esperou // tempo suficiente desde a última vez que pressionou para ignorar qualquer ruído:

// Se a chave mudou, devido a ruído ou ao pressionar:

if (reading! = lastButtonState) {// zera o temporizador de debouncing lastDebounceTime = millis (); } if ((millis () - lastDebounceTime)> debounceDelay) {// seja qual for a leitura, ela estará lá por mais tempo // do que o atraso de debounce, então considere-o como o estado atual atual:

// se o estado do botão mudou:

if (lendo! = buttonState) {buttonState = lendo;

// somente alternar a ativação do temporizador se o novo estado do botão indicar que ele foi pressionado

// pressione uma vez para ligar, pressione novamente para desligar if (buttonState == LOW) {timerState =! timerState; Serial.print ("Timer State is"); Serial.println (timerState); }}}

if (timerState == HIGH) {

Serial.println ("temporizador Pomodoro iniciado"); if (minutesCounter <11) {// se o segundo valor atual for diferente do valor anterior, firstStepper.step (stepsPerRevolution); // gira o stepper 200 passos / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

if (11 <= minutesCounter && minutesCounter <21) {// se o segundo valor atual for diferente do valor anterior, então secondStepper.step (stepsPerRevolution); // gira o stepper 200 passos / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

if (21 <= minutesCounter && minutesCounter <31) {// se o segundo valor atual for diferente do valor anterior, então thirdStepper.step (stepsPerRevolution); // gira o stepper 200 passos / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

if (31 <= minutesCounter && minutesCounter <1031) {// se o segundo valor atual for diferente do valor anterior, firstStepperBack.step (-1); // volta o stepper 1 passo na sequência para trás para aparecer como se todos estivessem rodando simultaneamente secondStepperBack.step (-1); thirdStepperBack.step (-1); minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }} else {Serial.println ("O temporizador Pomodoro está desligado"); } // salve a leitura. Na próxima vez no loop, // será o lastButtonState: lastButtonState = reading; }

Etapa 3: Etapa 3: Conter os Steppers e o Arduino se desejar

Optei por criar uma forma de paralelogramo para o meu relógio. Esta forma e as escolhas de materiais do carvalho vermelho foram inspiradas nos móveis modernos de meados do século. Uma parte com a qual tive mais dificuldade foi ajustar os steppers com mostradores através de suas vigias para serem vistos.