Timer ng Stepper Pomodoro: 3 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:15

Ang Stepper Pomodoro ay isang desk timer upang matulungan ang isa na pamahalaan ang kanilang pang-araw-araw na listahan ng gawain sa pamamagitan ng pagsira sa bawat panahon ng trabaho sa 30 minuto na mga segment. Gayunpaman, hindi tulad ng isang normal na timer ng Pomodoro, hindi ka nito nababalisa sa pamamagitan ng pagpapakita ng natitirang oras. Sa halip, ipinapakita nito ang oras na humigit-kumulang sa pamamagitan ng alin sa tatlong mga pagdayal ang nakakiliti. Sa pamamagitan ng hindi pagpapakita ng eksaktong oras pinapayagan ka nitong aktwal na tumuon sa gawain na nasa kamay, sa halip na patuloy na suriin ang iyong natitirang oras. Ang Pomodoro na ito ay perpekto para sa mga nangangailangan ng isang magaan at hindi nakakaabala na istraktura sa kanilang pamamahala sa gawain.

Mga kasangkapan

• Panghinang

• Mga striper ng wire

• Laser cutter (o sander depende sa kung paano mo nais na likhain ang mga pagdayal ng timer)

• Drill (Gumamit ako ng drill press upang masuntok ang mga butas na sapat na malaki para sa mga dial)

Mga Kagamitan

• 1 Arduino Uno

• 1 kalahating sukat na pisara

• 3 H na tulay (Gumamit ako ng DRV8833, isang motor shield wold ang nai-save sa akin ng ilang oras at sakit ng ulo)

• 3 Stepper motors (Gumamit ako ng NEMA 17 steppers)

• 1 Button

• 1 220-1K ohm risistor (anumang nasa loob ng saklaw ay mabuti)

• AC / DC adapter (Gumamit ako ng 12V, marahil masyadong malaki para sa dami ng mga steppers na ito)

• Power splitter

• USB A-B wire

• Mga wire ng Breadboard

• Maghinang

• Mga materyales para sa lalagyan ng timer

• Acrylic para sa mga pagdayal

• Mga kuko o metal na pin upang kumilos bilang nakatigil na braso ng timer

Hakbang 1: Hakbang 1: Paghihinang at Pagkonekta ng Circuit Sa Labas ng Lalagyan

