IOT123 - SOLAR TRACKER - CONTROLLER: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Aceasta este o extensie a Instructable

IOT123 - SOLAR TRACKER - TILT / PAN, CADRUL PANELULUI, MONTAJUL LDR. Aici ne concentrăm asupra controlerului servoarelor și asupra senzorilor poziției soarelui. Este important să subliniem că acest design presupune că vor fi utilizate 2 MCU-uri: unul (3,3V 8mHz Arduino Pro Mini) pentru tracker-ul solar și un MCU independent pentru senzorii / actorii dvs.

Aceasta este versiunea 0.3

În loc să public toate proiectele după o satisfacție completă, voi practica integrarea continuă și voi livra ceva mai des, modificând ceea ce am livrat după cum am nevoie. Voi scrie un alt instructabil pentru încărcătorul de baterii, _când_ optimizarea software-ului / hardware-ului controlerului este completă. Voi indica unde sunt necesare optimizările pe măsură ce parcurgem acest lucru.

O parte din motivul acestei abordări este feedback-ul clienților. Dacă vedeți o nevoie sau aveți o abordare mai bună, vă rugăm să comentați, dar rețineți că nu pot livra totul și, eventual, nu într-un interval de timp care vi se potrivește. Deoarece aceste explicații par mai puțin relevante, acestea vor fi șterse din acest articol.

Ce include acest lucru:

1. Utilizați LDR-urile din instructabilul original pentru a detecta locația aproximativă a soarelui.
2. Mutați servo-urile spre fața soarelui.
3. Opțiuni pentru sensibilitatea mișcărilor.
4. Opțiuni pentru dimensiunea pasului când vă deplasați la soare.
5. Opțiuni pentru constrângerile unghiulare utilizate pe servo.
6. Opțiuni pentru întârzierile mișcărilor.
7. Interfață I2C pentru setarea / obținerea valorilor între MCU-uri.
8. Somn profund între mișcări.

Ceea ce nu include (și va fi abordat în funcție de timp):

1. Utilizarea energiei electrice numai în timpul zilei.
2. Amintindu-mi poziția zorilor și mergând acolo la închiderea amurgului.
3. Scoaterea regulatorului din MCU.
4. Dezactivarea LED-urilor de pe MCU.
5. Redirecționarea puterii prin VCC, mai degrabă decât prin RAW.
6. Furnizarea soluțiilor pentru intermitent fără alimentare reglementată de la convertorul USB la serial TTL.
7. Monitor tensiune baterie.

ISTORIE

20 decembrie 2017 V0.1 COD

Versiunea inițială urmărește sursa de lumină, întotdeauna aprinsă, fără încărcare

7 ianuarie 2018 V0.2 COD

• SCHIMBĂRI HARDWARE

  • Adăugați pini I2C
  • Adăugați comutatorul la GND servo
  • Etichetă tipărită pe fascia cutiei controlerului

• MODIFICĂRI SOFTWARE

  • Citiți configurația din EEPROM
  • Suport autobuz I2C ca sclav al unui alt MCU (3.3V)
  • Setați configurația prin I2C
  • Setați Activat prin I2C
  • Obțineți configurarea prin I2C
  • Obțineți proprietăți de rulare prin I2C (activat în prezent și intensitate luminoasă curentă)
  • Eliminați înregistrarea în serie (a afectat valorile I2C)

19 ianuarie 2018 V0.3 COD

• HARDWARE

  Eticheta actualizată. Comutatorul este acum utilizat pentru a alege modul CONFIG sau TRACK

• SOFTWARE

  • I2C folosit doar pentru configurare
  • Controlerul așteaptă 5 secunde înainte de inițializarea urmăririi, permite mișcarea mâinilor
  • Pentru a utiliza configurația I2C, SPDT trebuie să fie pe CONFIG ca boot-uri unitare
  • Între mișcarea de urmărire, unitatea este în modul de repaus profund pentru valoarea de configurare SLEEP MINUTES (implicit 20 de minute).

Pasul 1: Materiale și instrumente

Acum există o listă completă a listei de materiale și surse.

