IOT123 - SEGUIDOR SOLAR - CONTROLADOR: 8 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

Aquesta és una extensió de l’instructible

IOT123 - SEGUIDOR SOLAR - TILT / PAN, MARC DE PANELL, MONTAJE LDR. Aquí ens concentrem en el controlador dels servos i els sensors de la posició del sol. És important assenyalar que aquest disseny suposa que s’utilitzaran 2 MCU: una (Arduino Pro Mini de 3,3 V 8 MHz) per al rastrejador solar i una MCU independent per als vostres sensors / actors.

Aquesta és la versió 0.3

En lloc de publicar tots els projectes després de la satisfacció completa, practicaré la integració contínua i lliuraré alguna cosa més sovint, modificant allò que he lliurat segons necessiti. Escriuré una altra instrucció per al carregador de bateria, _quan_ s'hagi completat l'optimització del programari / maquinari del controlador. Assenyalaré on es necessiten les optimitzacions a mesura que passem per això.

Part del motiu d’aquest enfocament són els comentaris dels clients. Si veieu una necessitat o teniu un enfocament millor, comenteu-ho, però tingueu en compte que no puc lliurar-ho tot i, possiblement, no en un període de temps que us convingui. Com que aquestes explicacions semblen menys rellevants, se suprimiran d’aquest article.

Què inclou:

1. Utilitzeu els LDR de l’instructible original per detectar la ubicació aproximada dels sols.
2. Mou els servos cap al sol.
3. Opcions per a la sensibilitat dels moviments.
4. Opcions per a la mida del pas en passar al sol.
5. Opcions per a les restriccions angulars utilitzades als servos.
6. Opcions per als retards dels moviments.
7. Interfície I2C per establir / obtenir valors entre MCU.
8. Son profund entre moviments.

Què no inclou (i es tractarà segons el temps que ho permeti):

1. Només utilitzeu energia durant el dia.
2. Recordant la posició de l’alba i anant-hi al tancar la nit.
3. Extracció del regulador de la MCU.
4. Desactivació dels LEDs de la MCU.
5. Reorientació de l'energia mitjançant VCC en lloc de RAW.
6. Proporciona solucions per parpellejar sense alimentació regulada des del convertidor USB a serial TTL.
7. Monitor de tensió de la bateria.

HISTORYRIA

20 de desembre de 2017 CODI V0.1

La versió inicial fa un seguiment de la font de llum, sempre activada, sense càrrega

7 de gener de 2018 CODI V0.2

• CANVIS DE HARDWARE

  • Afegiu pins I2C
  • Afegiu un commutador als servo GND
  • Etiqueta impresa a la carcassa de la caixa del controlador

• CANVIS DE PROGRAMARI

  • Llegiu la configuració des de EEPROM
  • Suport del bus I2C com a esclau d'un altre MCU (3,3 V)
  • Configureu la configuració mitjançant I2C
  • Estableix activat mitjançant I2C
  • Obteniu configuració mitjançant I2C
  • Obteniu propietats en temps d'execució mitjançant I2C (actualment activat i intensitat de llum actual)
  • Elimina el registre en sèrie (afectava els valors I2C)

19 de gener de 2018 CODI V0.3

• HARDWARE

  S'ha actualitzat l'etiqueta. Ara s’utilitza el commutador per triar el mode CONFIG o TRACK

• PROGRAMARI

  • I2C només s'utilitza per a la configuració
  • El controlador espera 5 segons abans d'iniciar el seguiment, permet moure les mans
  • Per utilitzar la configuració I2C, SPDT ha d’estar a CONFIG com a arrencades de la unitat
  • Entre el moviment de seguiment, la unitat està en mode de repòs profund per obtenir el valor de configuració SLEEP MINUTES (predeterminat 20 minuts).

Pas 1: materials i eines

Ara hi ha una llista completa de la llista de materials i fonts.

1. Parts impreses en 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 de placa de circuit imprès universal de prototip de doble cara de 4x6cm (per tallar per la meitat)
4. 1 capçalera masculina de 40P (per tallar a mida).
5. 1 capçal femení de 40P (per tallar a mida).
6. 4 restauradors de 10K 1 / 4W de descompte.
7. Cable de connexió.
8. Soldadura i ferro.
9. 20 cargols autorroscants de 4G x 6mm de capçal inoxidable.
10. 4 cargols autofiletants avellanats de 4G x 6mm inox.
11. 1 off de bateria i suport LiPo de 3,7 V (que finalitza en connectors dupont 2P).
12. 1 capçal d'angle recte masculí 2P de 2P
13. 1 commutador SPDT de 3 pins de 2,54 mm de pas
14. Cola forta de cianoacrilat
15. Connectors Dupont capçalera 1P femella (1 de color blau, 1 de color verd).

