Super Fast Analog Voltages Mula sa Arduino: 10 Hakbang (na may Mga Larawan)

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

Ipinapakita ng Instructable na ito kung paano makabuo ng napakabilis na mga pagbabago ng boltahe ng analog mula sa isang Arduino at isang simpleng pares ng risistor at capacitor. Ang isang application kung saan ito ay kapaki-pakinabang ay ang pagbuo ng mga graphic sa isang oscilloscope. Maraming iba pang mga proyekto na nagawa ito. Ipinapakita ni Johngineer ang isang simpleng punungkahoy ng Pasko gamit ang pulse width modulation (PWM). Ang iba ay napabuti sa proyektong iyon sa pamamagitan ng paggamit ng isang risistor hagdan o paggamit ng isang nakatuon na digital-to-analog converter chip.

Ang paggamit ng PWM ay nagdudulot ng maraming kurap, habang ang paggamit ng isang risistor hagdan o isang digital-to-analog converter ay nangangailangan ng maraming mga output pin at mga sangkap na maaaring hindi madaling makuha. Ang circuit na ginagamit ko ay ang parehong patay na simpleng resistor at pares ng capacitor tulad ng ginamit sa Christmas tree demo, ngunit nagpapatakbo na may mas kaunting mas kisap-mata.

Una, gagabayan ka namin sa proseso ng pagbuo ng circuit. Pagkatapos ay tuturuan kita kung paano magdagdag ng iyong sariling imahe. Panghuli, ipapakilala ko ang teorya sa kung bakit ito ginagawang mas mabilis.

Kung nagustuhan mo ang Instructable na ito, mangyaring isaalang-alang ang pagboto para dito!:)

Hakbang 1: Pagbuo ng Circuit

Upang maitayo ang circuit, kakailanganin mo ang sumusunod:

a) Isang Arduino batay sa Atmel 16MHz ATmega328P, tulad ng isang Arduino Uno o Arduino Nano.

b) Dalawang resistors ng halagang R na hindi bababa sa 150Ω.

c) Dalawang capacitor ng halagang C tulad ng C = 0.0015 / R, mga halimbawa:

• R = 150Ω at C = 10µ
• R = 1.5kΩ at C = 1µ
• R = 15kΩ at C = 100nF
• R = 150kΩ at C = 10nF

Ang mga dahilan para sa pagpili ng mga halagang ito ay dalawang tiklop. Pangunahin, nais naming panatilihin ang kasalukuyang sa mga pin ng Arduino sa ibaba ng maximum na kasalukuyang rate ng 40mA. Ang paggamit ng halagang 150Ω ay naglilimita sa kasalukuyang sa 30mA kapag ginamit sa boltahe ng supply ng Arduino na 5V. Ang mga mas malaking halaga ng R ay magbabawas ng kasalukuyang at samakatuwid ay katanggap-tanggap.

Ang pangalawang pagpigil ay nais naming panatilihin ang oras na pare-pareho, na kung saan ay ang produkto ng R at C, katumbas ng tungkol sa 1.5ms. Ang software ay partikular na na-tune para sa oras na ito pare-pareho. Habang posible na ayusin ang mga halaga ng R at C sa software, mayroong isang makitid na saklaw kung saan ito gagana, kaya pumili ng mga bahagi na malapit sa iminungkahing ratio hangga't maaari.

Ang isang mas masusing paliwanag kung bakit ang pare-pareho ang RC ay mahalaga ay ibibigay sa seksyon ng teorya, pagkatapos kong maipakita sa iyo kung paano tipunin ang demonstration circuit.

Hakbang 2: Pag-set up ng Oscilloscope

Ang demonstrasyon ay nangangailangan ng isang oscilloscope na nakatakda sa X / Y mode. Ang mga lead test ay kailangang ma-hook up tulad ng ipinakita sa mga eskematiko. Ang iyong oscilloscope ay magkakaiba sa minahan, ngunit lalakad ako sa mga kinakailangang hakbang upang mai-set up ang X / Y mode sa aking unit:

a) Itakda ang pahalang na walisin upang makontrol ng Channel B (ang X axis).

b) Itakda ang oscilloscope sa dual channel mode.

c) Itakda ang volts / div sa parehong mga channel upang maipakita ang mga voltages mula 0V hanggang 5V. Itinakda ko ang sa akin sa 0.5V / div.

d) Itakda ang mode ng pagkabit sa DC sa parehong mga channel.

e) Ayusin ang posisyon ng X at Y upang ang tuldok ay nasa ibabang kaliwang sulok ng screen kapag ang Arduino ay pinapatay.

Hakbang 3: I-download at Patakbuhin ang Software

I-download ang software mula sa Fast Vector Display For Arduino repository. Ang software ay lisensyado sa ilalim ng GNU Affero Public License v3 at maaaring malayang magamit at mabago sa ilalim ng mga tuntunin ng lisensyang iyon.