1. Piese imprimate 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 din placa de circuite imprimate universale PCB cu prototip dublu de 4x6cm (de tăiat în jumătate)
4. 1 antet masculin 40P (de tăiat la dimensiune).
5. 1 antet feminin 40P (de tăiat la dimensiune).
6. 4 opritoare 10K 1 / 4W.
7. Sârmă de conectare.
8. Lipire și fier.
9. 20 șuruburi autofiletante 4G x 6mm din oțel inoxidabil.
10. 4 șuruburi autofiletante din inox 4G x 6mm.
11. 1 off baterie și suport LiPo de 3,7 V (care se termină în conectori dupont 2P).
12. 1 off antet 2P masculin cu unghi drept
13. 1 oprire SPDT comutator 3 pini 2.54mm pitch
14. Lipici puternic de cianoacrilat
15. Conectori Dupont antet 1P feminin (1 oprit albastru, 1 oprit verde).

Pasul 2: Asamblarea circuitului

În prezent, circuitul nu are circuitul divizor de tensiune (voltmetru).

1. Tăiați placa de circuite imprimate universale cu prototip dublu de 4x6 cm pe jumătate pe axa lungă.

2. Tăiați antetul masculin 40P în bucăți:

   1. 2 de pe 12P
   2. 3 de pe 3P
   3. 6 de pe 2P.

3. Tăiați antetul feminin 40P în bucăți:

   1. 2 de pe 12P
   2. 1 din 6P
