Kailangan kong gumawa ng isang bagay na mas malaki kahit papaano. orasan sa dingding na may awtomatikong liwanag.
Ang mga orasan na ito ay perpekto para sa malalaking silid, tulad ng isang pasilyo ng opisina o isang malaking apartment.
Ang paggawa ng gayong malaking orasan sa dingding ay hindi napakahirap gamit ang mga tagubiling ito.
Upang matantya ang laki ng relo, maaari mong ipagpalagay na ang isang segment ng relo ay magiging kasing laki ng A4 na papel, na magpapadali sa paggamit ng mga frame ng larawan na may naaangkop na laki.
Hakbang 1. Mga bahagi ng isang malaking wall clock.
Mga wire, solder, soldering iron, LED strip 
Arduino Nano
DC-DC converter LM2596 
4 metro ng LED strip WS2811 
light sensor 
real time na orasan DS3231 
mga microswitch
Ano ang ginamit ko para sa proyektong ito:
Hakbang 8. Programa ang orasan.
Pagkatapos ng ilang kalikot sa paligid, nakuha ko ang isang relo na ganap na nasiyahan sa aking mga pangangailangan. Sigurado akong mas magaling ka sa akin.
Ang code ay mahusay na nagkomento at hindi ito magiging mahirap para sa iyo na maunawaan ito;
Kung kailangan mong baguhin ang ginamit na kulay ng wall clock, kailangan mong baguhin ang variable sa linya 22 ( int ledColor = 0x0000FF; // Kulay na ginamit (sa hex)). Makakahanap ka ng listahan ng mga kulay at mga hex code ng mga ito sa page: https://github.com/FastLED/FastLED/wiki/Pixel-refe…
Kung mayroon kang mga problema sa pag-download, gamitin ang salamin: http://bit.ly/1Qjtgg0
Maaaring ma-download ang aking huling sketch.
Hakbang 9. Gumawa ng mga numero gamit ang polystyrene.
Batayan ng pamutol 
Ang gumaganang katawan ng pamutol 
Pangkalahatang view pamutol 
Resulta ng pamutol
Gupitin ang bawat segment sa template na naka-print sa simula.
Maaaring i-cut ang polystyrene gamit ang isang matalim na kutsilyo, na medyo mahirap, o gamit ang isang simpleng aparato na ginawa mula sa nichrome wire o string ng gitara at ilang piraso ng OSB board.
Makikita mo kung paano ko ito ginawa sa mga larawan sa itaas.
Upang ma-power ang cutter gumamit ako ng 12v power supply.
Bilang resulta ng pagputol, dapat kang makakuha ng apat na mga segment para sa malaking orasan, isa sa mga ito ay ipinapakita sa larawan.
Hakbang 10. Idikit ang mga numero at takpan ang lahat gamit ang isang diffuser. Ang huling malaking wall clock.
Lumiwanag sa araw 
Lumiwanag sa gabi
Pagkatapos putulin ang lahat ng apat na numero at punto ng wall clock, idikit silang lahat sa karton kasama nito LED strips(Gumamit ako ng double sided tape para mapadali ang proseso)
Upang iwaksi ang mahirap humantong ilaw Gumamit ako ng dalawang sheet ng papel sa ibabaw ng mga numero ng polystyrene. Para sa kaginhawahan at aesthetics, gumamit ako ng A2 size na papel na nakatiklop sa kalahati.
Matapos makumpleto ang lahat ng mga hakbang na ito, inilagay ko ang nagresultang malaking wall clock assembly sa isang katugmang malaking frame ng larawan.
Ang relo na ito ay naging napaka-kahanga-hanga at kapansin-pansin. Sa palagay ko ang gayong malaking orasan sa dingding ay perpektong palamutihan ang maraming mga silid.
Kaya, real time clock. Ang kapaki-pakinabang na maliit na bagay na ito ay nalulutas ang pinakakapaki-pakinabang na mga problemang nauugnay sa oras. Sabihin nating kinokontrol mo ang pagdidilig sa alas-5 ng umaga sa iyong dacha. O ang pag-on at off ng mga ilaw tiyak na sandali. Sa pamamagitan ng petsa maaari kang magsimulang magpainit sa anumang bahay. Ang bagay ay medyo kawili-wili at kapaki-pakinabang. At partikular? Titingnan natin ang real-time na orasan ng DS1302 para sa sikat na platform ng Arduino.
Mula sa artikulong ito matututunan mo ang:
magandang araw, mahal na mga mambabasa harangan ang kip-world! kamusta ka na? Sumulat sa mga komento, interesado ka ba sa robotics? Ano ang ibig sabihin ng paksang ito sa iyo?
Hindi ko mapigilang isipin ito kahit isang minuto. Nangangarap ako at nakikita ko kung kailan tayo sa wakas ay darating sa punto na lahat ay kayang bumili ng personal na robot assistant. Hindi mahalaga kung ano ang gagawin niya, mamulot ng basura, maggapas ng damuhan, maghugas ng kotse.
Naiimagine ko lang kung paano kumplikadong mga algorithm dapat nilang taglayin sa kanilang "utak".
Pagkatapos ng lahat, darating tayo sa punto na mag-flash tayo ng software sa parehong paraan tulad ng sa mga personal na computer. I-download din mga programa sa aplikasyon. Tumahi sa mga braso, binti, baguhin ang mga kuko, manipulator.
Panoorin ang mga pelikulang "I Robot", " Artipisyal na katalinuhan", "Star Wars".
Matagal nang ipinatupad ng mga Hapon ang kanilang mga pagpapaunlad. Bakit tayo mas malala?? Napakaliit ng kasikatan namin. Kaunti lang ang alam kong developer. Mabibilang ko sa daliri ko. Iba ang ginagawa namin. Kami ay mga reseller. Bumili lang kami ng mga ready-made kits, robot, laruan at kung anu-ano pang basura.
Bakit hindi natin ito paunlarin:
O ito:
Tinapos ko ng malakas ang iniisip ko. Pag-usapan natin ang tungkol sa pagkonekta ng DS1302 Real Time Clock Timer sa Arduino.
Real time clock DS1302
Ang Arduino controller ay walang sariling orasan. Samakatuwid, kung kinakailangan, dapat itong dagdagan ng isang espesyal na DS1302 microcircuit.
Para sa power supply, ang mga board na ito ay maaaring gumamit ng sarili nilang baterya, o direktang pinapagana mula sa Arduino board.
Pinout na talahanayan:
Diagram ng koneksyon sa Arduino UNO:
Paraan para sa pagprograma ng Arduino upang gumana sa DS1302
Kinakailangang mag-download ng wastong aklatan mula sa mga mapagkakatiwalaang mapagkukunan.
Binibigyang-daan ka ng library na magbasa at magsulat ng mga real-time na parameter. Nagbibigay ako ng maikling paglalarawan sa ibaba:
#isama
iarduino_RTC BAGAY ( NAME [, RST_OUTPUT [, CLK_OUTPUT [, DAT_OUTPUT ]]] );
// Lumikha ng isang bagay.
Function magsimula();// Pagsisimula ng trabaho RTC module.
Function settime( SEC [, MIN [, HOUR [, DAY [, MONTH [, YEAR [, DAY]]]]]] ); // Pagtatakda ng oras.
Function gettime([ LINE ] ); // Basahin ang oras.
function blinktime ( PARAMETER [FREQUENCY] ); // Nagiging "blink" ang function ng gettime tinukoy na parameter oras.
function panahon ( MINUTO ); // Nagsasaad ng pinakamababang panahon para ma-access ang module sa ilang minuto.
Variable segundo// Ibinabalik ang mga segundo mula 0 hanggang 59.
Variable minuto// Ibinabalik ang mga minuto mula 0 hanggang 59.
Variable oras// Ibinabalik ang mga oras mula 1 hanggang 12.
Variable Oras// Ibinabalik ang mga oras mula 0 hanggang 23.
Variable tanghali// Babalik ng tanghali 0 o 1 (0-am, 1-pm).
Variable araw// Ibinabalik ang araw ng buwan mula 1 hanggang 31.
Variable araw ng linggo// Ibinabalik ang araw ng linggo mula 0 hanggang 6 (0 ay Linggo, 6 ay Sabado).
Variable buwan// Ibinabalik ang buwan mula 1 hanggang 12.
Variable taon// Ibinabalik ang taon mula 0 hanggang 99.
Nagsusulat kami isang simpleng programa. Pagtatakda ng kasalukuyang oras sa RTC module (DS1302):
Arduino
#isama
#isama iarduino_RTCtime(RTC_DS1302, 6, 7, 8); void setup() ( pagkaantala(300); Serial. magsimula(9600); oras. magsimula(); oras. settime(0, 51, 21, 27, 10, 15, 2); // 0 seg, 51 min, 21 oras, Oktubre 27, 2015, Martes void loop() ( kung (millis() % 1000 == 0 ) ( // kung lumipas na ang 1 segundo Serial. println (oras . gettime ( "d-m-Y, H:i:s, D") ); // oras ng pagpapakita pagkaantala(1); // i-pause ng 1 ms para hindi maipakita ang oras ng ilang beses sa 1 ms |
Nagbabasa kasalukuyang panahon mula sa RTC module (DS1302) at output sa "Serial port":
#isama
Magandang hapon, ngayon ay magbabahagi ako ng mga tagubilin para sa paggawa ng orasan na may thermometer ng silid( DIY Arduino na orasan). Ang orasan ay tumatakbo sa Arduino UNO; ang WG12864B graphic screen ay ginagamit upang ipakita ang oras at temperatura. Bilang isang sensor ng temperatura - ds18b20. Hindi tulad ng karamihan sa iba pang mga relo, hindi ako gagamit ng RTS ( Tunay na Oras Orasan), ngunit susubukan kong gawin nang wala itong karagdagang module.
Ang mga Arduino circuit ay nakikilala sa pamamagitan ng kanilang pagiging simple, at sinuman ay maaaring magsimulang mag-aral ng Arduino. Maaari mong basahin ang tungkol sa kung paano ikonekta ang mga aklatan at flash Arduino sa aming artikulo.
Magsimula na tayo.
Upang lumikha ng orasan na ito kakailanganin namin:
Arduino UNO (O anumang iba pa Katugma sa Arduino magbayad)
- Graphic na screenWG12864B
- Sensor ng temperatura ds18b20
- Resistor 4.7 Kom 0.25 W
- Resistor 100 ohm 0.25 W
- Kompartimento ng baterya para sa 4 na baterya ng AA
- Pagtutugma ng kahon
- Magandang file
- Nail polish (itim o kulay ng katawan)
- Ilang manipis na plastik o karton
- De-koryenteng tape
- Pagkonekta ng mga wire
- Circuit board
- Mga Pindutan
- Panghinang na bakal
- Panghinang, rosin
- Double-sided tape
Inihahanda ang graphic screen.
Sa unang sulyap, ang pagkonekta sa screen ay nagdudulot ng maraming problema at kahirapan. Ngunit kung una mong mauunawaan ang kanilang mga uri, ito ay magiging mas madali at mas malinaw. Mayroong maraming mga uri at uri ng mga screen sa ks0107/ks0108 controller. Ang lahat ng mga screen ay karaniwang nahahati sa 4 na uri:
Pagpipilian A: HDM64GS12L-4, Crystalfontz CFAG12864B, Sparkfun LCD-00710CM, NKC Electronics LCD-0022, WinStar WG12864B-TML-T
Pagpipilian B: HDM64GS12L-5, Lumex LCM-S12864GSF, Futurlec BLUE128X64LCD, AZ Displays AGM1264F, Displaytech 64128A BC, Adafruit GLCD, DataVision DG12864-828, Topway LM12, TM428 12864L-2, 12864J-1
Opsyon C: Shenzhen Jinghua Displays Co Ltd. JM12864
Pagpipilian D: Wintek-Cascades WD-G1906G, Wintek - GEN/WD-G1906G/KS0108B, Wintek/WD-G1906G/S6B0108A, TECDIS/Y19061/HD61202, Varitronix/MGLS19262/HD61202
Hindi kumpleto ang listahan, marami sila. Ang pinakakaraniwan at, sa palagay ko, maginhawa ay WG12864B3 V2.0. Ang display ay maaaring konektado sa Arduino sa pamamagitan ng serial o parallel port. Kapag gumagamit sa Arduino UNO, mas mahusay na piliin ang koneksyon sa pamamagitan ng serial port– pagkatapos ay kakailanganin lamang natin ng 3 microcontroller na output, sa halip na hindi bababa sa 13 linya kapag konektado sa pamamagitan ng isang parallel port. Ang lahat ay kumokonekta nang simple. May isa pang nuance: makakahanap ka ng dalawang opsyon sa pagpapakita na ibinebenta, na may built-in na potentiometer (upang ayusin ang contrast) at wala ito. Pinili ko, at ipinapayo ko sa iyo na gawin ang parehong, gamit ang built-in na isa.
Binabawasan nito ang bilang ng mga bahagi at oras ng paghihinang. Ito rin ay nagkakahalaga ng pag-install ng 100 Ohm current limiting resistor para sa backlight. Sa pamamagitan ng direktang pagkonekta ng 5 volts, may panganib na masunog ang backlight.
WG12864B – Arduino UNO
1 (GND) - GND
2 (VCC) - +5V
4 (RS) – 10
5 (R/W) – 11
6 (E) – 13
15 (PSB) – GND
19 (BLA) - sa pamamagitan ng isang risistor - +5V
20 (BLK) – GND
Ang pinaka-maginhawang paraan ay ang tipunin ang lahat sa likod ng screen at ilabas ang 5 wires mula dito na kumokonekta sa Arduino UNO. Ang huling resulta ay dapat magmukhang ganito:
Para sa mga pumili pa rin parallel na koneksyon Magbibigay ako ng isang talahanayan ng koneksyon.
At ang diagram para sa mga screen ng opsyon B:
Ang ilang mga sensor ay maaaring konektado sa isang linya ng komunikasyon. Ang isa ay sapat na para sa aming mga relo. Ikinonekta namin ang wire mula sa "DQ" pin ng ds18b20 hanggang sa "pin 5" ng Arduino UNO.
Inihahanda ang board na may mga pindutan.
Para itakda ang oras at petsa sa relo gagamit kami ng tatlong button. Para sa kaginhawahan, naghinang kami ng tatlong mga pindutan sa circuit board at tinanggal ang mga wire.
Kumonekta kami bilang mga sumusunod: ikinonekta namin ang wire na karaniwan sa lahat ng tatlong mga pindutan sa "GND" ng Arduino. Ang unang button, na ginagamit upang ipasok ang mode ng setting ng oras at lumipat ayon sa oras at petsa, ay konektado sa "Pin 2". Ang pangalawa, ang button para pataasin ang value, ay sa “Pin 3”, at ang pangatlo, ang button para bawasan ang value, ay sa “Pin 4”.
Pinagsasama-sama ang lahat.
Para makaiwas maikling circuit, ang screen ay dapat na insulated. I-wrap namin ito sa isang bilog na may de-koryenteng tape, at sa pabalik Nag-attach kami ng isang strip ng insulating material sa double-sided tape, gupitin sa laki. Makapal na karton o manipis na plastik ang gagawin. Gumamit ako ng plastic mula sa isang tablet para sa papel. Ang resulta ay ang mga sumusunod:
Sa harap ng screen, kasama ang gilid, nakadikit kami ng double-sided foam tape, mas mabuti na itim.
Ikonekta ang screen sa Arduino:
Dagdag pa mula sa kompartamento ng baterya kumonekta sa "VIN" ng Arduino, minus sa "GND". Inilalagay namin ito sa likod ng Arduino. Bago i-install ito sa kaso, huwag kalimutang ikonekta ang sensor ng temperatura at ang board na may mga pindutan.
Paghahanda at pagpuno ng sketch.
Ang sensor ng temperatura ay nangangailangan ng OneWire library.
Ang output sa screen ay isinasagawa sa pamamagitan ng U8glib library:
Upang i-edit at punan ang isang sketch, kailangan mong i-install ang dalawang library na ito. Mayroong dalawang paraan upang gawin ito. I-unpack lang ang mga archive na ito at ilagay ang mga na-unpack na file sa folder na "mga aklatan" na matatagpuan sa folder ng pag-install Arduino IDE. O ang pangalawang opsyon ay ang direktang pag-install ng mga aklatan sa kapaligiran ng programming. Nang hindi na-unpack ang mga na-download na archive, sa Arduino IDE, piliin ang menu Sketch - Connect Library. Sa pinakaitaas ng drop-down na listahan, piliin ang “Add.Zip library”. Sa lalabas na dialog box, piliin ang library na gusto mong idagdag. Buksan muli ang Sketch menu - Connect Library. Sa pinakailalim ng drop-down na listahan dapat mong makita ang bagong library. Ngayon ang library ay maaaring gamitin sa mga programa. Huwag kalimutang i-restart ang Arduino IDE pagkatapos ng lahat ng ito.
Gumagana ang sensor ng temperatura gamit ang One Wire protocol at may natatanging address para sa bawat device - isang 64-bit na code. Hindi praktikal na hanapin ang code na ito sa bawat oras. Samakatuwid, kailangan mo munang ikonekta ang sensor sa Arduino, i-upload ang sketch na makikita sa menu File – Mga Halimbawa – Dallas Temperature – OneWireSearch. Susunod, ilunsad ang Tools - Port Monitor. Dapat mahanap ng Arduino ang aming sensor, isulat ang address nito at kasalukuyang mga pagbabasa ng temperatura. Kinokopya o isusulat lang namin ang address ng aming sensor. Buksan ang sketch Arduino_WG12864B_Term, hanapin ang linya:
Byte addr=(0x28, 0xFF, 0xDD, 0x14, 0xB4, 0x16, 0x5, 0x97);//address ng aking sensor
Isinulat namin ang address ng iyong sensor sa pagitan kulot na braces, pinapalitan ang address ng aking sensor.
Stock:
//u8g.setPrintPos(44, 64); u8g.print(seg); // Output segundo upang kontrolin ang kawastuhan ng paglipat
Nagsisilbi upang ipakita ang mga segundo sa tabi ng inskripsiyon na "Data". Ito ay kinakailangan para sa tumpak na pag-install paglipas ng panahon.
Kung ang orasan ay mabilis o nasa likod, dapat mong baguhin ang halaga sa linya:
Kung (micros() - prevmicros >494000) ( // baguhin sa ibang bagay para itama ito ay 500000
Empirikal kong natukoy ang numero kung saan ang orasan ay tumatakbo nang tumpak. Kung mabilis ang iyong orasan, dapat mong dagdagan ang numerong ito, kung nasa likod ito, bawasan ito. Upang matukoy ang katumpakan ng paglipat, kailangan mong ipakita ang mga segundo. Pagkatapos ng tumpak na pagkakalibrate ng numero, maaaring magkomento ang mga segundo at sa gayon ay maalis sa screen.
Nagsimula ang lahat nang, kung nagkataon, natagpuan ko ang aking sarili na may-ari ng isang BTHQ 22005VSS text LCD screen (2 linya ng 20 character bawat isa) at isang board elektronikong relo DS1302. Upang sabihin ang katotohanan, ginagawa ko ang aking mga unang hakbang sa pagmamanupaktura ng Arduino, kaya ang mapagpasyang papel sa pagkuha ng mga bahaging ito ay ginampanan ng makatwirang presyo at pagkakataon mabilis na paghahatid. Pagkatapos ng lahat, madalas na walang oras upang hintayin ang "aparato" na dumating mula sa Gitnang Kaharian, na naglakbay ng halos "kalahati ng mundo," at ayaw mo.
Bakit relo? Sa panahon na maraming iba't ibang mga relo na ibinebenta sa paligid, ang presyo ng pinakasimpleng mga relo ay maihahambing sa isang kahon ng juice. Ngunit ang bagay ay madalas na kinakailangan hindi lamang upang malaman ang eksaktong oras (at petsa, na kung minsan ay kinakailangan din), kundi pati na rin upang gumana sa oras na ito. Halimbawa, panatilihin ang mga tala ng mga pagbabago sa temperatura (halumigmig, presyon, liwanag, atbp.) na nagsasaad ng eksaktong oras kung kailan nangyari ang mga pagbabagong ito. Ito ay kung saan ang ARDUINO, na nilagyan ng orasan, ay magbibigay ng napakagandang serbisyo. At bukod pa, maganda kapag ipinapakita din ng device ang oras. Pagkatapos ng lahat, kahit na nagtatrabaho para sa personal na computer Paminsan-minsan ay sumulyap kami sa kanang sulok sa ibaba, at paano kung oras na para sa tanghalian, o katapusan na ng araw ng trabaho, o marahil ay madaling araw na?
Sa puso ko ng proyektong ito Gumamit ako ng ARDUINO UNO, na medyo madaling bilhin - ito ay, siyempre, kung gusto mong bumili ng isang bagay na may mataas na kalidad at mabilis. Maaari mong, siyempre, hanapin ito ng mas mura, ngunit muli kailangan mong maghintay, at hindi ko nais na maghintay. Ang Arduinka ay masayang kumurap sa LED nito, ginawa ang lahat ng kailangan dito, na nagbibigay ng mga simpleng mensahe serial port, sa pangkalahatan ay nasiyahan ako. Ngunit bumalik tayo sa orasan. Nagsimula ang mga problema, gaya ng dati, nang hindi inaasahan. Hindi posible na makahanap ng mga matinong artikulo at lahat ng iba pa alinman sa screen o para sa mga oras sa rally. Sa iba pang mga screen - mayroon, sa iba pang mga relo - hangga't gusto mo, ngunit sa kung ano ang nasa iyong mga kamay - halos wala. Pero kapag wala, “halos” marami rin.
Magsimula tayo sa screen. Ang BTHQ 22005VSS ay naging isang banal na 20x2 LCD screen (ibig sabihin, mayroon itong 2 linya ng 20 character bawat isa), sa halip na ito ay posible na gumamit, halimbawa, isang screen - kahit na mayroon itong "lamang" 16 na mga character sa bawat linya, ngunit para sa karamihan ng mga proyekto ito ay higit pa, kaysa sapat. Ang screen na ito ay may 16-pin connector, bagama't hindi single-row, ngunit double-row (2x8), kung hahawakan mo ang device na malayo sa iyo ang screen at ang connector sa kanan, ang unang pin ay ibaba sa kaliwa, ang pangalawa. kanang ibaba, ang pangatlo sa itaas ng una, ang ikaapat sa itaas ng pangalawa, atbp. Ang kaliwang itaas (15) ay magiging anode, ang kanang itaas (16) ay ang katod. Kung mayroon kang kaalaman sa Ingles at kuryusidad, maaari mong basahin ang teknikal na paglalarawan. Kung kakaunti ang nauna, at mas mahina ang kuryusidad kaysa sa pagnanais na mag-eksperimento, ganito ko ito ikinabit:
| Contact sa Screen | Arduino contact | Tandaan |
| 1 | GND | Ito ay "minus" o "lupa". |
| 2 | +5V | |
| 3 | GND | Kung kailangan mo ng maliwanag na mga palatandaan. |
| 4 | 4 | |
| 5 | GND | Kung "magsulat" lamang. |
| 6 | 5 | |
| 7 | -- | hindi gumamit |
| 8 | -- | hindi gumamit |
| 9 | -- | hindi gumamit |
| 10 | -- | hindi gumamit |
| 11 | 10 | |
| 12 | 11 | |
| 13 | 12 | |
| 14 | 13 | |
| A(15) | +5V | Kumonekta ako sa pamamagitan ng isang 500 Ohm risistor |
| K(16) | GND |
Sa ilang mga mapagkukunan, ang "pinout" sa gilid ng Arduino ay iba, ngunit ito ay mas maginhawa para sa akin sa ganitong paraan. Ang pagkonekta sa relo ay hindi rin nagdulot ng anumang mga problema:
| Panoorin ang DS1302 | Arduino | Tandaan |
| VCC | +5V | |
| GND | GND | Dito ko ikinonekta ito sa pamamagitan ng isang 10 kOhm risistor. |
| CLK | 0 | Hindi dapat malito sa GND!!! Ang pin ay tinatawag ding SCLK |
| DAT | 1 | Ang contact ay tinatawag ding IO |
| RST | 3 | Ang contact ay tinatawag ding CE |
Maaari mo itong ikonekta sa mga wire o cable;
Nagsimula ang mga problema noong na-load ang demosketch at nagsimulang gumana ang relo. Totoo, ipinakita nila ang taong 2165, buwan 45, linggo 85... Marahil ito ay ayon sa kalendaryong “Uranian” o “Neptune”... Ngunit hindi ako mabubuhay sa Lupa, at hindi ako pupunta sa Uranus at Neptune pa. Sa pangkalahatan, may kailangang gawin. Ang paghihinang ng 10kOhm risistor sa GND->GND circuit ay hindi nakatulong. Ang problema ay naging isang hindi tamang library. sasabihin ko agad yan tamang library maaaring kunin. Ito ay para sa relo. Matagumpay na ginagamit ng maliit na screen ang library mula sa karaniwang hanay, na tinatawag na LiquidCrystal.h.
Problema #2. Sa bawat oras na magsisimula ang orasan, magsisimula itong magbilang mula sa oras na "tinahi" sa programa. Kumain mahirap na desisyon ang problemang ito. Lumikha ng hash, isulat ito sa memorya ng orasan, pagkatapos, kapag nagsimula, basahin ito mula doon, ihambing ito ... Sa pangkalahatan, para sa isang baguhan sa Arduino engineering, medyo kumplikado ito. Tulad ng lumalabas, mayroong isang simpleng solusyon. o sa halip ay napakasimple. Ibig sabihin, i-flash ito ng 2 beses. Sa unang pagkakataon - i-flash ito sa pagtatakda ng petsa at oras, sa pangalawang pagkakataon ay i-flash ito, na dati ay "nagkomento" (naglalagay ng // sign sa pinakadulo simula ng linya) ang mga linya na may pagtatakda sa mismong petsa.
Sa totoo lang ang sketch:
| // DS1302_LCD (C)2010 Henning Karlsen // web: http://www.henningkarlsen.com/electronics // Isang mabilis na demo kung paano gamitin ang aking DS1302-library para mabilis // orasan gamit ang isang DS1302 at isang 20x2 LCD. // Korespondensya sa pagitan ng mga pin ng orasan at ng Arduino pinpm screen. // DS1302: CE pin -> Arduino Digital 3 // I/O pin -> Arduino Digital 1 // SCLK pin -> Arduino Digital 0 // LCD: DB7 -> Arduino Digital 13 // DB6 -> Arduino Digital 12 // DB5 -> Arduino Digital 11 // DB4 -> Arduino Digital 10 // E -> Arduino Digital 5 // RS -> Arduino Digital 4 #isama // Magsimula ng mga pin ng orasan void setup() // Maglunsad ng screen na nagsasaad ng bilang ng mga character at linya // Ang tatlong ilalim na linya ay walang komento sa unang pagkakataon; Sa pangalawang pagkakataon - magkomento tayo. void loop() // Ipakita ang pinaikling Araw-ng-Linggo sa kaliwang sulok sa ibaba // Ipakita ang petsa sa kanang sulok sa ibaba // Maghintay ng isang segundo bago ulitin |
Tinatalakay ng artikulong ito ang isang halimbawa ng paggawa ng real time clock. Ipapakita ng indicator ang eksaktong oras, at ang colon dito ay kumukurap isang beses bawat segundo. Eksaktong oras ay awtomatikong mai-install sa panahon ng pag-compile ng firmware.
Paglalarawan ng mga bahagi
Real time na orasan
Ginagamit namin ang real-time na module ng orasan mula sa Seeed Studio. Ang mga ito ay batay sa DS1307 chip mula sa Maxim Integrated. Sa mga elemento ng strapping, nangangailangan ito ng tatlong resistors, isang clock quartz at isang baterya, na magagamit na sa modyul na ito. Ang module ay may mga sumusunod na katangian:
Nagbibilang ng oras (segundo, minuto, oras), petsa (taon, buwan, araw), araw ng linggo
Dalawang-wire na I²C na interface
Ang kakanyahan ng isang real-time na orasan ay kung mayroong baterya, maaari itong tumakbo kahit na ang pangunahing aparato ay de-energized. Palagi kaming nakatagpo ng gayong mga orasan sa mga laptop o mga digital camera. Kung aalisin mo ang baterya sa mga device na ito at ibabalik ang mga ito pagkaraan ng ilang sandali, hindi magre-reset ang oras. Ito ay salamat sa real time clock, Real Time Clock (RTC).
Lahat mga kinakailangang aklatan maaaring i-download mula sa opisyal na website.
Tagapagpahiwatig
Gumagamit kami ng apat na digit na indicator mula sa Seeed Studio. Ang pangunahing bagay sa indicator ay ang TM1637 chip, na isang driver para sa mga indibidwal na 7-segment bits. Gumagamit ang module na ito ng 4 bits. Ang module ay may mga sumusunod na katangian:
8 antas ng liwanag
Dalawang-wire na interface ng pagpapatakbo (CLK, DIO)
Ginagamit namin ang modyul na ito upang ipakita ang oras: oras at minuto. Ang kaginhawahan ng module ay na ito ay konektado sa pamamagitan lamang ng dalawang wires at hindi nangangailangan pagpapatupad ng software dynamic na indikasyon, dahil ang lahat ay ipinatupad na sa loob ng module.
Ang dynamic na indikasyon ay isang proseso kung saan ang mga indicator sa aming module ay sunud-sunod na umiilaw. Ngunit hindi namin nakikita ang pagkutitap, dahil ang mata ng tao ay may malaking pagkawalang-kilos. Ang pamamaraang ito ay nagbibigay-daan sa iyo upang mahusay na i-save ang bilang ng mga koneksyon sa pagitan ng mga tagapagpahiwatig at ang controller:
Static na display: 4 na digit × 7 segment = 28 na koneksyon.
Dynamic na indikasyon: 7 segment + 4 na karaniwang anode o cathodes = 11 koneksyon.
Chip TM1637: 2 koneksyon.
Ang benepisyo ay halata.
Koneksyon
Ang real time clock module ay dapat na konektado sa SCL/SDA pin na nauugnay sa I²C bus. Kinakailangan din na ikonekta ang mga linya ng kapangyarihan (Vcc) at lupa (GND).
Ang mga linya ng SDA/SCL ay may sariling hiwalay na mga pin sa Arduino, ngunit sa loob ay konektado sila sa mga pin. pangkalahatang layunin. Kung ating isasaalang-alang Arduino Uno, ang linya ng SDA ay tumutugma sa pin A4, at ang linya ng SCL ay tumutugma sa A5.
Ang module ay may kasamang cable na may mga babaeng contact, na mas maginhawang kumonekta sa Troyka Shield. Gayunpaman, hindi ipinapakita dito ang magkahiwalay na SDA at SCL pin, kaya direktang kumonekta kami sa pamamagitan ng mga pin A5 at A4.
Sa mga tuntunin ng pagkonekta sa tagapagpahiwatig, ang lahat ay mas simple. Ang CLK at DIO pin ay maaaring konektado sa anumang digital pin. SA sa kasong ito ang ika-12 at ika-11 na pin ay ginagamit ayon sa pagkakabanggit.
Pagsusulat ng firmware
Dapat na simulan ng function ng pag-setup ang real-time na orasan at indicator, at itala din ang oras ng compilation panloob na memorya real time na orasan. Ang buong aksyon, o sa halip, ang pagbabasa ng oras mula sa RTC at pagpapakita nito sa indicator, ay isasagawa sa mga function ng loop.
Ang code para dito ay ganito ang hitsura:
rtc.ino #include)
ipinaliwanag ang function ng getInt
Una, kailangan mong maunawaan kung saan nagmumula ang oras sa hanay ng compileTime. Lumilitaw ito sa linyang ito:
unsigned char compileTime = __TIME__;
Pinapalitan ng compiler ang __TIME__ ng string na naglalaman ng oras ng compilation sa form na __TIME__ = "hh:mm:ss" , kung saan ang hh ay oras, mm ay minuto, ss ay segundo.
Bumalik tayo sa code na kailangang ipaliwanag:
char getInt(const char * string, int startIndex) ( return int (string[ startIndex] - "0") * 10 + int (string[ startIndex+ 1 ] ) - "0" ; )Sa string array na ipinasa bilang isang parameter sa getInt function, nakukuha namin ang character sa index startIndex at ang sumusunod dito upang magkaroon ng dalawang-digit na integer. Gayunpaman, sa una ito ay hindi isang numero, ngunit isang pares mga karakter. Upang makakuha ng numero mula sa isang simbolo, kailangan nating ibawas ang simbolo ng zero (“0”) mula sa simbolo na ito: pagkatapos ng lahat, sa talahanayan ng ASCII lahat ng digit na simbolo ay sunod-sunod, simula sa zero na simbolo. Samakatuwid, ang code int(string) - "0"), literal, ay ginagawa ang sumusunod: “Kunin ang numero ng character startIndex , ibawas ang zero na character mula dito at i-convert ito sa isang uri ng integer.”
Mga problema
Oo, gumagana ang code na ito, at tatakbo ang orasan. Gayunpaman, kung i-off mo ang power at i-on ito makalipas ang ilang minuto, pagkatapos ay pagkatapos itong i-on, ang oras ay muling magiging katulad noong panahon ng compilation.
Nangyayari ito dahil pagkatapos i-on ang power, muling ipapatupad ang code na makikita sa setup function. At isinusulat niya ang lumang halaga ng oras sa real time clock.
Upang maiwasan ito, kailangan nating baguhin ang code nang kaunti pa. Sa bawat oras sa function ng pag-setup, kakalkulahin ang isang "hash" ng oras ng compilation - ang bilang ng mga segundo na lumipas mula 00:00:00 hanggang sa oras ng compilation ay kakalkulahin. At ang hash na ito ay ihahambing sa hash sa EEPROM. Paalalahanan ka namin na ang EEPROM ay isang memorya na hindi na-reset kapag naka-off ang power.
Kung ang mga halaga ng kinakalkula at dati nang nai-save na hash ay nag-tutugma, nangangahulugan ito na hindi na kailangang muling isulat ang oras sa module ng orasan: nagawa na ito. Ngunit kung ang tseke na ito ay hindi pumasa, ang oras ay mapapatungan sa RTC.
Upang magsulat/magbasa ng isang numero unsigned type int sa/mula sa EEPROM dalawa ang nakasulat karagdagang mga tampok EEPROMWriteInt at EEPROMReadInt . Ang mga ito ay idinagdag dahil ang EEPROM.read at EEPROM.write function ay maaari lamang magbasa at magsulat ng char data.
rtc-eeprom.ino #include//I-on at off natin ang colon bawat segundo
display.point (clock .second % 2 ? POINT_ON : POINT_OFF) ;
![) char getInt(const char * string, int startIndex) ( return int (string[ startIndex] -](/uploads/611c236f35f0454069026f9310109c7c.jpg ") char getInt(const char * string, int startIndex) ( return int (string[ startIndex] -")
