IOT123 - SOLAR TRACKER - CONTROLLER: 8 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Dette er en forlengelse av Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL FRAME, LDR MOUNTS RIG. Her konsentrerer vi oss om kontrolleren til servoene og sensorer for solens posisjon. Det er viktig å påpeke at denne designen forutsetter at 2 MCUer vil bli brukt: en (3,3V 8mHz Arduino Pro Mini) for solsporing og en uavhengig MCU for sensorene/aktørene.

Dette er versjon 0.3

I stedet for å publisere alle prosjektene etter fullstendig tilfredshet, vil jeg øve på kontinuerlig integrasjon og levere noe oftere, og endre det jeg har levert etter behov. Jeg skal skrive en annen instruks for batteriladeren, _når_ optimaliseringen av kontrollerprogramvaren/maskinvaren er fullført. Jeg vil påpeke hvor optimaliseringene er nødvendige når vi går gjennom dette.

En del av årsaken til denne tilnærmingen er tilbakemeldinger fra kunder. Hvis du ser et behov eller har en bedre tilnærming, vennligst kommenter, men husk at jeg ikke kan levere alt og muligens ikke til en tidsramme som passer deg. Siden disse forklaringene virker mindre relevante, vil de bli slettet fra denne artikkelen.

Hva dette inkluderer:

1. Bruk LDR -er fra den originale Instructable for å kjenne solens omtrentlige plassering.
2. Flytt servoene mot solen.
3. Alternativer for følsomheten til bevegelsene.
4. Alternativer for trinnstørrelsen når du flytter til solen.
5. Alternativer for vinkelbegrensningene som brukes på servoene.
6. Alternativer for forsinkelser av bevegelsene.
7. I2C -grensesnitt for innstilling/henting av verdier mellom MCUer.
8. Dyp søvn mellom bevegelser.

Dette inkluderer ikke (og vil bli behandlet når tiden tillater det):

1. Bruker bare strøm i dagslys.
2. Husker daggryposisjonen og dro dit i skumringsstopp.
3. Fjerner regulatoren fra MCU.
4. Deaktivering av LED -lampene på MCU -en.
5. Omdirigerer strømmen gjennom VCC i stedet for RAW.
6. Tilby løsninger for å blinke uten regulert strøm fra USB til seriell TTL -omformer.
7. Batterispenningsmåler.

HISTORIE

20. des. 2017 V0.1 KODE

Den første versjonen sporer lyskilden, alltid på, ingen lading

7. jan 2018 V0.2 KODE

• Maskinvareendringer

  • Legg til I2C -pinner
  • Legg bryteren til servo -GNDer
  • Trykt etikett på kontrollboksen

• PROGRAMVAREENDRINGER

  • Les konfigurasjon fra EEPROM
  • I2C bussstøtte som slave til en annen MCU (3.3V)
  • Angi konfigurasjon via I2C
  • Sett aktivert via I2C
  • Få konfigurasjon via I2C
  • Få kjøreegenskaper via I2C (for øyeblikket aktivert og nåværende lysintensitet)
  • Fjern seriell logging (det påvirket I2C -verdiene)

19. jan 2018 V0.3 KODE

• MASKINVARE

  Etiketten er oppdatert. Bryteren brukes nå til å velge enten CONFIG- eller TRACK -modus

• PROGRAMVARE

  • I2C brukes bare til konfigurasjon
  • Kontrolleren venter 5 sekunder før sporingen initialiseres, gir mulighet for å bevege hender
  • For å bruke I2C -konfigurasjon må SPDT være på CONFIG som enhetsstøvler
  • Mellom sporingsbevegelsen er enheten i dyp dvalemodus for konfigurasjonsverdien SLEEP MINUTES (standard 20 minutter).

Trinn 1: Materialer og verktøy

Det er nå en fullstendig liste over materialer og kilder.

1. 3D -trykte deler.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 av 4x6cm dobbeltsidig prototype PCB universelt kretskort (skal kuttes i to)
4. 1 av 40P mannlig topptekst (skal kuttes i størrelse).
5. 1 av 40P kvinnelig topptekst (skal kuttes i størrelse).
6. 4 av 10K 1/4W restistorer.
7. Tilkoblingskabel.
8. Lodde og jern.
9. 20 av 4G x 6 mm rustfrie pannehodeskruer.
10. 4 av 4G x 6 mm rustfrie forsenkede selvskruende skruer.
11. 1 av 3,7V LiPo -batteri og holder (avsluttes i 2P dupont -kontakter).
12. 1 av 2P mannlig rettvinklet overskrift
13. 1 av SPDT -bryter 3 -pins 2,54 mm stigning
14. Sterkt cyanoakrylatlim
15. Dupont -kontakter hunn 1P topptekst (1 blå, 1 grønn).

