Ang Algorithm Machine: 13 Hakbang (na may Mga Larawan)

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

Nagtuturo ako ng computer science sa antas ng kolehiyo sa loob ng 15 taon, at kahit na ang aking kadalubhasaan ay higit sa panig ng programa, gumugugol pa rin ako ng maraming oras sa pagtakip sa mga karaniwang algorithm para sa paghahanap at pag-uuri. Mula sa isang pananaw sa pagtuturo ang sentral na isyu ay ang pagiging kumplikado ng computational: gaano karaming oras ang kinakailangan ng bawat algorithm, na binigyan ng input ng isang partikular na laki? Ngunit maraming mga nuances. Halimbawa, ang mga algorithm ba ay may iba't ibang mga runtime depende sa mga tukoy na halaga ng pag-input (taliwas sa laki)? Sa aling mga kaso pipiliin mo ang isang pag-uuri ng algorithm kaysa sa isa pa? Bagaman tinatalakay namin ang mga isyung ito sa abstract, palaging naka-plug sa akin na walang madaling paraan upang makita kung paano gumagana ang iba't ibang mga algorithm sa ilalim ng iba't ibang mga kundisyon.

Mga Layunin

Ang aking buong layunin sa proyektong ito ay upang lumikha ng isang interactive na pagpapakita para sa mga mag-aaral na mailarawan at galugarin ang mga algorithm. Nilimitahan ko ang aking sarili sa mga algorithm na gumagana sa mga array ng mga halaga (integer), kaya maaari kong gamitin ang isang address na RGB LED strip upang mailarawan ang mga nilalaman ng array. Ang array ay may 100 elemento, at ang bawat integer ay nai-map sa isang kulay sa pagkakasunud-sunod ng bahaghari, upang agad na halata kapag ang array ay pinagsunod-sunod, bahagyang pinagsunod-sunod, o na-random. Bilang karagdagan sa mga halaga, gayunpaman, nais ko ng isang paraan upang mailarawan ang mga aspeto ng kontrol ng algorithm - halimbawa, kung aling mga elemento ng array ang kasalukuyang inihahambing o ipinagpapalit.

Ang mga tukoy na layunin ay:

- Magbigay ng iba't ibang mga paghahanap at pag-uuri ng mga algorithm

- Mailarawan ang mga halaga sa array sa isang paraan na nagha-highlight sa pag-unlad ng algorithm

- Mailarawan ang kontrol sa algorithm; sa partikular, ang mga elemento na isinasaalang-alang.

- Payagan ang mga gumagamit na piliin ang mga pattern ng pag-input ng data sa halip na palaging bumubuo ng mga random na halaga

- Payagan ang mga gumagamit na kontrolin ang bilis at i-pause ang algorithm

- Payagan ang mga gumagamit na pilitin ang pinakamahusay na kaso, pinakamasamang kaso, average-case na pag-uugali (tukoy sa algorithm)

- Ipakita ang bilang ng mga hakbang habang nagpapatuloy ang algorithm

Pagpapakita

Mula sa isang pananaw sa pisikal na disenyo ang pinaka-kagiliw-giliw na bahagi ng proyektong ito ay ang pagpapakita ng array. Nagpumilit ako kung paano ipakita ang data at kontrol, at kung paano mabuo ang mismong aparato sa pagpapakita. Ang aking layunin ay ipakita ang mga halaga ng data bilang mga may kulay na bilog at ang mga control point bilang mga may kulay na arrow na tumuturo sa mga halaga ng data. Matapos ang ilang pag-eksperimento naayos ako sa isang disenyo na may dalawang parallel strips ng 100 RGB LEDs (WS2812) na may isang pabilog na maskara sa bawat data LED at isang tatsulok na maskara sa bawat control LED. Gumawa ako ng isang 3D na modelo ng mask na may 10 pares ng mga bilog at tatsulok, at pagkatapos ay naka-print ang 3D ng 10 ng mga modyul na ito para sa isang kabuuang 100 mga bilog at 100 mga tatsulok. Ang laki at spacing ng aking mask ay idinisenyo para sa mga piraso na may 100 LEDs bawat metro. Ang mga file ng modelo ng 3D ay ibinigay sa paglaon sa paglalarawan na ito.