Pas 2: Muntatge del circuit

El circuit actualment no té el circuit divisor de tensió (voltímetre).

1. Talla la placa de circuit imprès universal de PCB de prototip lateral de 4x6 cm per la meitat a través de l'eix llarg.

2. Talla la capçalera masculina 40P en trossos:

   1. 2 de descompte a 12P
   2. 3 de descompte a 3P
   3. 6 de descompte en 2P.

3. Talla la capçalera femenina 40P en trossos:

   1. 2 de descompte a 12P
   2. 1 de descompte a 6P
4. Soldadura 2 fora de la capçalera femenina 12 com es mostra.
5. Enganxeu l’espaiador retirat d’un capçal masculí 3P (addicional) a la part inferior del commutador SPDT amb cola de cianoacrilat
6. En un altre costat, col·loqueu el soldador 6 off 2P, 2 off 3Pmeader i el commutador SPDT tal com es mostra.
7. Soldeu 4 resistències de 10 K (A, B, C, D negre) mitjançant el cable a la capçalera del pin GND (negre # 2) i als passadors de capçalera A0 - A3 (# 5, # 6, # 7, # 8) i després a través del forat (groc) com es mostra (3 fotos + 1 diagrama).
8. Traça els 3,3 V dels PINS LDR PINS per soldar els PINS # 4, # 6, # 8, # 10 i enfila el forat al pin VCC de capçalera feamale (verd).
9. Traça 3,3 V al capçal femení tal com es mostra (vermell) soldant a PINS # 1, # 12, # 15.
10. Forat passant de 3,3V el PIN soldat (vermell) de la capçalera RAW # 1.
11. Traça la connexió taronja des del PIN # 11 a través del forat fins a soldar el passador femení de l’altre costat tal com es mostra.
12. Traça i solda el cable de connexió blau del número 20 al número 30 i del número 31 al número 13 i número 16.
13. PIN de capçalera femení de soldadura # 11 al PIN de capçalera masculí # 11 mitjançant el forat.
14. Prepareu 2 connectors dupont de 30 mm de llarg amb capçalera 1P femella (1 de color blau i 1 de verd). Tireu i esteneu un altre extrem.
15. Fil de soldadura blau Dupont al número 28; cable de soldadura verd Dupont al número 29.
16. A la part superior de l'Arduino, fixeu la capçalera femenina 6P i després soldeu-la.
17. A la part superior de l'Arduino, fixeu la capçalera femenina d'angle recte 2P int # 29 i # 30 i després soldeu.
18. A la part inferior de l'Arduino, fixeu els 2 pins masculins de 12P i 1 de 3P i soldeu-los.
19. Inseriu pins 12P mascle Arduino a capçaleres femelles PCB 12P.

Pas 3: Intermitent de l'MCU

L'Arduino Pro Mini es fa servir fàcilment mitjançant un convertidor FTDI232 USB a TTL mitjançant la capçalera femella 6P. Vegeu la foto superior per veure l’alineació dels 2 taulers.

Assegureu-vos que el paràmetre de 3,3 V sigui escollit al vostre FTDI232. Seguiu les instruccions aquí mitjançant el codi següent (utilitzeu l'enllaç a GIST).

Cal instal·lar la biblioteca de baix consum (adjunta i

Un cop instal·lat el PCB Arduino Pro Mini + a la carcassa, encara es pot llampar a mesura que queden exposats els passadors de capçalera. Només heu de desconnectar la unitat de controlador del quadre del tauler exposant la capçalera.

Seguidor solar inclinable amb configuració I2C / EEPROM i cicle de son entre moviments. La precisió de la durada del cicle de son disminueix a mesura que augmenta la durada, però suficient per a aquest propòsit

/*

* modificat a partir del codi

* de Mathias Leroy

*

* V0.2 MODIFICACIONS

** SET I2C OBTÉ

** CONEIXEU EEPROM

** ELIMINEU LA SORTIDA DE SERIE: I2C AFECTAT

** ACTIVAR / DESACTIVAR EL SEGUIMENT

** MOU ELS SERVEIS ALS LÍMITS VIA I2C

** LLEGIU INTENSITAT AVG ACTUAL VIA I2C

* V0.3 MODIFICACIONS

** COMMUTADOR PER A 2 MODES: PISTA (NO I2C) i CONFIGURA (USA I2C)

** DORMIR EN MODE PISTA (PRECISIÓ MOLT BAIXA A causa de 8 SEGONS TROSSOS)

** DESACTIVAR / ATACAR ELS SERVICIS AL DORMIR / DESPERTAR (EL TRANSISTOR S'USA EVENTUALMENT)

** ELIMINA LA POSICIÓ INICIAL CONFIGURABLE (REDUNDANT)

** ELIMINA SEGONS DE DESPERTURA CONFIGURABLES (REDUNDANTS)

** ELIMINA ACTIVA / DESACTIVA CONFIGURABLE (REDUNDANT)

** ELIMINEU EL SEGUIDOR CONFIGURABLE HABILITAT (USEU EL COMMUTADOR DE HARDWARE)

** ELIMINEU EL TEMPS DE TENSIÓ: FARÀ COMPONENT I2C SEPARAT

** AFEGEIX EL REGISTRE DE SERIES QUAN NO FACIU I2C

*/

#incloure

#incloure

#incloure

#incloure

#incloure

# 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 // mitjana de tots els LDRS

# defineIDX_DUSK_INTENSITY13 // mitjana de tots els LDRS

# defineIDX_END_EEPROM_SET14

# defineIDX_CURRENT_INTENSITY15 // mitjana de tots els LDRS: s’utilitza per calcular la llum no directa ambiant IDX_DAWN_INTENSITY

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

int _angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

byte _i2cResponse = 0;

bool _inConfigMode = fals;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println ("Mode de configuració");

Serial.print ("Adreça I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (receiveEvent);

Wire.onRequest (requestEvent);

} més {

Serial.println ("Mode de seguiment");

delay (5000); // temps per treure les mans si es connecta la bateria, etc.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// Fare: ACTIVAR EL COMMUTADOR DEL TRANSISTOR

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

per a (int i = 0; i <20; i ++) {

si (i! = 0) {

getLightValues ();

}

moveServos ();

}

retard (500);

_servoH.detach ();

_servoV.detach ();

// Fer: DESACTIVAR EL COMMUTADOR DEL TRANSISTOR

retard (500);

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

}

}

// --------------------------------- MODE ACTUAL

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = DigitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom () {

si(

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

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

per a (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

_i2cVals = EEPROM.read (i);

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

}

}

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

voidreceiveEvent (recompte int) {

if (count == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

índex de bytes = Wire.read ();

valor de byte = Wire.read ();

commutador (cmd) {

cas "G":

if (índex <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [índex];

}

trencar;

cas "S":

if (índex <IDX_END_EEPROM_SET) {

_i2cVals [índex] = valor;

EEPROM.update (índex, _i2cVals [índex]);

}

trencar;

per defecte:

tornar;

}

}

}

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] = mapa (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]) {

// marxar cap a l’esquerra

Serial.println ("moveServos va cap a l'esquerra");

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

// anar a la dreta

Serial.println ("moveServos va cap a l'esquerra");

delay (_slowingDelay);

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

_servoH.write (_angleH ++);

delay (_servoLoopDelay);

}

}