Trinn 2: Montering av kretsen

Kretsen har for øyeblikket ikke Voltage Divider Circuit (volt meter).

1. Klipp 4x6cm dobbeltsidig prototype PCB -kretskort i to på tvers av den lange aksen.

2. Skjær 40P hannhodet i biter:

   1. 2 av 12P
   2. 3 av 3P
   3. 6 av 2P.

3. Skjær 40P hunnhodet i biter:

   1. 2 av 12P
   2. 1 av 6P
4. Loddetinn 2 av 12 Kvinneoverskrift som vist.
5. Lim avstandsstykket fjernet fra en 3P hann (ekstra) topptekst på undersiden av SPDT -bryteren med cyanoakrylatlim
6. På den andre siden plasserer du loddetinn 6 av 2P, 2 av 3Pmale header og SPDT -bryteren som vist.
7. Loddetinn 4 av 10K motstander (A, B, C, D svart) via ledning til GND pin header (#2 black) og til A0 - A3 header pins (#5, #6, #7, #8) deretter gjennom hull (gul) som vist (3 bilder + 1 diagram).
8. Spor 3.3V fra LDR PINS loddings -PINS #4, #6, #8, #10 og tråden gjennom hull til feamale header VCC pin (grønn).
9. Spor 3.3V på kvinnelig toppside som vist (rød) lodding til PINS #1, #12, #15.
10. 3.3V gjennom hullet loddet over side (rødt) RAW header PIN #1.
11. Spor oransje tilkobling fra PIN #11 gjennom hullet til loddetinn Hunnål på den andre siden som vist.
12. Spor og lodd blå tilkoblingstråd fra #20 til #30 og fra #31 til #13 og #16.
13. Loddetinn Kvinnehode PIN #11 til Mann Header PIN #11 gjennom hull.
14. Forbered 2 dupont -kontakter 30 mm lang med 1P kvinnelig topptekst (1 blå, 1 grønn). Strip og tinn den andre enden.
15. Lodd blå Dupont wire til #28; loddet grønt Dupont wire til #29.
16. På oversiden av Arduino fikser du 6P hunnhodet og deretter loddetinn.
17. På oversiden av Arduino festes 2P rettvinklet kvinnelig overskrift int #29 og #30 og deretter loddetinn.
18. På undersiden av Arduino festes 2 av 12P og 1 av 3P hannpinner og deretter loddes.
19. Sett inn Arduino mannlige 12P -pinner i PCB 12P hunnhoder.

Trinn 3: Blinker MCU

Arduino Pro Mini blinker praktisk med en FTDI232 USB til TTL -omformer ved hjelp av 6P kvinnelig topptekst. Se bildet ovenfor for justering av de 2 brettene.

Sørg for at 3.3V -innstillingen er valgt på FTDI232. Følg instruksjonene her ved å bruke koden nedenfor (bruk lenke til GIST).

Lowpower-biblioteket (vedlagt og https://github.com/rocketscream/Low-Power) må installeres.

Når Arduino Pro Mini + PCB er installert i foringsrøret, kan det fortsatt blinke når toppnålene blir avslørt. Bare koble kontrollenheten fra panelrammen og avsløre overskriften.

Tilt pan solar tracker med I2C/EEPROM konfigurasjon og søvnsyklus mellom bevegelser. Sovesyklusens varighet presisjon reduseres etter hvert som varigheten øker, men tilstrekkelig for dette formålet

/*

* endret fra kode

* av Mathias Leroy

*

* V0.2 MODIFIKASJONER

** I2C SET GET

** EEPROM SET GET

** FJERN SERIEUTGANG - BERØRT I2C

** AKTIVER/deaktiver sporing

** FLYT SERVOS TIL GRENSER VIA I2C

** LES GJELDENDE AVG INTENSITET VIA I2C

* V0.3 MODIFIKASJONER

** BRYTER FOR 2 MODUS - TRACK (NO I2C) og CONFIGURE (USES I2C)

** SOV I SPORMODUS (MEGET LAV PRESISJON PÅ 8 ANDRE CHUNKS)

** KOBLE/FESTE SERVOER PÅ SLEEP/WAKE (TRANSISTOR BRUKES EVENTUELL)

** FJERN KONFIGURERBAR INNSTILLINGSPOSISJON (REDUNDANT)

** FJERN KONFIGURERBARE VAKSESEKONDER (REDUNDANT)

** FJERN KONFIGURERBAR AKTIVER/Deaktiver (REDUNDANT)

** FJERN KONFIGURERBAR TRACKER AKTIVERT (BRUK HARDWAREBRYTER)

** FJERN SPENNINGSGETTER - VIL BRUKE SEPARAT I2C -KOMPONENT

** LEGG TIL SERIELOGGING NÅR I2C IKKE BRUKES

*/

#inkludere

#inkludere

#inkludere

#inkludere

#inkludere

#defineEEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definerePIN_SERVO_V11

#definerePIN_SERVO_H5

#definereIDX_I2C_ADDR0

#definereIDX_V_ANGLE_MIN1

#definereIDX_V_ANGLE_MAX2

#definereIDX_V_SENSITIVITY3

#definereIDX_V_STEP4

#definereIDX_H_ANGLE_MIN5

#definereIDX_H_ANGLE_MAX6

#definereIDX_H_SENSITIVITY7

#definereIDX_H_STEP8

#definereIDX_SLEEP_MINUTES9

#definereIDX_V_DAWN_ANGLE10

#definereIDX_H_DAWN_ANGLE11

#defineIDX_DAWN_INTENSITY12 // gjennomsnitt av alle LDRS

#defineIDX_DUSK_INTENSITY13 // gjennomsnitt av alle LDRS

#definereIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // gjennomsnitt av alle LDRS - brukt til å beregne IDX_DAWN_INTENSITY ambiant ikke -direkte lys

#definereIDX_END_VALUES_GET16

#definereIDX_SIGN_117

#definereIDX_SIGN_218

#definereIDX_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 = false;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println ("Konfigurasjonsmodus");

Serial.print ("I2C -adresse:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ReceiveEvent);

Wire.onRequest (requestEvent);

}ellers{

Serial.println ("Sporingsmodus");

forsinkelse (5000); // tid til å få hendene ut av veien når du kobler til batteriet etc.

}

}

voidloop ()

{

getLightValues ();

hvis (! _inConfigMode) {

// ToDo: SLÅ PÅ TRANSISTORBRYTEREN

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

hvis (i! = 0) {

getLightValues ();

}

moveServos ();

}

forsinkelse (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: SLÅ AV TRANSISTORBRYTEREN

forsinkelse (500);

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

}

}

// --------------------------------- AKTUELL MODUS

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

returner _inConfigMode;

}

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