Buksan ang file na "fast-vector-display-arduino.ino" sa Arduino IDE at i-upload sa iyong Arduino. Sandali, makikita mo ang isang "Maligayang Bagong Taon" na animation sa iyong oscilloscope screen.

Binuo ko ang proyektong ito bilang isang personal na hackaton sa mga linggo bago ang Pasko, kaya mayroong isang mensahe na may temang Pasko at Bagong Taon na maaari mong makita sa pamamagitan ng pagbabago ng variable ng PATTERN sa code.

Hakbang 4: Lumikha ng Iyong Sariling Pasadyang Guhit

Kung nais mong lumikha ng iyong sariling pagguhit, maaari mong i-paste ang mga coordinate ng point sa sketch ng Arduino sa linya na tumutukoy sa USER_PATTERN.

Nalaman ko na ang Inkscape ay isang napakahusay na tool para sa paggawa ng isang pasadyang pagguhit:

1. Lumikha ng teksto gamit ang isang malaki, naka-bold na font tulad ng Epekto.
2. Piliin ang object ng teksto at piliin ang "Object to Path" mula sa menu na "Path".
3. Piliin ang mga indibidwal na titik at isasapawan ito upang makagawa ng isang konektadong hugis
4. Piliin ang "Union" mula sa menu na "Path" upang pagsamahin ang mga ito sa isang solong curve.
5. Kung may mga butas sa anumang mga titik, gupitin ang isang maliit na bingaw sa pamamagitan ng pagguhit ng isang rektanggulo gamit ang tool na rektanggulo at ibawas ito mula sa tabas gamit ang tool na "Pagkakaiba".
6. I-double click ang path upang maipakita ang mga node.
7. Parihaba piliin ang lahat ng mga node at i-click ang tool na "Gumawa ng mga napiling sulok node".
8. I-save ang SVG file.

Ang mahalaga ay ang iyong pagguhit ay dapat magkaroon ng isang solong saradong landas at walang mga butas. Tiyaking ang iyong disenyo ay may mas kaunti sa halos 130 puntos.

Hakbang 5: I-paste ang Mga Coordinate Mula sa SVG File Sa Arduino IDE

1. Buksan ang SVG file at kopyahin ang mga coordinate. Ang mga ito ay mai-embed sa elemento ng "landas". Ang unang pares ng mga coordinate ay maaaring balewalain; palitan ang mga ito ng 0, 0.
2. I-paste ang mga coordinate sa Arduino sketch sa loob ng mga bracket pagkatapos mismo ng "#define USER_PATTERN".
3. Palitan ang lahat ng mga puwang ng mga kuwit, kung hindi man ay makakakuha ka ng isang error sa pag-ipon. Ang tool na "Palitan at Hanapin" ay maaaring maging kapaki-pakinabang.
4. Compile at patakbuhin!
5. Kung mayroon kang mga problema, panoorin ang serial console para sa anumang mga error. Sa partikular, makikita mo ang mga mensahe kung ang iyong pattern ay may masyadong maraming mga puntos para sa panloob na buffer. Sa mga ganitong kaso, ang imahe ay magpapakita ng sobrang kurap.

Hakbang 6: Maunawaan kung Bakit Mabagal ang PWM

Upang magsimula, suriin natin ang pag-uugali ng isang kapasitor habang naniningil ito.

Ang isang kapasitor na konektado sa isang mapagkukunan ng boltahe na Vcc ay magpapalaki ng boltahe nito ayon sa isang exponential curve. Ang curve na ito ay asymptotic, nangangahulugang mabagal ito habang papalapit sa target na boltahe. Para sa lahat ng mga praktikal na layunin, ang boltahe ay "sapat na malapit" pagkatapos ng 5 RC segundo. Ang RC ay tinawag na "time pare-pareho". Tulad ng nakita natin kanina, ito ay ang produkto ng mga halaga ng risistor at capacitor sa iyong circuit. Ang problema ay ang 5 RC ay isang mahabang mahabang panahon para sa pag-update ng bawat punto sa isang pagpapakita ng graphics. Ito ay humahantong sa maraming mga kisap-mata!

Kapag gumagamit kami ng pulse width modulation (PWM) upang singilin ang isang kapasitor, hindi kami mas mahusay. Sa PWM ang boltahe ay mabilis na lumilipat sa pagitan ng 0V at 5V. Sa pagsasagawa, nangangahulugan ito na mabilis kaming kahalili sa pagitan ng pagtulak sa singil sa capacitor at paghila ng kaunti nito agad-agad - ang push and pull na ito ay tulad ng pagsubok na magpatakbo ng isang marapon sa pamamagitan ng pagkuha ng isang malaking hakbang pasulong at pagkatapos ay isang maliit na hakbang paatras paulit-ulit.

