IOT123 - PÄIKESEKRAAN - KONTROLLER: 8 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

See on Instructable'i laiendus

IOT123 - PÄIKESEJÄRGI - KALD/PANN, PANEELRAAM, LDR -MONTAALID RIG. Siin keskendume servode kontrollerile ja päikese asukoha anduritele. Oluline on märkida, et see disain eeldab, et kasutatakse 2 MCU -d: üks (3,3 V 8mHz Arduino Pro Mini) päikeseenergia jälgija jaoks ja üks sõltumatu MCU teie andurite/osalejate jaoks.

See on versioon 0.3

Selle asemel, et avaldada kõiki projekte pärast täielikku rahulolu, harjutan pidevat integratsiooni ja esitan midagi sagedamini, muutes seda, mida olen esitanud. Kirjutan akulaadija jaoks veel ühe juhendi, _kui_kontrolleri tarkvara/riistvara optimeerimine on lõppenud. Juhin tähelepanu sellele, kus optimeerimisi vaja on.

Selle lähenemisviisi üheks põhjuseks on klientide tagasiside. Kui näete vajadust või teil on parem lähenemisviis, palun kommenteerige, kuid pidage meeles, et ma ei saa kõike pakkuda ja võib-olla ka mitte teile sobivasse ajavahemikku. Kuna need selgitused tunduvad vähem asjakohased, kustutatakse need sellest artiklist.

Mida see sisaldab:

1. Päikese ligikaudse asukoha tuvastamiseks kasutage originaaljuhendi LDR -ideid.
2. Liigutage servod päikese poole.
3. Liigutuste tundlikkuse valikud.
4. Päikese poole liikudes astme suuruse valikud.
5. Servodel kasutatavate nurgapiirangute valikud.
6. Liigutuste viivitamise võimalused.
7. I2C liides väärtuste seadistamiseks/hankimiseks MCU -de vahel.
8. Liigutuste vahel sügav uni.

Mida see ei sisalda (ja seda käsitletakse ajaliselt):

1. Kasutage energiat ainult päevavalgel.
2. Koidupositsiooni meenutamine ja hämariku sulgemisel sinna minek.
3. Regulaatori eemaldamine MCU -st.
4. MCU valgusdioodide (de) keelamine.
5. Toite ümbersuunamine VCC, mitte RAW kaudu.
6. Pakub lahendusi vilkumiseks ilma reguleerimata toiteallikast USB -seeria TTL -muundurist.
7. Aku pinge monitor.

AJALUGU

20. detsember 2017 V0.1 KOOD

Esialgne versioon jälgib valgusallikat, alati sisse lülitatud, laadimist ei toimu

7. jaanuar 2018 V0.2 KOOD

• RIISTVARA MUUDATUSED

  • Lisage I2C tihvtid
  • Lisage lüliti servo GND -dele
  • Trükitud silt kontrollerikarbi esiküljel

• TARKVARA MUUDATUSED

  • Lugege konfiguratsiooni EEPROMist
  • I2C siini tugi teise MCU orjana (3.3V)
  • Määrake konfiguratsioon I2C kaudu
  • Määra I2C kaudu lubatuks
  • Hankige konfiguratsioon I2C kaudu
  • Hankige käitusaja omadused I2C kaudu (praegu lubatud ja praegune valguse intensiivsus)
  • Eemaldage jada logimine (see mõjutas I2C väärtusi)

19. jaanuar 2018 V0.3 KOOD

• RIISTVARA

  Silt on värskendatud. Lülitit kasutatakse nüüd režiimi CONFIG või TRACK valimiseks

• TARKVARA
  • I2C kasutatakse ainult seadistamiseks
  • Kontroller ootab 5 sekundit enne jälgimise initsialiseerimist, võimaldab käsi liigutada
  • I2C konfiguratsiooni kasutamiseks peab SPDT seadme alglaadimisel olema CONFIG
  • Liikumise jälgimise vahel on seade sügava unerežiimi konfiguratsiooniväärtuse SLEEP MINUTES (vaikimisi 20 minutit) jaoks.

Samm: materjalid ja tööriistad

Nüüd on täielik materjalide ja allikate nimekiri.