voidgetFromEeprom () {

hvis(

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

hvis (count == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

byte indeks = Wire.read ();

byte verdi = Wire.read ();

bytte (cmd) {

case'G ':

hvis (indeks <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [indeks];

}

gå i stykker;

saker':

hvis (indeks <IDX_END_EEPROM_SET) {

_i2cVals [indeks] = verdi;

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

}

gå i stykker;

misligholde:

komme tilbake;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDRer

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

}

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

voidmoveServos () {

Serial.println ("moveServos");

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

// går til venstre

Serial.println ("moveServos går til venstre");

forsinkelse (_slowingDelay);

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

_servoH.write (_angleH--);

forsinkelse (_servoLoopDelay);

}

}

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

// går rett

Serial.println ("moveServos går til venstre");

forsinkelse (_slowingDelay);

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

_servoH.write (_angleH ++);

forsinkelse (_servoLoopDelay);

}

}

annet {

// gjør ingenting

Serial.println ("moveServos gjør ingenting");

forsinkelse (_slowingDelay);

}

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

// går opp

Serial.println ("moveServos går opp");

forsinkelse (_slowingDelay);

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

_servoV.write (_angleV ++);

forsinkelse (_servoLoopDelay);

}

}

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

// går ned

Serial.println ("moveServos går ned");

forsinkelse (_slowingDelay);

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

_servoV.write (_angleV--);

forsinkelse (_servoLoopDelay);

}

}

annet {

Serial.println ("moveServos gjør ingenting");

forsinkelse (_slowingDelay);

}

}

//---------------------------------SØVN

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