Para sa hakbang na ito nagsimula ako sa pamamagitan ng paghihinang na magkasama ang lahat ng aking mga H tulay (kung bumili ka ng kalasag sa motor ay hindi mo kailangang maghinang ng mga ito. Kapag mayroon kang isang H tulay para sa bawat stepper maaari mong suriin kung paano ang iyong mga steppers ay wired.

Ang NEMA 17s ay ang kilala bilang bipolar stepper motors, nangangahulugang mayroon silang dalawang (sa halip na isang) hanay ng mga coil sa loob ng motor na binabago ang polarity upang payagan ang tumpak na paggalaw ng motor. Ang mga stepper ng bipolar ay karaniwang mayroong apat na mga wire at ang mga stepper ng Polar ay karaniwang may anim, na kumplikado nito nang kaunti ang mga tagubilin sa online. Gayunpaman maaari kang maglakip ng isang multi meter sa dalawang mga wire at makita kung ang mga ito ay konektado o kung hindi. Ang NEMA 17 steppers ay mayroong order ng wire sa RED, YELLOW, GRAY, GREEN na pagkakasunud-sunod ng kulay, na may pula at grey na unang polar pares at ang dilaw at berde ang pangalawang polar pares. Kung sa anumang punto ang stepper ay nagsisimulang kumibot kaysa sa pagkumpleto ng inaasahang paggalaw, ang posibilidad na ang iyong mga wire ay kahit papaano ay hindi tama na na polarado sa kanilang kambal o ang isa ay naalis. Ang bawat stepper ay kinokontrol sa pamamagitan ng apat na output pin na kumokonekta sa mga tulay ng DRV8833 H. Ang order ng mga kable para sa pag-input sa DRV8833 ay: IN1, IN2, Power, Ground, IN3, IN4. Para sa mga hangarin sa output ang NEMA ay kumokonekta lamang sa gitnang apat ng anim na mga pin sa pagkakasunud-sunod ng: PULANG, LABI, DILAW, GREEN. Hinahayaan ngayon ang pagkonekta ng lakas. Mayroon akong aking mga NEMA sa mga digital port 2–13.

Upang mapagana ito, bumili ako ng isang 12V AC / DC adapter na may splitter upang ma-power ang parehong Arduino, at lahat ng steppers. BABALA: Huwag ikonekta ang iyong mga power at ground wires mula sa Arduino na tumatanggap na ng kuryente mula sa port patungo sa breadboard na tumatanggap ng direktang lakas mula sa AC / DC. Ito ay magprito ng iyong board. Mula sa 12V adapter na naka-plug sa pader ang isang bahagi ng splitter ay dumiretso sa port ng Arduino at ang isa sa positibo at negatibo ng board ng tinapay.

Panghuli, oras na upang mai-hook up ang pindutan. Ang isang gilid ng pindutan ay mangangailangan ng parehong lakas (kasama ang aming risistor na hinati) pati na rin ang output pin na solder (maaari rin itong gawin mula sa breadboard). Ang iba pang pin ay ang aming lupa. Ang tatlong mga wires na ito ay dapat na naka-plug in: Power na may risistor sa 5V, output sa A0, at ground sa ground lahat sa Arduino Uno board mismo.

Mula dito dapat naming tangkain upang makontrol ang mga steppers gamit ang pangunahing code ng pagsubok na stepper na matatagpuan dito. Ang paliwanag na ito sa Arduino.cc ay gumagawa din ng mas masusing paliwanag sa mga bi / unipolar steppers kung kailangan mo ito. Sumusunod na mapunta sa code para sa Pomodoro!

Hakbang 2: Hakbang 2: Pag-upload ng Code at Pagsasaayos nito sa Iyong Mga Pangangailangan

Nasa ibaba ang code para sa aking Pomodoro na may pindutan, upang ipasadya ito sa iyong pag-setup sundin kasama ang mga hakbang na ito:

1. Itakda kung gaano karaming mga hakbang bawat rebolusyon ang mayroon ang iyong personal na uri ng stepper (ang NEMA 17s ay mayroong 200 at nakalista ito sa pare-pareho na integer na tinatawag na stepsPerRevolution).

2. Itakda kung saan ang pag-input ng iyong pindutan sa palaging integer caller buttonPin.

3. Itakda kung saan dapat maglabas ang iyong arduino upang utusan ang mga steppers (ang mga bahaging ito ay maaaring mag-iba nang higit sa pagitan ng mga uri ng H tulay na maraming may iba't ibang mga silid aklatan na kanilang ginagamit).

4. Itakda ang bilis ng stepper sa mga RPM sa.setSpeed (Mayroon akong set na itinakda para sa 1 rpm kapag lumiliko sa pakaliwa at 30 rpm kapag nagiging anti clockwise).

5. Itakda kung gaano karaming beses na nais mong lumiko ang bawat isa sa iyong steppers bago ito lumipat (ang aking steppers ay bibilang ng sampung minuto, kaya paikutin nila ng sampung beses sa 1 RPM).

6 Itakda kung gaano katagal mo nais na paikutin ito paatras.

# isama

Const int stepsPerRevolution = 200; // setting ng kung gaano karaming mga hakbang ang nasa bawat buong rebolusyon ng aking mga motor na stepper

Const int buttonPin = A0; // setting ng aking input ng pindutan

Stepper firstStepper (stepsPerRevolution, 2, 3, 4, 5); // ipasimula ang stepper library sa ilang mga pin

Stepper secondStepper (stepsPerRevolution, 6, 7, 8, 9); Third stepper stepper (stepsPerRevolution, 10, 11, 12, 13); Stepper firstStepperBack (stepsPerRevolution, 2, 3, 4, 5); // reinitialize ang stepper library sa mga pin na ito upang ma-reset ang rpm para kapag nag-aalerto na ang oras ay nag-expire na Stepper secondStepperBack (stepsPerRevolution, 6, 7, 8, 9); Pangatlong stepperStepperBack (stepsPerRevolution, 10, 11, 12, 13);

int minutesCounter = 0; // int pagbibilang ng buong rebolusyon ng mga steppers

int timerState = LOW; // ang kasalukuyang estado ng timer ng pomodoro (HIGH = on, LOW = off / reset) int buttonState; // ang kasalukuyang pagbabasa mula sa input pin int last ButtonState = HIGH; // ang nakaraang pagbabasa mula sa input pin

// ang mga sumusunod na variable ay hindi naka-sign long dahil ang oras, sinusukat sa miliseconds, // ay mabilis na magiging isang mas malaking bilang kaysa maimbak sa isang int. unsigned matagal hulingDebounceTime = 0; // ang huling oras na ang output pin ay na-toggle na hindi naka-sign mahabang debounceDelay = 50; // ang oras ng pag-debate; dagdagan kung ang output ay pumitik

walang bisa ang pag-setup () {

pinMode (buttonPin, INPUT_PULLUP); // itakda ang pare-pareho ng pindutan bilang isang input

firstStepper.setSpeed (1); // itakda ang bilis sa 1 rpm para sa pagbibilang ng 10 minuto bawat stepper segundoStepper.setSpeed (1); thirdStepper.setSpeed (1); firstStepperBack.setSpeed (30); // itakda ang bilis sa 30 rpm para sa pag-alerto na ang oras ay nag-expire matapos na makumpleto ng Pomodoro ang pangalawangStepperBack.setSpeed (30); thirdStepperBack.setSpeed (30);

Serial.begin (9600); // simulan ang serial monitor na may 9600 baud rate

}

void loop () {

// basahin ang estado ng paglipat sa isang lokal na variable: int pagbabasa = digitalRead (buttonPin);

// check upang makita kung pinindot mo lang ang pindutan

// (ibig sabihin, ang pag-input ay nagmula sa LOW to HIGH), at naghintay ka // ng sapat na panahon mula noong huling pindutin upang huwag pansinin ang anumang ingay:

// Kung ang switch ay nagbago, dahil sa ingay o pagpindot:

kung (nagbabasa! = last ButtonState) {// i-reset ang timer ng debouncing lastDebounceTime = millis (); } kung ((millis () - lastDebounceTime)> debounceDelay) {// kung anuman ang pagbasa, nandoon ito para sa mas matagal // kaysa sa pagkaantala ng debounce, kaya kunin ito bilang aktwal na kasalukuyang estado:

// kung ang estado ng pindutan ay nagbago:

kung (nagbabasa! = buttonState) {buttonState = nagbabasa;

// i-toggle lamang ang timer activaton kung ang bagong estado ng pindutan ay nagpapahiwatig na ito ay pinindot

// press once to turn on, press again to turn off if (buttonState == LOW) {timerState =! timerState; Serial.print ("Ang Timer State ay"); Serial.println (timerState); }}}

kung (timerState == MATAAS) {

Serial.println ("Nagsimula ang timer ng Pomodoro"); kung (minutesCounter <11) {// kung ang kasalukuyang pangalawang halaga ay naiiba kaysa sa dating halaga pagkatapos ay firstStepper.step (stepsPerRevolution); // turn stepper 200 steps / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

kung (11 <= minutesCounter && minutesCounter <21) {// kung ang kasalukuyang pangalawang halaga ay naiiba kaysa sa dating halaga pagkatapos ay secondStepper.step (stepsPerRevolution); // turn stepper 200 steps / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

kung (21 <= minutesCounter && minutesCounter <31) {// kung ang kasalukuyang pangalawang halaga ay naiiba kaysa sa dating halaga pagkatapos ay thirdStepper.step (stepsPerRevolution); // turn stepper 200 steps / 1 rev minutesCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }

kung (31 <= minutesCounter && minutesCounter <1031) {// kung ang kasalukuyang pangalawang halaga ay naiiba kaysa sa dating halaga pagkatapos ay firstStepperBack.step (-1); // turn stepper back 1 step sa pagkakasunud-sunod upang lumitaw tulad ng lahat na tumatakbo nang sabay-sabay secondStepperBack.step (-1); thirdStepperBack.step (-1); minutoCounter ++; Serial.print ("minutesCounter is"); Serial.println (minutesCounter); }} iba pa {Serial.println ("Pomodoro timer is off"); } // i-save ang pagbabasa. Sa susunod sa pamamagitan ng loop, // ito na ang huling ButtonState: last ButtonState = nagbabasa; }

Hakbang 3: Hakbang 3: Maglalaman ng Mga Stepper at Arduino Kung nais mo

Pinili kong lumikha ng isang parallelogramic form para sa aking orasan. Ang form na ito at ang mga materyal na pagpipilian ng pulang oak ay inspirasyon ng modernong kasangkapan sa kalagitnaan. Ang isang bahagi na pinaghirapan ko ay ang pag-aakma sa mga stepper na may mga dial sa pamamagitan ng kanilang mga portholes na makikita mula.