1. 3D trükitud osad.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 4x6 cm kahepoolse prototüübi PCB universaalne trükkplaat (tuleb pooleks lõigata)
4. 1 off 40P isane päis (lõigatakse mõõtu).
5. 1 off 40P emane päis (lõigatakse suuruseks).
6. 4 off 10K 1/4W takistid.
7. Ühendusjuhe.
8. Jootmine ja raud.
9. 20 off 4G x 6mm roostevaba panni pea isekeermestavad kruvid.
10. 4 off 4G x 6mm roostevaba süvistatud isekeermestavad kruvid.
11. 1 väljalülitatud 3,7 V LiPo aku ja hoidik (lõpeb 2P duponti pistikutega).
12. 1 väljas 2P isane täisnurga päis
13. 1 väljalülitatud SPDT lüliti 3 kontaktiga 2,54 mm sammuga
14. Tugev tsüanoakrülaatliim
15. Duponti pistikute emane 1P päis (1 sinine, 1 roheline).

Samm: vooluringi kokkupanek

Vooluahelal pole praegu pingejaotusahelat (voltmeetrit).

1. Lõika 4x6 cm kahepoolse prototüübi PCB universaalne trükkplaat pooleks piki telge.

2. Lõika 40P isane päis tükkideks:

   1. 2 väljas 12P
   2. 3 väljas 3P
   3. 6 väljas 2P.

3. Lõika 40P naissoost päis tükkideks:

   1. 2 väljas 12P
   2. 1 välja 6P