més {

// no fer res

Serial.println ("moveServos sense fer res");

delay (_slowingDelay);

}

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

// pujant

Serial.println ("moveServos pujant");

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

// baixant

Serial.println ("moveServos baixant");

delay (_slowingDelay);

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

_servoV.write (_angleV--);

delay (_servoLoopDelay);

}

}

més {

Serial.println ("moveServos sense fer res");

delay (_slowingDelay);

}

}

// --------------------------------- DORMIR

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("adormitPer");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

veure rawtilt_pan_tracker_0.3.ino allotjat amb ❤ per GitHub

Pas 4: Muntatge de la carcassa del circuit

1. Assegureu-vos que l’Ardiuno Pro Mini s’insereix a les capçaleres del PCB.
2. Introduïu la base de la caixa del controlador SOLAR TRACKER a les parets de la caixa del controlador SOLAR TRACKER i col·loqueu-los amb 2 cargols autofiletants avellanats de 4G x 6mm.
3. Inseriu el PCB Ardiuno Pro Mini + amb capçalera 6P que s’inclou al buit a la base de la caixa del controlador SOLAR TRACKER.
4. Introduïu la tapa de la caixa del controlador SOLAR TRACKER a les parets de la caixa del controlador SOLAR TRACKER i col·loqueu-los amb 2 cargols autofiletants avellanats de 4G x 6mm.
5. Col·loqueu el conjunt superior a la base del marc del panell amb 4 cargols autofiletants de 4G x 6mm sense avellanar.