Elektronika at enclosure

Ang natitirang aparato ay prangka, mula sa pananaw ng electronics. Bilang karagdagan sa dalawang LED strips, mayroong isang pangkat ng mga pansamantalang pindutan, isang rotary encoder (para sa control ng bilis), at isang 7-segment na display (upang ipakita ang mga hakbang). Sa napakaraming mga pindutan at kontrol na pinili ko upang gumamit ng isang ESP32 microcontroller dahil inilalantad nito ang maraming mga pin at dahil medyo malakas ito. Pupunta ako sa diskarte sa mga kable, ngunit ito ay medyo batayan. Marahil ay maaaring gumawa ka ng isang bagay na matalino sa mga rehistro ng shift kung nais mong gumamit ng mas kaunting mga pin.

Maaari mong buuin ang enclosure para sa aparatong ito sa maraming iba't ibang mga form. Una kong naisip ito bilang isang malaking hugis-parihaba board na may LED strip sa tuktok, at isang grid ng mga pindutan sa gitna. Ang form na natapos ko ay binigyang inspirasyon ng isang uri ng pagtingin ng 1960 sa teknolohiyang pang-space. Maaari mo ring buuin ito sa mga LED strips sa isang patayong oryentasyon. O gawing mas malaki ang bahagi ng LED - punan ang isang buong pader - na may isang hiwalay na control panel.

Software

Ang code para sa aparatong ito ay malayang magagamit sa GitHub, at nagawa ko ang aking makakaya upang idokumento kung paano ito gumagana at kung paano ito mai-configure. Ang tanging panlabas na library na kailangan mo ay FastLED upang himukin ang mga WS2812 strips.

Mga gamit

Elektronika

