IOT123 - INSEGUITORE SOLARE - CONTROLLORE: 8 Passi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Questa è un'estensione di Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL FRAME, LDR MOUNTS RIG. Qui ci concentriamo sul controller dei servi e sui sensori della posizione del sole. È importante sottolineare che questo progetto presuppone l'utilizzo di 2 MCU: uno (3,3 V 8 mHz Arduino Pro Mini) per l'inseguitore solare e un MCU indipendente per i sensori/attori.

Questa è la versione 0.3

Piuttosto che pubblicare tutti i progetti dopo la completa soddisfazione, praticherò l'integrazione continua e consegnerò qualcosa più spesso, modificando ciò che ho consegnato secondo le mie necessità. Scriverò un'altra istruzione per il caricabatterie, _quando_ l'ottimizzazione del software/hardware del controller sarà completata. Indicherò dove sono necessarie le ottimizzazioni man mano che procediamo.

Parte del motivo di questo approccio è il feedback del cliente. Se vedete una necessità o avete un approccio migliore, per favore commentate, ma tenete a mente che non posso consegnare tutto e forse non in un lasso di tempo che vi si addice. Poiché queste spiegazioni sembrano meno rilevanti, verranno eliminate da questo articolo.

Cosa include:

1. Usa gli LDR dell'Instructable originale per rilevare la posizione approssimativa del sole.
2. Sposta i servi verso il sole.
3. Opzioni per la sensibilità dei movimenti.
4. Opzioni per la dimensione del passo quando ci si sposta al sole.
5. Opzioni per i vincoli angolari utilizzati sui servi.
6. Opzioni per i ritardi degli spostamenti.
7. Interfaccia I2C per impostare/ottenere valori tra MCU.
8. Sonno profondo tra i movimenti.

Cosa questo non include (e verrà affrontato quando il tempo lo consente):

1. Utilizzo dell'energia solo durante le ore diurne.
2. Ricordando la posizione dell'alba e andando lì al tramonto.
3. Rimozione del regolatore dall'MCU.
4. Disabilitazione dei LED sull'MCU.
5. Reindirizzamento dell'alimentazione tramite VCC anziché RAW.
6. Fornire soluzioni alternative per il flashing senza alimentazione regolata dal convertitore da USB a seriale TTL.
7. Monitoraggio della tensione della batteria.

STORIA

20 dicembre 2017 V0.1 CODICE

La versione iniziale tiene traccia della sorgente luminosa, sempre accesa, senza ricarica

7 gennaio 2018 CODICE V0.2

• MODIFICHE HARDWARE

  • Aggiungi pin I2C
  • Aggiungi interruttore ai servo GND
  • Etichetta stampata sulla fascia della scatola del controller

• MODIFICHE SOFTWARE

  • Leggi la configurazione da EEPROM
  • Supporto bus I2C come slave per un altro MCU (3,3 V)
  • Imposta configurazione tramite I2C
  • Imposta abilitato tramite I2C
  • Ottieni la configurazione tramite I2C
  • Ottieni proprietà di runtime tramite I2C (attualmente abilitato e Current Light Intensity)
  • Rimuovi la registrazione seriale (influiva sui valori I2C)

19 gennaio 2018 V0.3 CODICE

• HARDWARE

  Etichetta aggiornata. L'interruttore è ora utilizzato per scegliere la modalità CONFIG o TRACK

• SOFTWARE

  • I2C utilizzato solo per la configurazione
  • Il controller attende 5 secondi prima di inizializzare il tracciamento, consente di muovere le mani
  • Per utilizzare la configurazione I2C, SPDT deve essere su CONFIG all'avvio dell'unità
  • Tra il movimento di tracciamento, l'unità è in modalità di sospensione profonda per il valore di configurazione MINUTI DI SONNO (predefinito 20 minuti).

Passaggio 1: materiali e strumenti

Ora c'è un elenco completo della distinta materiali e delle fonti.

1. Parti stampate in 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 di 4x6cm Double Side Prototype PCB Circuito stampato universale (da tagliare a metà)
4. 1 connettore maschio 40P (da tagliare a misura).
5. 1 connettore femmina 40P (da tagliare a misura).
6. 4 resistenze da 10K 1/4W.
7. Cavo di collegamento.
8. Saldare e ferro.
9. 20 viti autofilettanti a testa piatta in acciaio inossidabile da 4 G x 6 mm.
10. 4 viti autofilettanti a testa svasata in acciaio inossidabile da 4 G x 6 mm.
11. 1 batteria LiPo da 3,7 V e supporto (terminazione con connettori dupont 2P).
12. 1 intestazione ad angolo retto maschio 2P
13. 1 interruttore SPDT a 3 pin passo 2,54 mm
14. Colla cianoacrilica forte
15. Connettore Dupont femmina 1P header (1 off blu, 1 off verde).