Kapag na-average mo ang lahat, ang pag-uugali ng pagsingil ng isang kapasitor gamit ang PWM ay eksaktong kapareho ng kung gumamit ka ng isang matatag na boltahe ng Vpwm upang singilin ang capacitor. Tumatagal pa rin ito ng humigit-kumulang 5 segundo ng RC para sa amin upang makakuha ng "sapat na malapit" sa nais na boltahe.

Hakbang 7: Kumuha ng Mula sa hanggang B, isang Tad Bit Mas Mabilis

Ipagpalagay na mayroon kaming isang capacitor na nasingil na hanggang sa Va. Ipagpalagay na gumagamit kami ng analogWrite () upang isulat ang bagong halaga ng b. Ano ang minimum na dami ng oras na kailangan mong maghintay para makamit ang boltahe Vb?

Kung nahulaan mo ang 5 RC segundo, mahusay iyon! Sa pamamagitan ng paghihintay ng 5 RC segundo, sisingilin ang capacitor sa halos halos Vb. Ngunit kung nais natin, maaari tayong maghintay nang kaunti nang kaunti.

Tingnan ang curve ng singil. Kita mo, ang capacitor ay nasa Va nang magsimula kami. Nangangahulugan ito na hindi namin kailangang maghintay ng oras t_a. Magagawa lamang namin kung singilin namin ang capacitor mula sa zero.

Kaya sa pamamagitan ng hindi paghihintay sa oras na iyon, nakakakita kami ng isang pagpapabuti. Ang oras na t_ab ay talagang medyo mas maikli sa 5 RC.

Ngunit hawakan, magagawa natin nang mas mahusay! Tingnan ang lahat ng puwang sa itaas ng v_b. Iyon ang pagkakaiba sa pagitan ng Vcc, ang maximum na magagamit na boltahe sa amin, at ang Vb na balak nating maabot. Maaari mo bang makita kung paano makakatulong ang labis na boltahe na iyon upang makarating tayo sa lugar na nais naming mapabilis?

Hakbang 8: Kumuha ng Mula sa isang B, Gamit ang isang Turbo Charger

Tama iyan. Sa halip na gamitin ang PWM sa target na boltahe V_b, hinahawakan namin ito sa isang matatag na Vcc para sa isang mas, mas maikli na tagal ng panahon. Tinatawag ko ito na Turbo Charger na pamamaraan at dadalhin tayo sa kung saan namin nais pumunta talaga, napakabilis! Matapos ang pagkaantala ng oras (na dapat nating kalkulahin), isinasara namin ang mga preno sa pamamagitan ng paglipat sa PWM sa V_b. Pinipigilan nito ang boltahe mula sa pag-overshooting ng target.

Sa pamamaraang ito, posible na baguhin ang boltahe sa capacitor mula sa V_a hanggang V_b sa isang maliit na bahagi ng oras kaysa sa paggamit ng PWM lamang. Ito ay kung paano ka makakakuha ng mga lugar, sanggol!

Hakbang 9: Maunawaan ang Code

Ang isang larawan ay nagkakahalaga ng isang libong mga salita, sa gayon ang diagram ay nagpapakita ng data at mga pagpapatakbo na isinasagawa sa code. Mula kaliwa hanggang kanan:

• Ang data ng graphics ay nakaimbak sa PROGMEM (iyon ay, flash memory) bilang isang listahan ng mga puntos.
• Ang anumang kumbinasyon ng mga pagpapatakbo ng pagsasalin, pag-scale at pag-ikot ay pinagsama sa isang affine transformation matrix. Ginagawa ito nang isang beses sa simula ng bawat frame ng animation.
• Ang mga puntos ay binabasa nang isa-isa mula sa data ng graphics at pinarami ng bawat naka-imbak na matrix ng pagbabago.
• Ang mga nabago na puntos ay pinakain sa pamamagitan ng isang scissoring algorithm na nagtatanim ng anumang mga puntos sa labas ng nakikitang lugar.
• Gamit ang isang talahanayan ng pagtingin sa pagkaantala ng RC, ang mga puntos ay na-convert sa mga boltahe sa pagmamaneho at pagkaantala ng oras. Ang mesa ng pagkaantala sa pagkaantala ng RC ay nakaimbak sa EEPROM at maaaring magamit muli para sa maraming mga pagpapatakbo ng code. Sa pagsisimula, ang talahanayan ng pagtingin sa RC ay nasuri para sa kawastuhan at ang anumang maling halaga ay na-update. Ang paggamit ng EEPROM ay nakakatipid ng mahalagang memorya ng RAM.
• Ang mga voltages at pagkaantala sa pagmamaneho ay nakasulat sa hindi aktibong frame sa frame buffer. Naglalaman ang buffer ng frame ng puwang para sa isang aktibong frame at isang hindi aktibong frame. Kapag nakasulat na ang isang kumpletong frame, ang aktibong frame ay ginawang aktibo.
• Ang isang nakakagambala na gawain na regular na patuloy na muling kumukuha ng larawan sa pamamagitan ng pagbabasa ng mga halaga ng boltahe at pagkaantala mula sa aktibong frame buffer. Batay sa mga halagang iyon, inaayos nito ang mga duty-cycle ng mga output pin. Ginagamit ang timer 1 para sa pagsukat ng oras na pagkaantala sa ilang mga nanosecond ng katumpakan, habang ang timer 2 ay ginagamit para sa pagkontrol sa cycle ng tungkulin ng mga pin.
• Ang pin na may pinakamalaking pagbabago sa boltahe ay palaging "turbo charge" na may duty-cycle na zero o 100%, na nagbibigay ng pinakamabilis na pagsingil o paglabas ng oras. Ang pin na may isang maliit na pagbabago sa boltahe ay hinihimok na may isang cycle ng tungkulin na pinili upang tumugma sa oras ng paglipat ng unang pin-this time na pagtutugma ay mahalaga upang matiyak na ang mga linya ay iginuhit nang diretso sa oscilloscope.