4. Solder 2 off 12 Antet feminin așa cum se arată.
5. Lipiți distanțierul îndepărtat dintr-un antet masculin 3P (suplimentar) pe partea inferioară a comutatorului SPDT cu adeziv cianoacrilat
6. Pe cealaltă parte, lipiți apoi 6 off 2P, 2 off 3P header masculin și comutatorul SPDT așa cum se arată.
7. Lipiți 4 rezistențe 10K (A, B, C, D negru) prin cablu la antetul pinului GND (# 2 negru) și la pinii antetului A0 - A3 (# 5, # 6, # 7, # 8) apoi prin orificiu (galben) așa cum se arată (3 fotografii + 1 diagramă).
8. Urmăriți 3.3V de la PIN-urile de lipit LDR PINS # 4, # 6, # 8, # 10 și filetați orificiul până la pinul VCC antet feamale (verde).
9. Urmăriți 3.3V pe partea antetului feminin așa cum se arată (roșu) lipit la PINS # 1, # 12, # 15.
10. 3,3 V prin orificiul lipit peste partea (roșie) PIN antet RAW # 1.
11. Urmăriți legătura portocalie de la PIN-ul 11 prin orificiu până la lipit Știftul feminin de pe cealaltă parte, așa cum se arată.
12. Urmăriți și lipiți cablul de legătură albastru de la # 20 la # 30 și de la # 31 la # 13 și # 16.
13. PIN de antet femelă de lipit # 11 până la orificiul PIN de antet masculin # 11.
14. Pregătiți 2 conector dupont de 30 mm lungime cu antet 1P feminin (1 albastru, 1 verde). Banda și staniu celălalt capăt.
15. Sârmă Dupont albastră de lipit la # 28; sârmă Dupont verde de lipit la # 29.
16. În partea superioară a Arduino, fixați antetul de sex feminin 6P, apoi lipiți.
17. În partea superioară a Arduino fixați 2P antetul feminin cu unghi drept int # 29 și # 30 apoi lipiți.
18. Pe partea inferioară a Arduino fixați 2 pinii 12P și 1 off pinii masculi 3P apoi lipiți.
19. Introduceți pini Arduino tată 12P în antetele de mână PCB 12P.

Pasul 3: intermitent MCU

Arduino Pro Mini este intermitent în mod convenabil folosind un convertor FTDI232 USB la TTL utilizând antetul de sex feminin 6P. Vedeți fotografia de mai sus pentru alinierea celor 2 plăci.

Asigurați-vă că setarea de 3,3 V este aleasă pe FTDI232. Urmați instrucțiunile de aici folosind codul de mai jos (utilizați linkul către GIST).

Biblioteca lowpower (atașată și https://github.com/rocketscream/Low-Power) trebuie instalată.

Odată ce PCB-ul Arduino Pro Mini + este instalat în carcasă, acesta poate fi încă intermitent pe măsură ce pinii antetului sunt expuși. Deconectați unitatea controlerului de la cadrul panoului, expunând antetul.

Tracker solar Tilt Pan cu configurare I2C / EEPROM și ciclu de somn între mișcări. Precizia duratei ciclului de somn scade odată cu creșterea duratei, dar suficientă în acest scop

/*

* modificat din cod

* de Mathias Leroy

*

* MODIFICĂRI V0.2

** SET I2C OBȚINE

** SET EEPROM OBȚINE

** ELIMINAȚI IEȘIREA SERIALĂ - I2C AFECTAT

** ACTIVAȚI / DEZACTIVAȚI URMĂRAREA

** MUTAȚI SERVICIILE LA LIMITE VIA I2C

** CITIȚI INTENSITATEA AVG CURENTĂ VIA I2C

* MODIFICĂRI V0.3

** COMUTATOR PENTRU 2 MODURI - TRACK (NO I2C) și CONFIGURE (USES I2C)

** SOMNUL ÎN MODUL TRACK (PRECIZIE FOARTE SCĂZUTĂ DATORI DE 8 SECȚIUNI)

** DESPOZIȚI / ATAȘAȚI SERVICIILE PE SOMN / TREZI (TRANSISTORUL UTILIZAT EVENTUAL)

** ELIMINAȚI POZIȚIA INIȚIALĂ CONFIGURABILĂ (REDUNDANȚĂ)

** ELIMINAȚI SECUNDE DE TREZIRE CONFIGURABILE (REDUNDANTE)

** ELIMINAȚI ACTIVAȚI / DEZACTIVAȚI CONFIGURABIL (REDUNDANT)

** ELIMINAȚI TRACKERUL CONFIGURABIL ACTIVAT (UTILIZAȚI COMUTATORUL HARDWARE)

** ELIMINAȚI GETTERUL DE TENSIUNE - VA UTILIZA COMPONENTUL I2C SEPARAT

** ADĂUGAȚI ÎNREGISTRARE SERIALĂ CÂND NU UTILIZAȚI I2C

*/

#include

#include

#include

#include

#include

# 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 // media tuturor LDRS

# defineIDX_DUSK_INTENSITY13 // media tuturor LDRS

# defineIDX_END_EEPROM_SET14

# defineIDX_CURRENT_INTENSITY15 // media tuturor LDRS - utilizată pentru calcularea luminii non-directe ambiante IDX_DAWN_INTENSITY

# defineIDX_END_VALUES_GET16

# defineIDX_SIGN_117

# defineIDX_SIGN_218

# defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

octet _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 _angleH = 90;

int _angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

octet _i2cResponse = 0;

bool _inConfigMode = false;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println („Mod configurare”);

Serial.print ("Adresa I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (receiveEvent);

Wire.onRequest (requestEvent);

} altceva {

Serial.println („Mod de urmărire”);

delay (5000); // timpul pentru a scăpa de mâini dacă conectați bateria etc.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// ToDo: PORNIȚI INTERRUPTORUL TRANSISTORULUI

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

dacă (i! = 0) {

getLightValues ();

}

moveServos ();

}

întârziere (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: OPRIȚI INTERRUPTORUL TRANSISTORULUI

întârziere (500);

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

}

}

// --------------------------------- MODUL ACTUAL

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom () {

dacă(

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");

for (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");

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

_i2cVals = EEPROM.read (i);

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

}

}

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

voidreceiveEvent (int count) {

if (count == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

octet index = Wire.read ();

valoare octet = Wire.read ();

comutator (cmd) {

cazul „G”:

if (index <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [index];

}

pauză;

cazul „S”:

if (index <IDX_END_EEPROM_SET) {

_i2cVals [index] = valoare;

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

}

pauză;

Mod implicit:

întoarcere;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDR-uri

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] = hartă (avgIntensity, 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]) {

// mergand la stanga

Serial.println ("moveServos merge la stânga");

delay (_slowingDelay);

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

_servoH.write (_angleH--);

delay (_servoLoopDelay);

}

}

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

// mergând dreapta

Serial.println ("moveServos merge la stânga");

delay (_slowingDelay);

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

_servoH.write (_angleH ++);

delay (_servoLoopDelay);

}

}

altceva {

// facand nimic

Serial.println ("moveServos nu face nimic");

delay (_slowingDelay);

}

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

// merge în sus

Serial.println ("moveServos merge în sus");

delay (_slowingDelay);

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

_servoV.write (_angleV ++);

delay (_servoLoopDelay);

}

}

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

// merge in jos

Serial.println ("moveServos merge în jos");

delay (_slowingDelay);

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

_servoV.write (_angleV--);

delay (_servoLoopDelay);

}

}

altceva {

Serial.println ("moveServos nu face nimic");

delay (_slowingDelay);

}

}