Pas 5: Connexió dels cables de la plataforma al controlador

Les connexions pertinents preparades per a l’anterior instructable són 4 connexions LDR 2P desactivades i 2 connexions 3P desactivades des dels servos. El que és temporal fins que la recàrrega estigui llesta és la bateria. Feu servir un LiPo de 3,7 V que finalitzi en una connexió 2P DuPont per ara.

1. Inseriu les connexions LDR (sense polaritat) des de la part superior:

   1. Dalt a la dreta
   2. A dalt a l'esquerra
   3. Abaix a la dreta
   4. Baix a l 'esquerra

2. Inseriu les connexions Servo (amb el cable de senyal a l'esquerra) des de la part superior:

   1. Horitzontal
   2. Vertical
3. ESPERA FINS QUE ESTÀ PREPARAT PER A LA PROVA: Introduïu el cable d'alimentació de 3,7 V CC + ve a la part superior, -ve a la part inferior.

Pas 6: proveu el controlador

Com s’ha dit abans, el programari no s’ha optimitzat per al flux de treball de càrrega solar. Tanmateix, es pot provar i modificar mitjançant fonts de llum naturals (sol) i antinaturals.

Per provar el seguiment en un entorn controlat, pot ser convenient establir el SLEEP MINUTES a un valor inferior (vegeu el pas següent).

Pas 7: Configuració mitjançant I2C mitjançant l'entrada de consola

Això explica la configuració del controlador mitjançant una segona MCU, introduint la configuració en una finestra de consola.

1. Pengeu el següent script a un D1M WIFI BLOCK (o Wemos D1 Mini).
2. Desconnecteu l'USB de l'ordinador

3. CONNEXIONS DE PIN: -ve (controlador) => GND (D1M) + ve (controlador) => 3V3 (D1M) SCL (controlador) => D1 (D1M)

   SDA (controlador) => D2 (D1M)

4. Gireu el commutador SPDT a CONFIG
5. Connecteu l'USB al PC
6. Des de l'IDE Arduino, inicieu una finestra de consola amb el port COM correcte
7. Assegureu-vos que estiguin seleccionats "Newline" i "9600 baud"
8. Les ordres s'introdueixen al quadre de text d'enviament seguit de la tecla Retorn
9. Les ordres tenen el format byte de bytes de caràcters
10. Si no s'inclou el segon byte (tercer segment), el script envia 0 (zero)
11. Aneu amb compte amb l’entrada de sèrie; reviseu el que heu introduït abans de prémer la tecla "Retorn". Si esteu bloquejat (per exemple, canviant l'adreça I2C a un valor que heu oblidat), haureu de tornar a parpellejar el microprogramari del controlador.

Les variacions admeses en el primer caràcter de l'ordre són:

• E (Activa el seguiment del servo) útil per aturar el moviment durant la configuració. Això s’introdueix mitjançant: E 0
• D (Desactiva el seguiment del servo) útil per iniciar el seguiment automàtic si no reinicieu el dispositiu. Això s’introdueix mitjançant: D 0
• G (Obtén el valor de configuració) llegeix els valors de l'EEPROM i IN-MEMORY: s'introdueix mitjançant: G (l'índex té valors de byte vàlids 0 - 13 i 15)
• S (Establir valor EEPROM) estableix els valors a EEPROM que estan disponibles després de reiniciar-se. Això s’introdueix mitjançant: S (l’índex té valors de byte vàlids de 0 a 13, el valor és de valors de byte vàlids i varia segons la propietat)

El codi és el punt de veritat dels índexs, però el següent s’utilitza per a una guia de valors / comentaris vàlids:

• ADREÇA I2C 0: adreça esclava del controlador, el mestre ho necessita per comunicar-se amb el controlador (per defecte 10)
• ANGLE VERTICAL MÍNIM 1: límit inferior de servo vertical d'angle (per defecte 10, rang 0-180)
• ANGLE VERTICAL MÀXIM 2 - límit superior de servo vertical d'angle (per defecte 170, rang 0-180)
• SENSIBILITAT VERTICAL LDR 3: marge de lectura LDR vertical (per defecte 20, rang 0-1024)
• ANGLE VERTICAL PAS 4: passos de servo verticals d'angle en cada ajust (per defecte 5, rang 1-20)
• ANGLE HORITZONTAL MÍNIM 5: límit inferior de servo horitzontal d’angle (per defecte 10, rang 0-180)
• ANGLE MÀXIM HORITZONTAL 6 - límit superior servo angular horitzontal (predeterminat 170, rang 0-180)
• SENSIBILITAT LDR 7 HORITZONTAL: marge de lectura horitzontal de LDR (predeterminat 20, rang 0-1024)
• PAS ANGULAR HORITZONTAL 8: passos angulars de servo horitzontal en cada ajust (per defecte 5, rang 1-20)
• SLEEP MINUTES 9: el període de son aproximat entre el seguiment (predeterminat 20, interval 1-255)
• ANGLE VERTICAL ALBA 10 - ÚS FUTUR: l’angle vertical al qual tornar quan es pon el sol
• ANGLE 11 ALBA HORITZONTAL - ÚS FUTUR: l'angle horitzontal al qual tornar quan es pon el sol
• INTENSITAT ALBA 12 - ÚS FUTUR: la mitjana mínima de tots els LDR que desencadenen un seguiment diari del sol
• INTENSITAT DE DUSK 13 - ÚS FUTUR: la mitjana mínima de tots els LDR que desencadena el seguiment diari del sol
• MARCADOR 14 DE VALORS DE L’EEPROM: VALOR NO ÚS
• INTENSITAT ACTUAL 15: el percentatge mitjà actual de la intensitat de la llum
• MARCADOR 16 DE VALORS FINS A LA MEMORYRIA: VALOR NO ÚS.

Captura l'entrada de sèrie (entrada de teclat a la finestra de la consola) i la reenvia a un esclau I2C amb el format char, byte, byte

#incloure

# defineI2C_MSG_IN_SIZE2

# defineI2C_MSG_OUT_SIZE3

# defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

byte const _numChars = 32;

char _receivedChars [_numChars]; // una matriu per emmagatzemar les dades rebudes

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

retard (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

byte estàtic 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;

}

} més {

_receivedChars [ndx] = '\ 0'; // finalitzar la cadena

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

token char *;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

índex de bytes = 0;

valor de byte = 0;

int i = 0;

while (token! = NULL) {

//Serial.println(token);

i ++;

commutador (i) {

cas 1:

token = strtok (NULL, delim);

índex = atoi (testimoni);

trencar;

cas 2:

token = strtok (NULL, delim);

if (token! = NULL) {

valor = atoi (testimoni);

}

trencar;

per defecte:

testimoni = NUL;

}

}

sendCmd (cmd, índex, valor);

_newData = false;

}

}

voidsendCmd (char cmd, índex de bytes, valor de byte) {

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

Serial.println ("Enviament de l'ordre:");

Serial.println ("\ t" + Cadena (cmd) + "" + Cadena (índex) + "" + Cadena (valor));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // transmetre al dispositiu

Wire.write (cmd); // envia un caràcter

Wire.write (índex); // envia un byte

Wire.write (valor); // envia un byte

Wire.endTransmission ();

resposta de bytes = 0;

bool hadResponse = false;

if (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

mentre que (Wire.available ()) // l’esclau pot enviar menys del que s’ha sol·licitat

{

hadResponse = true;

resposta = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Obtenció de la resposta:");

Serial.println (resposta);

} més {

Serial.println ("Sense resposta, comproveu l'adreça / connexió");

}

}

}

veure rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino allotjat amb ❤ per GitHub

Pas 8: passos següents

Torneu a fer-ho periòdicament per comprovar si hi ha canvis al programari / maquinari.

Modifiqueu el programari / maquinari segons les vostres necessitats.

Comenteu qualsevol sol·licitud / optimització.