Passaggio 2: assemblaggio del circuito

Il circuito attualmente non ha il circuito divisore di tensione (voltmetro).

1. Tagliare a metà il circuito stampato universale PCB del prototipo a doppia faccia 4x6 cm lungo l'asse lungo.

2. Taglia a pezzi l'intestazione maschio 40P:

   1. 2 fuori 12P
   2. 3 off 3P
   3. 6 off 2P.

3. Taglia a pezzi l'intestazione femmina 40P:

   1. 2 fuori 12P
   2. 1 off 6P
4. Saldare 2 connettori femmina 12P come mostrato.
5. Incolla il distanziatore rimosso da un connettore maschio 3P (aggiuntivo) sul lato inferiore dell'interruttore SPDT con colla cianoacrilica
6. Sull'altro lato, quindi saldare 6 su 2P, 2 su 3P maschio e l'interruttore SPDT come mostrato.
7. Saldare 4 resistori da 10K (A, B, C, D nero) tramite cavo all'intestazione del pin GND (n.2 nero) e ai pin dell'intestazione A0 - A3 (n.5, #6, #7, #8) quindi attraverso il foro (giallo) come mostrato (3 foto + 1 diagramma).
8. Tracciare 3.3V dai PIN LDR PINS di saldatura #4, #6, #8, #10 e filettare attraverso il foro al pin VCC dell'intestazione femmina (verde).
9. Tracciare 3,3 V sul lato dell'intestazione femmina come mostrato (rosso) saldando ai PIN n. 1, n. 12, n. 15.
10. Foro passante da 3,3 V il PIN #1 dell'intestazione RAW sul lato (rosso) saldato.
11. Tracciare il collegamento arancione dal PIN #11 attraverso il foro al perno femmina a saldare sull'altro lato come mostrato.
12. Traccia e salda il filo di collegamento blu dal #20 al #30 e dal #31 al #13 e al #16.
13. Saldare il PIN #11 dell'intestazione femmina al PIN #11 dell'intestazione maschio attraverso il foro.
14. Preparare 2 connettori dupont lunghi 30 mm con intestazione 1P femmina (1 blu, 1 verde). Striscia e stagna l'altra estremità.
15. Saldare il filo Dupont blu al n. 28; saldare il cavo Dupont verde al n. 29.
16. Sulla parte superiore dell'Arduino fissare l'intestazione femmina 6P, quindi saldare.
17. Sulla parte superiore dell'Arduino fissare l'intestazione femmina ad angolo retto 2P int # 29 e # 30, quindi saldare.
18. Sul lato inferiore dell'Arduino fissare i 2 pin 12P e 1 off 3P maschio, quindi saldare.
19. Inserire i pin 12P maschio Arduino nelle intestazioni femmina PCB 12P.

Passaggio 3: lampeggiare l'MCU

L'Arduino Pro Mini è convenientemente flashato utilizzando un convertitore FTDI232 da USB a TTL utilizzando l'intestazione femmina 6P. Vedere la foto sopra per l'allineamento delle 2 schede.

Assicurati che l'impostazione 3.3V sia scelta sul tuo FTDI232. Segui le istruzioni qui usando il codice qui sotto (usa il link al GIST).

La libreria a basso consumo (allegata e https://github.com/rocketscream/Low-Power) deve essere installata.

Una volta che Arduino Pro Mini + PCB è installato nell'involucro, può ancora essere lampeggiato poiché i pin dell'intestazione sono esposti. Basta scollegare l'unità di controllo dal telaio del pannello esponendo l'intestazione.

Inseguitore solare inclinabile con configurazione I2C/EEPROM e ciclo di sonno tra i movimenti. La precisione della durata del ciclo del sonno diminuisce all'aumentare della durata, ma è sufficiente per questo scopo

/*

* modificato dal codice

* di Mathias Leroy

*

* MODIFICHE V0.2

** I2C SET OTTIENI

** IMPOSTAZIONE EEPROM OTTIENI

** RIMUOVERE USCITA SERIALE - INTERESSATO I2C

**ABILITA/DISATTIVA IL TRACCIAMENTO

** SPOSTA I SERVI AI LIMITI TRAMITE I2C

** LEGGERE L'INTENSITÀ MEDIA CORRENTE VIA I2C

* V0.3 MODIFICHE

** INTERRUTTORE PER 2 MODALITÀ - TRACCIA (NO I2C) e CONFIGURA (UTILIZZA I2C)

** DORMIRE IN MODALITÀ TRACK (PRECISIONE MOLTO BASSA GRAZIE A 8 SECONDI BLOCCHI)

** STACCO/ATTACCO SERVI SU SLEEP/WAKE (EVENTUALE TRANSISTORE UTILIZZATO)

** RIMUOVERE POSIZIONE INIZIALE CONFIGURABILE (RIDONDANTE)

** RIMUOVERE SECONDI DI SVEGLIA CONFIGURABILI (RIDONDANTE)

** RIMUOVERE CONFIGURABILE ABILITA/DISABILITA (RIDONDANTE)

** RIMUOVERE TRACKER CONFIGURABILE ABILITATO (UTILIZZARE SWITCH HARDWARE)

** RIMUOVERE IL VOLTAGE GETTER - UTILIZZERÀ IL COMPONENTE I2C SEPARATO

** AGGIUNGI REGISTRAZIONE SERIALE QUANDO NON SI UTILIZZA I2C

*/

#includere

#includere

#includere

#includere

#includere

#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 di tutti i LDRS

#defineIDX_DUSK_INTENSITY13// media di tutti i LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15// media di tutti LDRS - utilizzata per calcolare IDX_DAWN_INTENSITY luce ambientale non diretta

#defineIDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

byte _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 _angoloH = 90;

int _angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

byte _i2cResponse = 0;

bool _inConfigMode = false;

voidsetup()

{

Serial.begin(115200);

getFromEeprom();

if (inConfigMode()){

Serial.println("Modalità configurazione");

Serial.print("Indirizzo I2C: ");

Serial.println(_i2cVals[IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

}altro{

Serial.println("Modalità di monitoraggio");

delay(5000);// tempo per togliersi le mani se si collega la batteria, ecc.

}

}

anello vuoto()

{

getLightValues();

if (!_inConfigMode){

// Da fare: ACCENDERE L'INTERRUTTORE DEL TRANSISTORE

_servoH.attach(PIN_SERVO_H);

_servoV.attach(PIN_SERVO_V);

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

se (io!= 0){

getLightValues();

}

moveServos();

}

ritardo (500);

_servoH.detach();

_servoV.detach();

// Da fare: SPEGNERE L'INTERRUTTORE DEL TRANSISTORE

ritardo (500);

addormentatoFor((_i2cVals[IDX_SLEEP_MINUTES] * 60) / 8);

}

}

//---------------------------------MODALITÀ ATTUALE

boolinConfigMode(){

pinMode(PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead(PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom(){

Se(

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 (conta == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read();

indice di byte = Wire.read();

valore in byte = Wire.read();

interruttore (cmd) {

caso'G':

if (indice< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals[indice];

}

rottura;

caso'S':

if (indice< IDX_END_EEPROM_SET){

_i2cVals[indice] = valore;

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

}

rottura;

predefinito:

Restituzione;

}

}

}

voidrequestEvent()

{

Wire.write(_i2cResponse);

}

//---------------------------------LDR

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] = map(avgIntensity, 0, 1024, 0, 255);

}

//---------------------------------SERVO

voidmoveServos(){

Serial.println("moveServos");

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

// vado a sinistra

Serial.println("moveServos che va a sinistra");

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]) {

// va a destra

Serial.println("moveServos che va a sinistra");

delay(_slowingDelay);

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

_servoH.write(_angleH++);

delay(_servoLoopDelay);

}

}

altro {

// facendo nulla

Serial.println("moveServos non fa nulla");

delay(_slowingDelay);

}

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

// salendo

Serial.println("moveServos in salita");

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]) {

// andando giù

Serial.println("moveServos in discesa");

delay(_slowingDelay);

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

_servoV.write(_angleV--);

delay(_servoLoopDelay);

}

}