Hakbang 10: Sa Mahusay na Bilis, Dumating ang Mahusay na Pananagutan

Dahil ang pamamaraang ito ay napakabilis kaysa sa PWM, bakit hindi ito ginagamit ng analogWrite ()? Kaya, dahil ang paggamit ng PWM lamang ay sapat na mabuti para sa karamihan ng mga programa at higit na mapagpatawad. Gayunpaman, ang pamamaraan na "Turbo Charger" ay nangangailangan ng maingat na pag-coding at angkop lamang para sa mga tukoy na kaso:

1. Ito ay lubos na sensitibo sa tiyempo. Kapag naabot na namin ang antas ng target na boltahe, ang pin na pagmamaneho ay dapat agad na ilipat sa regular na mode na PWM upang maiwasan ang sobrang pag-overshooting ng target na boltahe.
2. Nangangailangan ito ng kaalaman sa pare-pareho sa RC, kaya dapat ipasok muna ang mga halagang ito. Sa mga maling halaga, ang tiyempo ay magiging mali at ang mga voltages ay hindi wasto. Sa regular na PWM, mayroong isang garantiya na ikaw ay tumira sa tamang boltahe pagkatapos ng ilang oras, kahit na ang RC pare-pareho ay hindi alam.
3. Ang pagkalkula ng tumpak na agwat ng oras para sa pagsingil ng kapasitor ay nangangailangan ng mga equation na logarithmic na masyadong mabagal para sa real-time na pagkalkula sa Arduino. Ang mga ito ay dapat na paunang kalkulahin bago ang bawat frame ng animation at i-cache sa memorya sa kung saan.
4. Ang mga programang pakikitungo sa pamamaraang ito ay dapat na makipaglaban sa katotohanang ang mga pagkaantala ay napaka-hindi linear (sila, sa katunayan, exponential). Ang mga target na voltages na malapit sa Vcc o GND ay kukuha ng mas maraming order ng lakas na maabot kaysa sa mga voltages na malapit sa midpoint.

Upang mapagtagumpayan ang mga limitasyong ito, ginagawa ng aking vector graphics code ang mga sumusunod na bagay:

1. Gumagamit ito ng Timer 1 sa 16kHz at isang nakakagambala na gawain sa serbisyo para sa tumpak na pagmamanipula at tiyempo ng output.
2. Nangangailangan ito ng isang tiyak na halaga ng pare-pareho ang oras ng RC upang magamit, nililimitahan ang mga pagpipilian ng mga halaga ng capacitor at resistor.
3. Iniimbak nito ang mga pagkaantala ng oras para sa lahat ng mga puntos sa isang frame ng animation sa isang buffer ng memorya. Nangangahulugan ito na ang nakagawiang pagkalkula ng pagkaantala ng oras ay tumatakbo sa isang mas mabagal na rate kaysa sa nakakagambala na gawain sa serbisyo na ina-update ang mga output pin. Ang anumang naibigay na frame ay maaaring lagyan ng kulay ng dosenang beses bago ang isang bagong hanay ng mga pagkaantala para sa susunod na frame ay handa nang gamitin.
4. Ang paggamit ng isang memory buffer ay naglalagay ng isang hadlang sa bilang ng mga puntos na maaaring iguhit sa bawat frame. Gumagamit ako ng isang mahusay na pag-encode ng puwang upang masulit ang magagamit na RAM, ngunit limitado pa rin ito sa halos 150 puntos. Higit pa sa isang daang mga punto o higit pa, ang display ay magsisimulang kumurap pa rin, kaya't ito ay isang punto ng moot!