se rawtilt_pan_tracker_0.3.ino hostet av ❤ av GitHub

Trinn 4: Montering av kretshuset

1. Sørg for at Ardiuno Pro Mini er satt inn i topptekstene på kretskortet.
2. Sett SOLAR TRACKER -kontrollerboksbasen inn i SOLAR TRACKER -kontrollerboksveggene og fest med 2 av 4G x 6 mm selvforsynte skruer i rustfritt, forsenket.
3. Sett Ardiuno Pro Mini + PCB med 6P Header inn i tomrommet i SOLAR TRACKER -kontrolleren.
4. Sett lokket på SOLAR TRACKER -kontrollerboksen inn i veggene på SOLAR TRACKER -kontrollerboksen, og fest med 2 av 4G x 6 mm selvforsynte skruer med forsenket rustfritt stål.
5. Fest monteringen ovenfor på bunnen av panelrammen med 4 av 4x x 6 mm, selvforsynte skruer i rustfritt stål.

Trinn 5: Koble riggledningene til kontrolleren

De aktuelle tilkoblingene som er klare fra forrige Instructable, er 4 av 2P LDR -tilkoblinger og 2 av 3P -tilkoblinger fra servoene. Det som er midlertidig til ladingen er klar, er batteriet. Bruk en 3,7V LiPo som slutter i en 2P DuPont -tilkobling for nå.

1. Sett inn LDR -tilkoblingene (ingen polaritet) ovenfra:

   1. Øverst til høyre
   2. Øverst til venstre
   3. Nede til høyre
   4. Nede til venstre

2. Sett inn Servo -tilkoblingene (med signalkabelen til venstre) fra toppen:

   1. Horisontal
   2. Vertikal
3. VENT TIL Klar for test da: Sett inn 3,7V likestrømkabel +ve til toppen, -ve til bunnen.

Trinn 6: Testing av kontrolleren

Som nevnt tidligere, har ikke programvaren blitt optimalisert for Solar Charging arbeidsflyt. Det kan testes og justeres ved hjelp av naturlige (sol) og unaturlige lyskilder.

For å teste sporing i et kontrollert miljø kan det være praktisk å sette SLEEP MINUTES til en lavere verdi (se neste trinn).

Trinn 7: Konfigurere Via I2C ved hjelp av konsollinngang

Dette forklarer konfigurering av kontrolleren via en annen MCU, og angir innstillinger i et konsollvindu.

1. Last opp følgende skript til en D1M WIFI -BLOKK (eller Wemos D1 Mini).
2. Koble USB fra PC

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

   SDA (kontroller) => D2 (D1M)

4. Vri SPDT -bryteren til CONFIG
5. Koble USB til PC
6. Start et konsollvindu med riktig COM -port fra Arduino IDE
7. Sørg for at "Newline" og "9600 baud" er valgt
8. Kommandoene blir lagt inn i Send tekstboks etterfulgt av Enter -tasten
9. Kommandoene er i formatet Tegnbyte -byte
10. Hvis den andre byten (tredje segment) ikke er inkludert 0, blir 0 (null) sendt av skriptet
11. Vær forsiktig med å bruke seriell inngang; gå gjennom det du har angitt før du trykker på "Enter" -tasten. Hvis du er låst ute (for eksempel endring av I2C -adressen til en verdi du har glemt), må du blinke kontrollenes fastvare igjen.

De støttede variasjonene i kommandoens første tegn er:

• E (Aktiver servosporing) nyttig for å stoppe bevegelse under konfigurasjon. Dette skrives inn med: E 0
• D (Deaktiver servosporing) nyttig for å starte automatisk sporing hvis enheten ikke startes på nytt. Dette skrives inn med: D 0
• G (Hent konfigurasjonsverdi) leser verdier fra EEPROM og IN -MEMORY: Dette skrives inn med: G (indeks er gyldige byteverdier 0 - 13 og 15)
• S (Angi EEPROM -verdi) setter verdier til EEPROM som er tilgjengelige etter omstart. Dette skrives inn med: S (indeks er gyldige byteverdier 0 - 13, verdien er gyldige byteverdier og varierer per eiendom)

Koden er sannhetspunktet for indeksene, men følgende brukes for en guide for gyldige verdier/kommentarer:

• I2C ADRESSE 0 - kontroller slave adresse, masteren trenger dette for å kommunisere med kontrolleren (standard 10)
• MINIMUM VERTIKAL ANGLE 1 - nedre grense for vertikal servo -vinkel (standard 10, område 0 - 180)
• MAKSIMAL VERTIKALVINKEL 2 - vertikal vertikal servo øvre grense (standard 170, område 0 - 180)
• SENSITIVITET VERTIKAL LDR 3 - Vertikal LDR -lesemargin (standard 20, område 0 - 1024)
• VERTIKALVINKEL TRINN 4 - vinkelrette vertikale servotrinn ved hver justering (standard 5, område 1 - 20)
• MINIMAL HORISONTAL VINKEL 5 - vinkel horisontal servo nedre grense (standard 10, område 0 - 180)
• MAKSIMAL HORIZONTAL VINKEL 6 - vinkel horisontal servo øvre grense (standard 170, område 0 - 180)
• SENSITIVITET HORIZONTAL LDR 7 - Horisontal LDR -lesemargin (standard 20, område 0 - 1024)
• HORISONTALVINKEL TRINN 8 - horisontale servotrinn i vinkel ved hver justering (standard 5, område 1 - 20)
• SLEEP MINUTES 9 - den omtrentlige søvnperioden mellom sporing (standard 20, område 1 - 255)
• VERTICAL DAWN ANGLE 10 - FREMTIDIG BRUK - den vertikale vinkelen å gå tilbake til når solen går ned
• HORISONTAL DAWN ANGLE 11 - FREMTIDIG BRUK - den horisontale vinkelen å gå tilbake til når solen går ned
• DAWN INTENSITY 12 - FREMTIDIG BRUK - minimumsgjennomsnittet for alle LDR -er som utløser en start på daglig solsporing
• DUSK INTENSITY 13 - FREMTIDIG BRUK - minimumsgjennomsnittet for alle LDR -er som utløser slutten av daglig solsporing
• SLUTT PÅ EEPROM VERDIER MARKERING 14 - VERDI IKKE BRUKT
• AKTUELL INTENSITET 15 - gjeldende gjennomsnittlig prosentandel av lysintensiteten
• SLUTT PÅ MINDREVERDIMERKER 16 - VERDI IKKE BRUKT.

Fanger seriell inngang (tastaturinngang i konsollvinduet) og videresender den til en I2C -slave i formatet char, byte, byte

#inkludere

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

boolsk _newData = false;

const byte _numChars = 32;

char _receivedChars [_numChars]; // en matrise for å lagre mottatte data

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

forsinkelse (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

statisk byte ndx = 0;

char endMarker = '\ n';

røye rc;

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

rc = Serial.read ();

hvis (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

hvis (ndx> = _numChars) {

ndx = _numChars - 1;

}

} annet {

_receivedChars [ndx] = '\ 0'; // avslutt strengen

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

hvis (_newData == true) {

constchar delim [2] = "";

char *token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

byte indeks = 0;

byte verdi = 0;

int i = 0;

mens (token! = NULL) {

//Serial.println(token);

i ++;

bytte (i) {

case1:

token = strtok (NULL, delim);

indeks = atoi (token);

gå i stykker;

case2:

token = strtok (NULL, delim);

if (token! = NULL) {

verdi = atoi (token);

}

gå i stykker;

misligholde:

token = NULL;

}

}

sendCmd (cmd, indeks, verdi);

_newData = false;

}

}

voidsendCmd (char cmd, byteindeks, byteverdi) {

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

Serial.println ("Sendekommando:");

Serial.println ("\ t" + streng (cmd) + "" + streng (indeks) + "" + streng (verdi));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // overføre til enhet

Wire.write (cmd); // sender en røye

Wire.write (indeks); // sender en byte

Wire.write (verdi); // sender en byte

Wire.endTransmission ();

bytesvar = 0;

bool hadResponse = false;

hvis (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

mens (Wire.available ()) // slave kan sende mindre enn forespurt

{

hadResponse = true;

respons = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Få svar:");

Serial.println (svar);

}ellers{

Serial.println ("Ingen respons, sjekk adressen/tilkoblingen");

}

}

}

vis rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino hostet med ❤ av GitHub

Trinn 8: Neste trinn

Kom tilbake med jevne mellomrom for å se etter endringer i programvare/maskinvare.

Endre programvaren/maskinvaren til dine krav.

Kommenter eventuelle forespørsler/optimaliseringer.