altro {

Serial.println("moveServos non fa nulla");

delay(_slowingDelay);

}

}

//---------------------------------DORMIRE

voidasleepFor(unsignedint eightSecondSegments){

Serial.println("asleepFor");

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

{

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

visualizza rawtilt_pan_tracker_0.3.ino ospitato con ❤ da GitHub

Passaggio 4: assemblaggio dell'involucro del circuito

1. Assicurarsi che Ardiuno Pro Mini sia inserito nelle intestazioni del PCB.
2. Inserire la base della scatola del controller SOLAR TRACKER nelle pareti della scatola del controller SOLAR TRACKER e fissarla con 2 viti autofilettanti a testa svasata in acciaio da 4G x 6 mm.
3. Inserire Ardiuno Pro Mini + PCB con intestazione 6P che si incastra nel vuoto nella base della scatola del controller SOLAR TRACKER.
4. Inserire il coperchio della scatola del controller SOLAR TRACKER nelle pareti della scatola del controller SOLAR TRACKER e fissarlo con 2 viti autofilettanti a testa svasata in acciaio da 4G x 6 mm.
5. Fissare il gruppo sopra alla base del telaio del pannello con 4 viti autofilettanti a testa svasata in acciaio da 4 G x 6 mm.

Passaggio 5: collegamento dei cavi dell'impianto di perforazione al controller

Le connessioni pertinenti pronte dal precedente Instructable, sono 4 connessioni 2P LDR e 2 connessioni 3P dai servi. Ciò che è temporaneo finché la ricarica non è pronta è la batteria. Usa un LiPo da 3,7 V che termina con una connessione DuPont 2P per ora.

1. Inserire le connessioni LDR (nessuna polarità) dall'alto:

   1. In alto a destra
   2. In alto a sinistra
   3. In basso a destra
   4. In basso a sinistra

2. Inserire i collegamenti Servo (con il cavo di segnale a sinistra) dall'alto:

   1. Orizzontale
   2. Verticale
3. ATTENDERE IL PRONTO PER IL TEST POI: Inserire il cavo di alimentazione da 3,7 V CC +ve in alto, -ve in basso.

Passaggio 6: test del controller

Come affermato in precedenza, il software non è stato ottimizzato per il flusso di lavoro di ricarica solare. Tuttavia, può essere testato e ottimizzato utilizzando fonti di luce naturali (sole) e innaturali.

Per testare il tracciamento in un ambiente controllato può essere conveniente impostare i MINUTI DI SONNO su un valore più basso (vedi passaggio successivo).

Passaggio 7: configurazione tramite I2C utilizzando l'ingresso della console

Questo spiega la configurazione del controller tramite un secondo MCU, inserendo le impostazioni in una finestra della console.

1. Carica il seguente script su un BLOCCO WIFI D1M (o Wemos D1 Mini).
2. Scollega l'USB dal PC

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

   SDA (Controllore) => D2 (D1M)

4. Portare l'interruttore SPDT su CONFIG
5. Collega l'USB al PC
6. Dall'IDE Arduino avvia una finestra della console con la porta COM corretta
7. Assicurati che "Newline" e "9600 baud" siano selezionati
8. I comandi vengono inseriti nella casella di testo di invio seguito dal tasto Invio
9. I comandi sono nel formato Carattere byte byte
10. Se il secondo byte (terzo segmento) non è incluso 0 (zero) viene inviato dallo script
11. Fare attenzione utilizzando l'input seriale; rivedere ciò che hai inserito prima di premere il tasto "Invio". Se sei bloccato (ad esempio cambiando l'indirizzo I2C con un valore che hai dimenticato) dovrai eseguire nuovamente il flashing del firmware del controller.

Le variazioni supportate nel primo carattere del comando sono:

• E (Abilita inseguimento servo) utile per fermare il movimento durante la configurazione. Questo è inserito usando: E 0
• D (Disable servo tracking) utile per avviare il tracking automatico se non si riavvia il dispositivo. Questo è inserito usando: D 0
• G (Ottieni valore di configurazione) legge i valori da EEPROM e IN-MEMORY: Questo è inserito usando: G (l'indice è valori di byte validi 0 - 13 e 15)
• S (Imposta valore EEPROM) imposta i valori su EEPROM che sono disponibili dopo il riavvio. Questo viene immesso utilizzando: S (l'indice è valori di byte validi 0 - 13, il valore è valori di byte validi e varia in base alla proprietà)

Il codice è il punto di verità per gli indici, ma quanto segue viene utilizzato come guida per valori/commenti validi:

• I2C ADDRESS 0 - indirizzo slave controller, il master ha bisogno di questo per comunicare con il controller (default 10)
• ANGOLO VERTICALE MINIMO 1 - limite inferiore servo angolo verticale (default 10, range 0 - 180)
• ANGOLO VERTICALE MASSIMO 2 - limite superiore servo angolare verticale (default 170, range 0 - 180)
• SENSIBILITÀ LDR VERTICALE 3 - Margine di lettura LDR verticale (predefinito 20, intervallo 0 - 1024)
• ANGOLO VERTICALE STEP 4 - servo gradini verticali dell'angolo su ogni regolazione (default 5, range 1 - 20)
• ANGOLO ORIZZONTALE MINIMO 5 - limite inferiore servo angolo orizzontale (default 10, range 0 - 180)
• ANGOLO ORIZZONTALE MASSIMO 6 - limite superiore servo angolo orizzontale (default 170, range 0 - 180)
• SENSIBILITÀ LDR ORIZZONTALE 7 - Margine di lettura LDR orizzontale (predefinito 20, intervallo 0 - 1024)
• PASSO ANGOLARE ORIZZONTALE 8 - servo gradini orizzontali dell'angolo su ogni regolazione (default 5, range 1 - 20)
• MINUTI DI SONNO 9 - il periodo di sonno approssimativo tra il monitoraggio (predefinito 20, intervallo 1 - 255)
• ANGOLO DI ALBA VERTICALE 10 - USO FUTURO - l'angolo verticale a cui tornare quando il sole tramonta
• ANGOLO DI ALBA ORIZZONTALE 11 - USO FUTURO - l'angolo orizzontale a cui tornare quando il sole tramonta
• DAWN INTENSITY 12 - USO FUTURO - la media minima di tutti gli LDR che attiva l'inizio dell'inseguimento solare giornaliero
• INTENSITÀ DEL TRAMONTO 13 - USO FUTURO - la media minima di tutti gli LDR che attiva la fine dell'inseguimento solare giornaliero
• MARKER DI FINE VALORI EEPROM 14 - VALORE NON UTILIZZATO
• INTENSITÀ CORRENTE 15 - la percentuale media attuale dell'intensità luminosa
• MARKER FINE DEI VALORI IN MEMORIA 16 - VALORE NON UTILIZZATO.

Cattura l'input seriale (input da tastiera nella finestra della console) e lo inoltra a uno slave I2C nel formato char, byte, byte

#includere

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

booleano _newData = false;

const byte _numChars = 32;

char _receivedChars[_numChars]; // un array per memorizzare i dati ricevuti

voidsetup() {

Serial.begin(9600);

Wire.begin(D2, D1);

ritardo (5000);

}

voidloop() {

recvWithEndMarker();

parseSendCommands();

}

voidrecvWithEndMarker() {

byte statico 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;

}

} altro {

_receivedChars[ndx] = '\0'; // termina la stringa

ndx = 0;

_newData = vero;

}

}

}