//---------------------------------DORMI

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("asleepFor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

vizualizați rawtilt_pan_tracker_0.3.ino găzduit cu ❤ de GitHub

Pasul 4: Asamblarea carcasei circuitului

1. Asigurați-vă că Ardiuno Pro Mini este introdus în anteturile de pe PCB.
2. Introduceți baza cutiei controlerului SOLAR TRACKER în pereții cutiei controlerului SOLAR TRACKER și fixați-l cu 2 șuruburi autofiletante din inox 4G x 6mm.
3. Introduceți PCB-ul Ardiuno Pro Mini + cu antet 6P înclinat în gol în baza cutiei controlerului SOLAR TRACKER.
4. Introduceți capacul cutiei controlerului SOLAR TRACKER în pereții casetei controlerului SOLAR TRACKER și fixați-l cu 2 șuruburi autofiletante din inox 4G x 6mm.
5. Așezați ansamblul de mai sus la baza cadrului panoului cu 4 șuruburi autofiletante 4G x 6mm inox.

Pasul 5: Conectarea cablurilor Rig la controler

Conexiunile pertinente, pregătite din instructabilul anterior, sunt 4 conexiuni LDR 2P și 2 conexiuni 3P de pe servere. Ceea ce este temporar până când reîncărcarea este gata este bateria. Folosiți un LiPo de 3,7 V care se termină deocamdată într-o conexiune 2P DuPont.

1. Introduceți conexiunile LDR (fără polaritate) de sus:

   1. Sus în dreapta
   2. Stânga sus
   3. Dreapta-jos
   4. Stânga jos

2. Introduceți conexiunile Servo (cu firul de semnal spre stânga) de sus:

   1. Orizontală
   2. Vertical
3. AȘTEPTAȚI PÂNĂ Gata pentru testare: Introduceți cablul de alimentare de 3.7V DC + ve în partea de sus, -ve în partea de jos.

Pasul 6: Testarea controlerului

După cum sa menționat anterior, software-ul nu a fost optimizat pentru fluxul de lucru de încărcare solară. Poate fi testat și modificat folosind surse de lumină naturale (soare) și nenaturale.

Pentru a testa urmărirea într-un mediu controlat, poate fi convenabil să setați SLEEP MINUTES la o valoare mai mică (consultați pasul următor).

Pasul 7: Configurarea prin I2C folosind Console Input

Acest lucru explică configurarea controlerului printr-un al doilea MCU, introducerea setărilor într-o fereastră de consolă.

1. Încărcați următorul script pe un D1M WIFI BLOCK (sau Wemos D1 Mini).
2. Deconectați USB de la PC

3. CONEXIUNI PIN: -ve (Controller) => GND (D1M) + ve (Controller) => 3V3 (D1M) SCL (Controller) => D1 (D1M)

   SDA (controler) => D2 (D1M)

4. Rotiți comutatorul SPDT pe CONFIG
5. Conectați USB la computer
6. Din Arduino IDE porniți o fereastră de consolă cu portul COM corect
7. Asigurați-vă că sunt selectate „Newline” și „9600 baud”
8. Comenzile sunt introduse în Send Textbox urmată de tasta Enter
9. Comenzile au formatul Octet de caractere octet
10. Dacă al doilea octet (al treilea segment) nu este inclus 0 (zero) este trimis de script
11. Aveți grijă la utilizarea intrării seriale; examinați ce ați introdus înainte de a apăsa tasta „Enter”. Dacă sunteți blocat (de exemplu, schimbarea adresei I2C la o valoare pe care ați uitat-o) va trebui să blocați din nou firmware-ul controlerului.

Variațiile acceptate în primul caracter de comandă sunt:

• E (Enable servo tracking) util pentru oprirea mișcării în timpul configurării. Aceasta este introdusă folosind: E 0
• D (Dezactivați urmărirea servo) util pentru a porni urmărirea automată dacă nu reporniți dispozitivul. Aceasta este introdusă folosind: D 0
• G (Obțineți valoarea de configurare) citește valorile din EEPROM și IN-MEMORY: Aceasta este introdusă folosind: G (indexul este valorile de octet valide 0 - 13 și 15)
• S (Setează valoarea EEPROM) setează valorile la EEPROM care sunt disponibile după repornire. Aceasta este introdusă folosind: S (indexul are valori de octet valide 0 - 13, valoarea este valori de octet valide și variază în funcție de proprietate)

Codul este punctul de adevăr pentru indexuri, dar următoarele sunt folosite pentru un ghid pentru valori / comentarii valide:

• ADRESA I2C 0 - adresa slave a controlerului, comandantul are nevoie de aceasta pentru a comunica cu controlerul (implicit 10)
• UNGHIUL VERTICAL MINIM 1 - limita inferioară a servo-unghiului vertical (implicit 10, interval 0 - 180)
• UNGHIUL VERTICAL MAXIM 2 - limita superioară a servo-unghiului vertical (implicit 170, interval 0 - 180)
• SENSIBILITATE VERTICAL LDR 3 - Marjă de citire verticală LDR (implicit 20, interval 0 - 1024)
• UNGUL VERTICAL PASUL 4 - trepte servo unghiulare verticale pe fiecare reglare (implicit 5, interval 1 - 20)
• UNGHIUL MINIMAL ORIZONTAL 5 - limita inferioară a servo unghiului orizontal (implicit 10, interval 0 - 180)
• UNghiul MAXIM ORIZONTAL 6 - limita superioară a servo unghiului orizontal (implicit 170, interval 0 - 180)
• SENSIBILITATE HORIZONTAL LDR 7 - Marjă de citire LDR orizontală (implicit 20, interval 0 - 1024)
• PASUL 8 UNGHIAR ORIZONTAL - servo unghi orizontal pe fiecare reglare (implicit 5, interval 1 - 20)
• SLEEP MINUTES 9 - perioada aproximativă de somn între urmărire (implicit 20, interval 1 - 255)
• UNGHIUL VERTICAL AL ZILEI 10 - UTILIZARE VIITORĂ - unghiul vertical pentru a reveni la apusul soarelui
• UNGHIUL ORIZONTAL AL ZILEI 11 - UTILIZARE VIITORĂ - unghiul orizontal la care să reveniți când soarele apune
• INTENȚIUNEA DAWN 12 - UTILIZARE FUTURĂ - media minimă a tuturor LDR-urilor care declanșează un început de urmărire zilnică a soarelui
• INTENSITATE DUSK 13 - UTILIZARE FUTURĂ - media minimă a tuturor LDR-urilor care declanșează sfârșitul urmăririi zilnice a soarelui
• FINALUL VALORILOR EEPROM MARKER 14 - VALOARE NEUTILIZATĂ
• INTENSITATE CURENTĂ 15 - procentul mediu actual al intensității luminii
• MARKER 16 DE VALORI ÎN MEMORIE - VALOARE NEUTILIZATĂ.

Captează intrarea serială (intrarea tastaturii în fereastra consolei) și o redirecționează către un slave I2C în format char, octet, octet

#include

# defineI2C_MSG_IN_SIZE2

# defineI2C_MSG_OUT_SIZE3

# defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

octet const _numChars = 32;

char _receivedChars [_numChars]; // o matrice pentru stocarea datelor primite

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

întârziere (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

octet static ndx = 0;

char endMarker = '\ n';

char rc;

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

rc = Serial.read ();

if (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

if (ndx> = _numChars) {

ndx = _numChars - 1;

}

} altceva {

_receivedChars [ndx] = '\ 0'; // terminați șirul

ndx = 0;

_newData = adevărat;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

char * token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

octet index = 0;

valoarea octetului = 0;

int i = 0;

while (token! = NULL) {

//Serial.println(token);

i ++;

comuta (i) {

cazul 1:

token = strtok (NULL, delim);

index = atoi (token);

pauză;

caz 2:

token = strtok (NULL, delim);

if (token! = NULL) {

valoare = atoi (token);

}

pauză;

Mod implicit:

token = NULL;

}

}

sendCmd (cmd, index, valoare);

_newData = false;

}

}

voidsendCmd (char cmd, index octet, valoare octet) {

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

Serial.println ("Comanda de trimitere:");

Serial.println ("\ t" + Șir (cmd) + "" + Șir (index) + "" + Șir (valoare));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // transmite la dispozitiv

Wire.write (cmd); // trimite un char

Wire.write (index); // trimite un octet

Wire.write (valoare); // trimite un octet

Wire.endTransmission ();

răspuns de octeți = 0;

bool hadResponse = false;

if (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

în timp ce (Wire.available ()) // slave poate trimite mai puțin decât s-a solicitat

{

hadResponse = adevărat;

răspuns = Wire.read ();

}

if (hadResponse == true) {

Serial.println („Obținerea răspunsului:”);

Serial.println (răspuns);

} altceva {

Serial.println ("Fără răspuns, verificați adresa / conexiunea");

}

}

}

vizualiza rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino găzduit cu ❤ de GitHub

Pasul 8: Pașii următori

Reveniți periodic pentru a verifica modificările software-ului / hardware-ului.

Modificați software-ul / hardware-ul în funcție de cerințele dvs.

Comentează orice solicitare / optimizare.