4. Jootmine 2 välja 12Pnaise päis nagu näidatud.
5. Liimige 3P isase (täiendava) päise küljest eemaldatud vahetükk SPDT -lüliti alumisele küljele tsüanoakrülaatliimiga
6. Teisel küljel asetage seejärel jootma 6 välja 2P, 2 välja 3Pmale päise ja SPDT lüliti, nagu näidatud.
7. Jootke 4 maha 10K takistid (A, B, C, D must) juhtme kaudu GND tihvti päisele (#2 must) ja A0 - A3 päise tihvtidele (#5, #6, #7, #8) ja seejärel läbi ava (kollane) nagu näidatud (3 fotot + 1 skeem).
8. Jälgige 3.3V LDR -i PINS -i jootmis -PINS -idest #4, #6, #8, #10 ja keerake auk läbi feamale päise VCC tihvti (roheline).
9. Jälgige 3.3V emase päisepoolsel küljel, nagu näidatud (punane), jootmiseks PINS #1, #12, #15.
10. 3.3V läbiv auk joodetud üle külje (punane) RAW päise PIN #1.
11. Jälgige oranži ühendamist PIN -koodist nr 11 läbi augu kuni jooteni. Emastapp teisel pool, nagu näidatud.
12. Jälgige ja jootke sinist haaketraati vahemikus #20 kuni #30 ja #31 kuni #13 ja #16.
13. Jootma naissoost päise PIN #11 kuni isase päise PIN #11 läbi ava.
14. Valmistage ette kaks 30 mm pikkust dupont -pistikut koos emase 1P -päisega (1 sinine, 1 roheline). Riba ja tina teine ots.
15. Joodis sinine Duponti traat kuni #28; jootma roheline Duponti traat kuni #29.
16. Arduino ülaosas kinnitage 6P naissoost päis ja seejärel jootke.
17. Arduino ülaosas kinnitage 2P täisnurga emane päis int #29 ja #30, seejärel jootke.
18. Arduino alumisel küljel kinnitage 2 12P ja 1 3P isast tihvti, seejärel jootke.
19. Sisestage Arduino isased 12P tihvtid PCB 12P naissoost päistesse.

3. samm: MCU vilkumine

Arduino Pro Mini saab mugavalt välgutada FTDI232 USB -TTL -muunduri abil, kasutades 6P naissoost päist. Vaadake ülaltoodud fotot kahe tahvli joondamiseks.

Veenduge, et teie seadmes FTDI232 oleks valitud 3.3V säte. Järgige siin toodud juhiseid, kasutades allolevat koodi (kasutage linki GIST).

Vähese energiatarbega teek (lisatud ja https://github.com/rocketscream/Low-Power) tuleb installida.

Kui Arduino Pro Mini + PCB on korpusesse paigaldatud, saab seda siiski vilgutada, kuna päise tihvtid on paljastatud. Lihtsalt ühendage juhtplokk lahti paneeli raamist, mis paljastab päise.

Kallutatav päikeseseade I2C/EEPROM konfiguratsiooniga ja unetsükkel liikumiste vahel. Unetsükli kestuse täpsus väheneb kestuse kasvades, kuid selleks piisab

/*

* koodist muudetud

* Mathias Leroy

*

* V0.2 MUUDATUSED

** I2C SET GET

** EEPROM SET GET

** EEMALDA SERIAALVÄLJUND - MÕJUTATUD I2C

** JÄLGIMISE LUBAMINE/KEELAMINE

** Liigutage teenuseid I2C piirangutega

** LOE JOOKSVAT AVG TUGEVUST VÄLJA I2C

* V0.3 MUUDATUSED

** Lülitage 2 režiimi - TRACK (NO I2C) ja CONFIGURE (KASUTAB I2C)

** MAGA RADIREŽIIMIS (VÄGA MADAL TÄPSUS TÄHELEPANU 8 SEKUNDI KOHTA)

** Eemaldage/kinnitage servad magamise/ärkamise ajal (juhuslikult kasutatav TRANSISTOR)

** EEMALDA KONFIGUREERITAV ALGASEND (REDUNDANT)

** EEMALDA KONFIGUREERITAV WAKE SECONDS (REDUNDANT)

** EEMALDA KONFIGUREERITAV LUBATUD/KEELATAV (REDUNDANT)

** EEMALDA KONFIGUREERITAV JÄLGIMINE LUBATUD (KASUTAGE RIISTVÕTELÜLITI)

** REMOVE VOLTAGE GETTER - KASUTAB Eraldi I2C KOMPONENTI

** LISA SERIAL LOGGING, KUI EI KASUTA I2C

*/

#kaasake

#kaasake

#kaasake

#kaasake

#kaasake

#defineEEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definePIN_SERVO_V11

#definePIN_SERVO_H5

#defineIDX_I2C_ADDR0

#defineIDX_V_ANGLE_MIN1

#defineIDX_V_ANGLE_MAX2

#defineIDX_V_SENSITIVITY3

#defineIDX_V_STEP4

#defineIDX_H_ANGLE_MIN5

#defineIDX_H_ANGLE_MAX6

#defineIDX_H_SENSITIVITY7

#defineIDX_H_STEP8

#defineIDX_SLEEP_MINUTES9

#defineIDX_V_DAWN_ANGLE10

#defineIDX_H_DAWN_ANGLE11

#defineIDX_DAWN_INTENSITY12 // kõigi LDRS -ide keskmine

#defineIDX_DUSK_INTENSITY13 // kõigi LDRS -ide keskmine

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // kõigi LDRS -ide keskmine - kasutatakse IDX_DAWN_INTENSITY ümbritseva otsese valguse arvutamiseks

#defineIDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

bait _i2cVals [20] = {10, 10, 170, 20, 5, 10, 170, 20, 5, 20, 40, 10, 30, 40, 0, 0, 0, 0, 0, 0};

int _servoLoopDelay = 10;

int _slowingDelay = 0;

int _nurkH = 90;

int _nurkV = 90;

int _verageTop = 0;

int _verageRight = 0;

int _ keskmiseltBottom = 0;

int _verageLeft = 0;

bait _i2cResponse = 0;

bool _inConfigMode = vale;

voidsetup ()

{

Seriaalne algus (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println ("Seadistusrežiim");

Serial.print ("I2C aadress:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onRecept (ReceiveEvent);

Wire.onRequest (requestEvent);

} muud {

Serial.println ("Jälgimisrežiim");

viivitus (5000); // aeg, et käed eemale saada, kui ühendate aku jne.

}

}

tühjus ()

{

getLightValues ();

if (! _inConfigMode) {

// Ülesanded: LÜLITA TRANSISTORI LÜLITI

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

jaoks (int i = 0; i <20; i ++) {

kui (i! = 0) {

getLightValues ();

}

moveServos ();

}

viivitus (500);

_servoH.detach ();

_servoV.detach ();

// Ülesanded: LÜLITA TRANSISTORI LÜLITI

viivitus (500);

sleepFor ((_ i2cVals [IDX_SLEEP_MINUTES] * 60) / 8);

}

}

// --------------------------------- HETKELINE REŽIIM

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

// --------------------------------- EEPROM

voidgetFromEeprom () {

kui (

EEPROM.read (IDX_SIGN_1)! = 'S' ||

EEPROM.read (IDX_SIGN_2)! = 'T' ||

EEPROM.read (IDX_SIGN_3)! = EEPROM_VERSION

) EEPROM_write_default_configuration ();

EEPROM_read_configuration ();

}

voidEEPROM_write_default_configuration () {

Serial.println ("EEPROM_write_default_configuration");

jaoks (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

EEPROM.update (i, _i2cVals );

}

EEPROM.update (IDX_SIGN_1, 'S');

EEPROM.update (IDX_SIGN_2, 'T');

EEPROM.update (IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration () {

Serial.println ("EEPROM_read_configuration");

jaoks (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

_i2cVals = EEPROM.lugemine (i);

//Seria.println(String(i) + "=" + _i2cVals );

}

}

// --------------------------------- I2C

voidreceptEvent (int count) {

kui (loend == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

baitindeks = Wire.read ();

baidi väärtus = Wire.read ();

lüliti (cmd) {

juhtum G:

if (indeks <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [indeks];

}

murda;

juhtum:

if (indeks <IDX_END_EEPROM_SET) {

_i2cVals [indeks] = väärtus;

EEPROM.update (indeks, _i2cVals [indeks]);

}

murda;

vaikimisi:

tagasipöördumine;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDR-id

voidgetLightValues () {

int valueTopLeft = analogRead (PIN_LDR_TL);

int valueTopRight = analogRead (PIN_LDR_TR);

int valueBottomRight = analogRead (PIN_LDR_BR);

int valueBottomLeft = analogRead (PIN_LDR_BL);

_averageTop = (valueTopLeft + valueTopRight) / 2;

_averageRight = (valueTopRight + valueBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (valueTopLeft + valueTopRight + valueBottomRight + valueBottomLeft) / 4;

_i2cVals [IDX_CURRENT_INTENSITY] = kaart (keskm. intensiivsus, 0, 1024, 0, 255);

}

// -------------------------------- SERVOS

voidmoveServos () {

Serial.println ("moveServos");

if ((_averageLeft-_averageRight)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH-_i2cVals [IDX_H_STEP])> _ i2cVals [IDX_H_ANGLE_MIN]) {

// läheb vasakule

Serial.println ("moveServos läheb vasakule");

viivitus (_slowingDelay);

jaoks (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH--);

viivitus (_servoLoopDelay);

}

}

elseif ((_averageRight-_averageLeft)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH+_i2cVals [IDX_H_STEP]) <_ i2cVals [IDX_H_ANGLE_MAX]) {

// läheb õigesti

Serial.println ("moveServos läheb vasakule");

viivitus (_slowingDelay);

jaoks (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_nurkH ++);

viivitus (_servoLoopDelay);

}

}

muu {

// mitte midagi teha

Serial.println ("moveServos ei tee midagi");

viivitus (_slowingDelay);

}

kui ((_averageTop-_averageBottom)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV+_i2cVals [IDX_V_STEP]) <_ i2cVals [IDX_V_ANGLE_MAX]) {

// üles minema

Serial.println ("moveServos läheb üles");

viivitus (_slowingDelay);

jaoks (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV ++);

viivitus (_servoLoopDelay);

}

}

elseif ((_averageBottom-_averageTop)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV-_i2cVals [IDX_V_STEP])> _ i2cVals [IDX_V_ANGLE_MIN]) {

// alla minema

Serial.println ("moveServos läheb alla");

viivitus (_slowingDelay);

jaoks (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV--);

viivitus (_servoLoopDelay);

}

}

muu {

Serial.println ("moveServos ei tee midagi");

viivitus (_slowingDelay);

}

}

// -------------------------------- MAGU

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

for (unsignedint sleepCounter = eightSecondSegments; sleepCounter> 0; sleepCounter--)

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

vaata rawtilt_pan_tracker_0.3.ino, mille hostiks on GitHub ❤

Samm: vooluringi korpuse kokkupanek

1. Veenduge, et Ardiuno Pro Mini oleks sisestatud trükkplaadi päistesse.
2. Sisestage SOLAR TRACKER kontrollerikarbi alus SOLAR TRACKER kontrollerikarbi seintesse ja kinnitage 2 väljalülitatud 4G x 6 mm roostevaba isekeermestava kruviga.
3. Sisestage Ardiuno Pro Mini + trükkplaat, millel on 6P päis, SOLAR TRACKER kontrollerikarbi aluse tühimikku.
4. Sisestage SOLAR TRACKER kontrollerikarbi kaas SOLAR TRACKER kontrollerikarbi seintesse ja kinnitage 2 väljalülitatud 4G x 6 mm roostevabast terasest isekeermestava kruviga.
5. Kinnitage komplekt paneeliraami aluse külge 4 väljalülitatud 4G x 6 mm roostevaba isekeermestava kruviga.

Samm 5: Seadmejuhtmete ühendamine kontrolleriga

Asjakohased ühendused, mis on valmis eelmisest juhendist, on 4 välja lülitatud 2P LDR -ühendused ja 2 väljalülitatud 3P -ühendust servodelt. Aku on aku laadimiseks ajutine. Kasutage praegu 3,7 V LiPo, mis lõpeb 2P DuPonti ühendusega.

1. Sisestage LDR -ühendused (pole polaarsust) ülevalt:

   1. Üleval paremal
   2. Üleval vasakul
   3. Paremalt alumine
   4. All vasakul

2. Sisestage servoühendused (signaaltraat vasakule) ülevalt:

   1. Horisontaalne
   2. Vertikaalne
3. Oodake, kuni olete testimiseks valmis: sisestage 3,7 V alalisvoolu toitejuhe +ve ülaossa, -ve alla.

6. samm: kontrolleri testimine

Nagu varem öeldud, pole tarkvara päikeseenergia laadimise töövoo jaoks optimeeritud. Seda saab siiski testida ja kohandada, kasutades looduslikke (päike) ja ebaloomulikke valgusallikaid.

Jälgimise kontrollimiseks kontrollitud keskkonnas võib olla mugav seadistada SLEEP MINUTES madalamale väärtusele (vt järgmist sammu).

Samm 7: seadistamine I2C kaudu konsooli sisendi abil

See selgitab kontrolleri seadistamist teise MCU kaudu, seadete sisestamist konsooli aknasse.

1. Laadige järgmine skript D1M WIFI BLOCK -i (või Wemos D1 Mini) üles.
2. Ühendage USB arvutist lahti

3. PIN-ÜHENDUSED: -ve (kontroller) => GND (D1M)+ve (kontroller) => 3V3 (D1M) SCL (kontroller) => D1 (D1M)

   SDA (kontroller) => D2 (D1M)

4. Keerake SPDT -lüliti asendisse CONFIG
5. Ühendage USB arvutiga
6. Arduino IDE -st käivitage õige COM -pordiga konsoolaken
7. Veenduge, et valitud on "Newline" ja "9600 baud"
8. Käsud sisestatakse tekstikasti Saada, millele järgneb sisestusklahv
9. Käsud on vormingus Märkbait bait
10. Kui teist baiti (kolmas segment) pole lisatud, saadab skript 0 (null)
11. Olge jada sisendit kasutades ettevaatlik; enne sisestusklahvi vajutamist vaadake sisestatud andmed üle. Kui olete lukustamata (näiteks muudate I2C aadressi väärtuseks, mille olete unustanud), peate kontrolleri püsivara uuesti vilkuma.

Käsu esimese märgi toetatud variatsioonid on järgmised:

• E (Luba servo jälgimine) on kasulik liikumise peatamiseks konfigureerimise ajal. Selle sisestamiseks kasutage: E 0
• D (Keela servo jälgimine) on kasulik automaatse jälgimise alustamiseks, kui seadet ei taaskäivitata. Selle sisestamiseks kasutatakse: D 0
• G (Hangi konfiguratsiooniväärtus) loeb väärtusi EEPROM -ist ja IN -MEMORY -st: see sisestatakse järgmiselt: G (indeks kehtib baitide väärtuste 0–13 ja 15 kohta)
• S (Set EEPROM value) määrab väärtusteks EEPROM, mis on saadaval pärast taaskäivitamist. Selle sisestamiseks kasutatakse: S (indeks on kehtivad baitväärtused 0–13, väärtus kehtivad baitväärtused ja varieeruvad olenevalt objektist)

Kood on indeksite tõde, kuid kehtivate väärtuste/kommentaaride juhendiks kasutatakse järgmist.

• I2C ADDRESS 0 - kontrolleri alam -aadress, master vajab seda kontrolleriga suhtlemiseks (vaikimisi 10)
• MINIMAALNE VERTIKAALNURK 1 - vertikaalse servo nurga alumine piir (vaikimisi 10, vahemik 0–180)
• MAKSIMAALVERTIKAALNURK 2 - vertikaalse servo ülemine ülempiir (vaikimisi 170, vahemik 0–180)
• Tundlikkus VERTICAL LDR 3 - vertikaalne LDR lugemisvaru (vaikimisi 20, vahemik 0–1024)
• VERTIKAALNURK 4. samm - vertikaalsed servosammud igal reguleerimisel (vaikimisi 5, vahemik 1–20)
• MINIMAALNE HORISONTAALNURK 5 - horisontaalse servo nurga alumine piir (vaikimisi 10, vahemik 0–180)
• MAKSIMAALNE HORISONTAALNURK 6 - horisontaalne servo ülemine piir (vaikimisi 170, vahemik 0–180)
• TUNDLIKKUS HORISONTAALNE LDR 7 - horisontaalne LDR lugemisvaru (vaikimisi 20, vahemik 0–1024)
• HORISONTAALNURK 8. SAMM - horisontaalsed servoastmed igal reguleerimisel (vaikimisi 5, vahemik 1–20)
• SLEEP MINUTES 9 - ligikaudne uneaeg jälgimise vahel (vaikimisi 20, vahemik 1–255)
• VERTICAL DAWN NURK 10 - TULEVIKUKASUTUS - vertikaalne nurk, mille juurde naasta, kui päike loojub
• HORISONTAALNE KOIDANURK 11 - TULEVIKUKASUTUS - horisontaalne nurk, mille juurde naasta, kui päike loojub
• DAWN INTENSITY 12 - TULEVIKUKASUTUS - kõigi LDR -ide minimaalne keskmine, mis käivitab igapäevase päikese jälgimise
• DUSK INTENSITY 13 - TULEVIKUKASUTUS - kõigi LDR -ide minimaalne keskmine, mis käivitab igapäevase päikese jälgimise
• EEPROMI VÄÄRTUSTE LÕPP MARKER 14 - VÄÄRTUS KASUTAMATA
• CURRENT INTENSITY 15 - praegune keskmine valgustugevuse protsent
• MÄLUVÄÄRTUSTE LÕPP MARKER 16 - VÄÄRTUS KASUTAMATA.

Jäädvustab jadasisendi (klaviatuuri sisend konsooli aknas) ja edastab selle I2C orjale vormingus char, bait, bait

#kaasake

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

boolean _newData = vale;

const bait _numChars = 32;

char _saidChars [_numChars]; // massiiv vastuvõetud andmete salvestamiseks

voidsetup () {

Seriaalne algus (9600);

Traat.algus (D2, D1);

viivitus (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

staatiline bait ndx = 0;

char endMarker = '\ n';

char rc;

samas (Serial.available ()> 0 && _newData == false) {

rc = Serial.read ();

if (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

if (ndx> = _numChars) {

ndx = _numbrimärgid - 1;

}

} muud {

_receivedChars [ndx] = '\ 0'; // lõpetada string

ndx = 0;

_newData = tõsi;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

char *märk;

sümboolne = strtok (_saidised, tühjad);

char cmd = _saanudSüdamikud [0];

baitindeks = 0;

baidi väärtus = 0;

int i = 0;

while (märk! = NULL) {

//Serial.println(token);

i ++;

lüliti (i) {

juhtum 1:

märk = strtok (NULL, delim);

indeks = atoi (märk);

murda;

juhtum2:

märk = strtok (NULL, delim);

kui (märk! = NULL) {

väärtus = atoi (märk);

}

murda;

vaikimisi:

märk = NULL;

}

}

sendCmd (cmd, indeks, väärtus);

_newData = vale;

}

}

voidsendCmd (char cmd, baitindeks, baitväärtus) {

Serial.println ("-----");

Serial.println ("Saatmise käsk:");

Serial.println ("\ t" + string (cmd) + "" + string (indeks) + "" + string (väärtus));

Serial.println ("-----");

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // edastada seadmesse

Wire.write (cmd); // saadab sümboli

Wire.write (indeks); // saadab ühe baidi

Wire.write (väärtus); // saadab ühe baidi

Wire.endTransmission ();

baitide vastus = 0;

bool hadResponse = vale;

kui (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

samas (Wire.available ()) // ori võib saata vähem kui soovitud

{

hadResponse = tõsi;

vastus = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Vastuse saamine:");

Serial.println (vastus);

} muud {

Serial.println ("Vastust pole, kontrollige aadressi/ühendust");

}

}

}

vaata rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino, mille hostiks on GitHub ❤

8. samm: järgmised sammud

Kontrollige aeg -ajalt tarkvara ja riistvara muudatusi.

Muutke tarkvara/riistvara vastavalt oma vajadustele.

Kommenteerige kõiki taotlusi/optimeerimisi.