voidparseSendCommands() {

if (_newData == true) {

constchar delim[2] = "";

char *token;

token = strtok(_receivedChars, delim);

char cmd = _receivedChars[0];

indice di byte = 0;

valore in byte = 0;

int i = 0;

while(token != NULL) {

//Serial.println(token);

io++;

interruttore (i){

caso 1:

token = strtok(NULL, delim);

indice = atoi(token);

rottura;

caso2:

token = strtok(NULL, delim);

if (token != NULL){

valore = atoi(token);

}

rottura;

predefinito:

token = NULL;

}

}

sendCmd(cmd, indice, valore);

_newData = falso;

}

}

voidsendCmd(char cmd, byte index, byte value) {

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

Serial.println("Invio comando:");

Serial.println("\t" + String(cmd) + "" + String(indice) + "" + String(valore));

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

Wire.beginTransmission(I2C_SLAVE_ADDRESS); // trasmette al dispositivo

Wire.write(cmd); // invia un carattere

Wire.write(indice); // invia un byte

Wire.write(valore); // invia un byte

Wire.endTransmission();

byte di risposta = 0;

bool hadResponse = false;

if (cmd == 'G'){

Wire.requestFrom(I2C_SLAVE_ADDRESS, 1);

while(Wire.available()) // lo slave può inviare meno di quanto richiesto

{

hadResponse = true;

risposta = Wire.read();

}

if (hadResponse == true){

Serial.println("Ricevo risposta:");

Serial.println(risposta);

}altro{

Serial.println("Nessuna risposta, controlla l'indirizzo/connessione");

}

}

}

visualizza rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino ospitato con ❤ da GitHub

Passaggio 8: passaggi successivi

Ricontrolla periodicamente per verificare le modifiche al software/hardware.

Modifica il software/hardware in base alle tue esigenze.

Commenta eventuali richieste/ottimizzazioni.