1 ESP32 development board (hal., 2 WS2812 o katulad na LED strips, density 100 LEDs per meter (hal., 1 Button na "pagsisimula" ng tatsulok (hal., 12 Mga sandali na sandali (hal., Https://amzn.com/B01N4D4750) - iba't ibang mga hugis kung nais mo

1 Pack (20) mga naka-link na naka-pindutan na prewired (hal., 1 Mga konektor ng JST Pack (hal., 1 Rotary encoder (hal., 1 Knob para sa rotary encoder (hal., 1 Mga konektor ng Dupont na pack (hal., Https://amzn.com/B014YTPFT8) - sulit na makuha din ang crimping tool.

1 Barrel jack (para sa lakas) (hal., 1 TM1637 7-segment na numeric display (hal., Mga gamit sa paghihinang at mga kable

Mga file ng modelo ng 3D

Mahahanap mo ang 3D na modelo para sa isang pares ng 10-light module sa Thingiverse:

www.thingiverse.com/thing[178181

Kakailanganin mong i-print ang modelong ito ng limang beses para sa isang kabuuang 10 mga module.

Software

github.com/samguyer/AlgorithmMachine

Enclosure

Kahoy, plexiglass, hindi kinakalawang na asero bolts at turnilyo

Materyal ng pagsasabog. Ang paborito ko ay Lee Filters # 216 buong puting pagsasabog, ngunit may iba pang mga pagpipilian. Kahit na ang puting puting papel ay may mahusay na trabaho.

Hakbang 1: Mga Algorithm 101

Maraming mga tao ang nag-iisip na ang computer science ay mahalagang pag-aaral ng programa. Ngunit ang totoong puso at kaluluwa ng larangang ito ay mga algorithm: ang pag-aaral ng sistematikong mga pamamaraan para sa paglutas ng mga problema at ang kanilang gastos (karaniwang, kung gaano katagal sila tumatagal). Ang mga semi figure sa larangan, tulad ng Alan Turing, Alonzo Church, at Edsger Dijkstra, ay nag-iisip tungkol sa mga ideyang ito bago alam ng mga computer na mayroon din sila.

Ang pangunahing tampok ng isang algorithm upang malutas ang isang partikular na problema ay ito ay detalyado at tumpak, upang ang isang tao ay maaaring gamitin ito upang makakuha ng isang solusyon nang hindi nauunawaan kung paano ito gumagana sa lahat; sundin lamang ang mga hakbang sa isang mekanikal na paraan at makakakuha ka ng tamang sagot. Maaari mong makita kung paano ito nakakatulong sa mga computer sa pag-program, dahil kailangan nila ang antas ng detalyeng ito. Hindi maaaring punan ng isang computer ang mga nawawalang detalye o gumawa ng mga paghuhusga, sa paraang kaya ng isang tao.

Gaano ito katagal?

Kapag mayroon kaming isang detalyadong pamamaraan isang natural na katanungan ay gaano katagal bago makuha ang sagot? Hindi namin maaaring gamitin ang mga ordinaryong yunit ng oras, dahil depende ito sa kung sino ang gumagawa ng trabaho (ihambing kung gaano kabilis makalkula ng isang tao ang isang bagay kumpara sa isang supercomputer). Bilang karagdagan, depende ito sa kung magkano ang data na mayroon kami. Malinaw, mas matagal bago maghanap ng isang listahan ng isang milyong mga numero ng telepono kaysa sa isang listahan ng isang daang.

Upang ilarawan ang gastos ng isang algorithm pumili muna kami ng ilang operasyon sa pamamaraan na kumakatawan sa isang "hakbang" - karaniwang isang bagay na simple, tulad ng paghahambing o pagdaragdag ng dalawang numero, na tumatagal ng isang nakapirming dami ng oras upang gawin. Pagkatapos ay nakakakuha kami ng isang pormula na naglalarawan kung gaano karaming mga hakbang ang gagawin ng algorithm na binigyan ng ilang bilang ng mga item sa data. Para sa mga kadahilanang pangkasaysayan, halos palaging ipinapahiwatig namin ang bilang ng mga item ng data na may kapital na N.

Halimbawa, ang pagtingin sa isang listahan ng mga numero ng telepono ng N ay tumatagal ng mga N hakbang. Ang pagtingin sa listahan ng dalawang beses ay tumatagal ng 2N na mga hakbang. Parehong ito ay tinatawag na mga linear time algorithm - ang kabuuang bilang ng mga hakbang ay ilang maramihang laki ng pag-input. Ang iba pang mga algorithm ay quadratic (N squared time) o cubic (N cubed) o logarithmic (log N) o ilang kombinasyon ng mga ito. Ang ilan sa mga pinaka mahirap na problema sa computational ay nangangailangan ng exponential time algorithms (2 ^ N).

OK, kaya ano?

Kapag ang bilang ng mga item ng data na N ay maliit na hindi mahalaga. Halimbawa, para sa N = 10, 10N ang pangalang iyon bilang N na parisukat. Ngunit paano ang tungkol sa N = 1000? o N = 1000000? Ang isang milyong parisukat ay isang medyo malaking bilang. Kahit na sa isang napakabilis na computer, ang isang quadratic algorithm ay maaaring tumagal ng isang mahabang oras kung ang input ay sapat na malaki. Ang mga expponential algorithm ay mas mahirap: para sa N = 50 ang isang exponential algorithm ay tatagal ng dalawang linggo upang matapos kahit sa isang computer kung saan ang bawat hakbang ay isang nanosecond lamang (1 bilyon ng isang segundo). Ouch!

Sa kabilang dulo ng sukat mayroon kaming mga logarithmic time algorithm, na napakabilis. Ang oras ng pag-log ay kabaligtaran ng exponential time: ibinigay ang laki ng pag-input N, ang bilang ng mga hakbang ay ang exponent na T sa pormula 2 ^ T = N. Halimbawa, kung ang laki ng aming pag-input ay isang bilyon, ang isang algorithm ng oras ng pag-log ay nangangailangan lamang ng 30 mga hakbang, mula noong 2 ^ 30 = 1, 000, 000, 000. Gaano ito katamis?! ??!

Maaaring nagtataka ka, sino ang nagmamalasakit sa mga laki ng pag-input na milyon-milyon o bilyun-bilyon? Pag-isipan ito: ilan ang mga gumagamit doon sa Facebook? Ilan sa mga web page ang na-index ng Google? Ilan sa mga pares ng base ang mayroon sa genome ng tao? Gaano karaming mga sukat ang pumunta sa isang simulate ng panahon?

Hakbang 2: Ang Mga Algorithm

Kasalukuyang nagpapatupad ang Algorithm Machine ng mga sumusunod na algorithm. Ang dalawa sa mga ito ay mga algorithm sa paghahanap (maghanap ng isang partikular na halaga sa listahan), ang natitira ay pag-uuri ng mga algorithm (ilagay ang mga halaga sa pagkakasunud-sunod).

Linear na paghahanap

Paghahanap sa listahan ng mga halagang isa-isa simula sa simula. Nangangailangan ng linear na oras.

Paghahanap ng binary

Maghanap ng isang listahan sa pamamagitan ng paulit-ulit na paghati nito sa kalahati. Nangangailangan ng oras ng pag-log, ngunit dapat ayusin ang listahan upang gumana ito.

Pag-uuri ng bubble

Pagbukud-bukurin ang isang listahan ng paulit-ulit na pakikipagpalitan ng mga kalapit na elemento na hindi maayos. Nangangailangan ng quadratic na oras.

Pag-uuri ng uri

Pagbukud-bukurin ang isang listahan sa pamamagitan ng paglalagay ng bawat elemento sa tamang lugar nito sa listahan ng mga nakaayos na halaga. Nangangailangan ng quadratic na oras.

Quicksort

Pagbukud-bukurin ang isang listahan sa pamamagitan ng paulit-ulit na paghati sa listahan sa kalahati at ilipat ang lahat ng mga halagang mas mababa kaysa sa panggitna sa unang kalahati, at lahat ng mga halagang mas malaki kaysa sa panggitna sa ikalawang kalahati. Sa pagsasagawa, hindi namin mahusay na makahanap ng median, kaya pumili kami ng isang halaga nang sapalaran. Bilang isang resulta ang algorithm na ito ay maaaring maging quadratic sa pinakamasamang kaso, ngunit karaniwang nangangailangan ng N * logN na oras.

Sumanib-uuri

Pagbukud-bukurin ang isang listahan sa pamamagitan ng paghahati nito sa kalahati, pag-uuri-hiwalayin ang dalawang halves (gamit ang pagsasama-sama ng pagsasama), at pagkatapos ay pagsasama-sama ng mga ito sa pamamagitan ng pag-interleve ng mga halaga. Palaging nangangailangan ng oras ng N * logN.

Magbunton ng uri

Pagbukud-bukurin ang isang listahan sa pamamagitan ng pagbuo ng isang istraktura ng data na tinatawag na isang bunton, na nagbibigay-daan sa iyo upang makahanap ng pinakamaliit na halaga sa oras ng pag-log. Palaging nangangailangan ng oras ng N * logN.

Bitonic sort

Katulad ng pagsasama-sama ng uri at quicksort, hatiin ang isang listahan sa kalahati, pag-uri-uriin ang mga kalahati, at muling pagsamahin ang mga ito. Nangangailangan ang algorithm na ito ng N * logN * oras ng pag-logN, ngunit may kalamangan na madali itong i-parallelize.

Hakbang 3: LED Bar: 3D I-print ang Mask

Ang unang hakbang sa pagbuo ng LED bar ay ang 3D i-print ang mask na nagbibigay sa mga ilaw ng kanilang hugis. Saklaw ng bawat module ang sampung elemento ng array, 10 halaga (bilog) at 10 tagapagpahiwatig (triangles), kaya kakailanganin mo ng 10 module ang kabuuan. Ang STL file na ibinibigay ko dito ay naglalaman ng dalawang mga pagkakataon ng module, kaya kakailanganin mong gawin ang limang print cycle. Wala akong pinakamahusay na 3D printer, kaya't kailangan kong gumawa ng manu-manong paglilinis sa kanila gamit ang isang file at liha. Ang pinakamahalagang bagay ay ang mga bilog at tatsulok na butas ay malinis.

Sa mga larawan makikita mo ang aking pag-set up ng pagsubok: Nai-tap ko ang dalawang LED strips at isinama ang mga ito sa isang breadboard na may isang microcontroller. Ang hakbang na ito ay hindi kinakailangan, ngunit nais kong makita kung paano ito magmukha bago ako magsimulang tipunin ang enclosure. Pinila ko ang mga module ng maskara sa dalawang LED strips at nagpatakbo ng isang simpleng sketch na may mga random na kulay. Sa pamamagitan ng isang strip ng diffusion material ang mga hugis at kulay ay talagang pop.

Hakbang 4: Mga Alternatibong LED Bar

Noong una kong pagsisimula sa proyektong ito nag-eksperimento ako sa iba pang mga paraan ng paggawa ng LED mask. Kung wala kang isang 3D printer maaari mong isaalang-alang ang isa sa mga pagpipiliang ito. Magtatapat ako: napakalaking sakit na gawin ang mga bahaging ito.

Para sa mga bilog, bumili ako ng isang 13/32 tanso na tubo, na halos eksaktong 1cm ang lapad. Pinutol ko ito sa isang daang 1cm na mga segment at pagkatapos ay spray ang pininturahan ng puti.

Para sa mga triangles, gumamit ako ng mabibigat na aluminyo na foil na hiwa mula sa isang disposable baking pan. Gumawa ako ng isang tatsulok na form mula sa kahoy, pagkatapos ay binalot ng maikling piraso ng foil sa paligid ng form at nai-tape ang mga ito. Muli, kakailanganin mo ang isang daang mga bagay na ito, kaya't tumatagal ng ilang oras at pasensya.

Hakbang 5: LED Bar Enclosure

Ang aking enclosure ay medyo simple: dalawang piraso ng kahoy para sa mga gilid at dalawang piraso ng plexiglass para sa itaas at ibaba. Ang lahat ng mga bahagi ay tungkol sa 102cm ang haba (1 metro para sa mga LED, kasama ang isang maliit na labis upang mapaunlakan ang mga kable). Ang mga gilid ay dapat na isang maliit na mas mataas kaysa sa 1cm upang makagawa ng puwang para sa mga LED strips. Matapos i-cut ang mga piraso ay sinampay ko ang 3D na naka-print na mga piraso ng mask sa pagitan nila upang masukat ang lapad para sa plexiglass. Gupitin ang dalawang piraso ng plexiglass ang lapad at haba ng bar. Sa wakas, gupitin ang isang strip ng materyal na pagsasabog upang magkasya sa maskara.

Para sa pagsasabog gusto ko talaga ang Lee Filters # 216 (buong puting pagsasabog). Ito ay isang manipis na plastic sheet na nagbibigay ng kahit na pagsasabog nang hindi nawawalan ng maraming ilaw. Ngunit ito ay mamahaling bagay. Minsan maaari kang makahanap ng mas maliit na mga sheet para sa pagbebenta online, ngunit ang isang buong roll ay magbabalik sa iyo ng halos $ 125. Ang ilang iba pang mga pagpipilian ay puting papel o anumang iba pang uri ng satin o frosted na plastik. Ang isang tanyag na pagpipilian ay manipis na mga plastic cutting mat.

Bago mo tipunin ang LED bar siguraduhing mayroon kang mga naaangkop na konektor na solder sa mga LED strips. Maraming mga piraso ang may mga lead na paunang hinang, upang maaari mo lamang gamitin ang mga iyon.

Sinimulan ko ang pagpupulong sa pamamagitan ng pag-screw sa tuktok na piraso ng plexiglass papunta sa mga gilid na kahoy (tingnan ang larawan). Pagkatapos ay binaligtad ko ito at inilagay ang diffusion strip, sinundan ng 10 piraso ng maskara. Sa sandaling natuwa ako sa spacing ay na-pin ko sila sa lugar na may ilang mga tuldok ng mainit na pandikit.

Susunod, itabi ang dalawang LED strips magkatabi sa tuktok ng mga maskara. Siguraduhin na ang mga LED ay nakaharap at tiyakin na ang bawat linya ng LED ay pataas na may kaukulang butas sa maskara. Magdagdag ng ilang maiinit na pandikit o tape upang hawakan ang mga LED strip. Panghuli, tornilyo sa likod na piraso ng plexiglass.

Patakbuhin ang isang pattern ng pagsubok. Ang ganda ng trabaho! Nagawa mo ang pinakamahirap na bahagi!

Hakbang 6: Control Panel

Ang control panel ay ang bahagi na nagbibigay ng pinaka malikhaing kalayaan. Kailangan lamang na hawakan ang lahat ng mga kontrol at electronics, kasama ang LED bar. Ang pinakasimpleng disenyo ay isang hugis-parihaba board: drill hole para sa mga pindutan at kontrol, at ilakip ang LED bar. Gusto kong pagsamahin ang kahoy, plexiglass, at iba pang mga materyales upang magbigay ng isang uri ng steampunk / retro-modernong hitsura. Sa kasong ito, pinutol ko ang isang piraso ng mabigat na tungkulin na plexiglass upang hawakan ang pangunahing mga pindutan ng pagpipilian ng algorithm, at isang kahoy na bar upang hawakan ang natitirang electronics. Nag-drill ako ng mga butas upang maitugma ang laki ng mga arcade button. Nagpapakita ang mga kable sa likuran, ngunit gusto ko ito!

Nag-drill din ako ng puwang para sa 7-segment display, ang rotary encoder, at ilan sa mga kable sa likuran. Pinutol ko ang isang dado sa itaas upang hawakan ang LED bar.

Hakbang 7: Harness ng Button

Ang kable ng maraming mga pindutan ay maaaring maging isang tunay na sakit. Sa kabutihang palad, ang mga tao na gumawa ng mga arcade machine ay nakakuha ng ilang mga karaniwang konektor na maaari mong gamitin. Ang bawat pindutan ng cable ng konektor ay may dalawang mga wire, isa para sa VCC at isa para sa lupa. Ang isang dulo ay may mga konektor ng pala na umaangkop sa mga lead sa likod ng pindutan - ikabit ang lupa sa "karaniwang bukas" na lead, at VCC sa "karaniwang" tingga. Sa pagsasaayos na ito, kapag itinulak ng gumagamit ang pindutan, nakumpleto ang circuit at babasahin ng microcontroller ang TAAS sa kaukulang input pin.

Ang kabilang dulo ng cable ay mayroong konektor ng JST (ang maliit na puting bagay). Ano ang maganda sa mga konektor na ito ay pumupunta lamang sila sa sisidlan sa isang paraan, kaya walang paraan upang aksidenteng baligtarin ang VCC at ground.

Ang ginawa ko ay bumuo ng isang maliit na harness para sa mga konektor na ito. Naghinang ako ng isang serye ng mga container ng JST sa isang piraso ng protoboard at pagkatapos ay patakbuhin ang mga wire pabalik sa mga konektor ng Dupont na isasaksak ko sa microcontroller. Ang pulang kawad ay ang linya ng VCC, at kumokonekta ito sa lahat ng mga container ng JST. Ang mga asul na wires ay ang mga na hiwalay para sa bawat pindutan.

Hakbang 8: Rotary Encoder

Hinahayaan ng rotary encoder ang gumagamit na kontrolin ang bilis ng algorithm. Gumagamit ako ng isang module na dumarating bilang isang breakout board na may kasamang mga pull-up resistor para sa dalawang linya ng data (mga dilaw na wires). Ang isang ito ay nangyari din na isang pindutan, ngunit hindi ko ginagamit ang tampok na iyon. Ang dalawa pang wires ay ang VCC at ground. Nakakuha rin ako ng isang magandang knob na taba.

Ang gusto ko tungkol sa isang rotary encoder, taliwas sa isang potensyomiter, ay signal lang ng pag-ikot (pakaliwa kumpara sa pag-orasan) sa microcontroller, kaya madaling baguhin kung paano binibigyang kahulugan ang halaga. Halimbawa, maaari mong bigyan ito ng isang pakiramdam ng pagpapabilis (tulad ng isang mouse) kapag ang gumagamit ay mabilis na umiikot nito.

Hakbang 9: 7-segment na Display

Hindi maraming sasabihin dito. Ang mga bagay na ito ay saanman. Ang mga LED ay kinokontrol ng isang maliit na tilad na tinatawag na TM1637, na nakikipag-usap sa microcontroller sa pamamagitan ng isang simpleng serial protocol. Gumagamit ako ng isang mayroon nang silid-aklatan na hinahayaan akong sabihin dito kung anong numero ang nais kong ipakita, at ginagawa nito ang iba pa.

Ang likod ay may apat na pin: VCC, ground, at dalawang wires para sa serial protocol. Naghinang ako ng isang 4-pin na piraso ng header, na kumokonekta sa isang kaukulang konektor ng Dupont na naka-wire sa microcontroller.

Hakbang 10: Pangunahing Lupon ng Controller

Ang pangunahing board ng controller ay matatagpuan ang microcontroller mismo at lahat ng mga konektor sa mga kontrol (mga pindutan, display, LED). Ang microcontroller ay isang ESP32, na nagbibigay ng maraming kapangyarihan sa computing at memorya, at inilalantad ang maraming mga pin. Ang mga kable ay medyo pamantayan, ngunit ituturo ko ang ilang mga kagiliw-giliw na piraso.

TANDAAN: Maaari mong tingnan ang code (https://github.com/samguyer/AlgorithmMachine) bago mo simulan ang mga kable sa pangunahing board, upang ang iyong pagsasaayos ng pin ay tumutugma sa akin.

Naghinang ako ng isang jack jack sa board para sa lakas, at kumonekta sa dalawang malakas na mga wire ng tanso sa lakas at ground rails ng board. Ang dahilan ay ang LED bar ay maaaring gumuhit ng maraming lakas kung ang ilaw ay itinakda nang mataas, at hindi ko nais na hilahin ang lahat ng kapangyarihan na iyon sa pamamagitan ng USB konektor sa microcontroller.

Upang gawing simple ang mga kable ng pindutan ay naghinang ako ng isang strip ng male-to-female kanang anggulo header pababa sa buong bahagi ng microcontroller (itaas na bahagi ng board tulad ng ipinakita). Ang mga konektor ng Dupont mula sa plug ng harness button ay direkta sa header na ito.

MAHALAGA: ang lakas para sa mga pindutan (ang pulang kawad) ay dapat na konektado sa linya ng kuryente na 3.3V sa microcontroller. Ang ESP32 ay isang 3.3V chip, kaya ang mga mapagkukunan lamang ng 3.3V ay dapat na maiugnay sa mga pin ng data.

Ang microcontroller ay kumukuha ng lakas (o itinutulak ang lakas) sa mga daang-bakal (ibabang bahagi ng board tulad ng ipinakita) sa pamamagitan ng 5V USB pin at lupa. Ang lahat ng iba pang mga pula / itim na wires ay VCC at ground.

Ang dalawang asul na mga wire ay ang mga linya ng data para sa mga LED strips (ang WS2812s). Ang dilaw / berdeng pares ay ang mga linya ng data para sa rotary encoder, at ang dilaw na pares ang serial na koneksyon sa 7-segment na display.

Hakbang 11: Assembly

Ipinapakita ng seryeng ito ng mga larawan ang pangwakas na pagpupulong at mga kable. Inilakip ko rin ang pangunahing board ng controller sa likuran sa tuktok.

Bago paandarin ito ay gumawa ako ng ilang mga tseke upang maiwasan ang anumang mga hindi magandang sorpresa. Sa partikular, upang matiyak na wala akong anumang kapangyarihan / ground konektor paatras, at walang mga maikling circuit. Itakda ang iyong multimeter upang subukan para sa pagpapatuloy - ito ay beep kapag mayroong isang de-koryenteng landas sa pagitan ng dalawang lead. Maglakip ng isang tingga sa karaniwang linya ng VCC sa mga pindutan. Pagkatapos ay i-attach ang isa pang lead sa bawat pin ng harness isa-isa. Ang multimeter ay dapat na beep lamang kapag pinindot mo ang pindutan. Kung nakakuha ka ng anumang iba pang mga beep nangangahulugan ito na mayroon kang isang baligtad o isang maikli. Subaybayan ito at ayusin ito bago mo buksan ang lakas!

Hakbang 12: Code

Una, buksan ang iyong Arduino IDE at tiyaking mayroon kang naka-install na FastLED library.

I-download ang code ng Algorithm Machine mula sa GitHub:

github.com/samguyer/AlgorithmMachine.git

Maaari mong mai-clone ito nang direkta sa iyong Arduino folder, o kopyahin ito sa pamamagitan ng kamay.

Bago ito i-upload, tiyaking tumutugma ang mga setting ng pin sa iyong pagsasaayos ng hardware. Inilagay ko ang lahat ng mga setting ng pin sa tuktok ng file.

Mag-upload at mag-enjoy!

Hakbang 13: Paano Gumamit

Ang Algorithm Machine ay simpleng gamitin at halos anumang kombinasyon ng mga pindutan ay ok!

Una, gamitin ang mga pindutan ng data upang simulan ang mga halaga sa array. Mayroong tatlong mga pagpipilian: (1) i-randomize, (2) magdagdag ng isang random na halaga, at (3) baligtarin ang array. Tandaan na ang mga halaga ay nananatili, kaya maaari mong gawin ang mga bagay tulad ng pag-uri-uriin muna ang mga ito, pagkatapos ay magdagdag ng ilang ingay, pagkatapos ay magpatakbo ng ibang pag-uuri o paghahanap ng algorithm.

Pumili ng isang naghahanap o pag-uuri ng algorithm mula sa iba pang mga pagpipilian sa pindutan. Sa kasalukuyan, walang feedback kapag pinili mo ito (isang bagay para sa trabaho sa hinaharap). Pagkatapos ay pindutin ang pindutang "play".

Kinokontrol ng knob ang bilis. Maaari mo ring pindutin ang "play" upang i-pause at i-pause ang algorithm.

Awtomatiko itong titigil kapag tapos na ito. Maaari mo ring pindutin ang isa pang pindutan ng algorithm sa anumang oras. Ititigil ng makina ang kasalukuyang algorithm at ipasimula ang bago, ngunit panatilihin ang data nang eksakto tulad ng naiwan na ng nakaraang algorithm.

Grand Prize sa STEM Contest