IOT123 - SOLAR TRACKER - CONTROLLER: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Detta är en förlängning av Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL RAM, LDR MOUNTS RIG. Här koncentrerar vi oss på servomotorn och sensorerna för solens position. Det är viktigt att påpeka att denna design förutsätter att två MCU: er kommer att användas: en (3,3V 8mHz Arduino Pro Mini) för solspåraren och en oberoende MCU för dina sensorer/aktörer.

Detta är version 0.3

Istället för att publicera alla projekt efter fullständig tillfredsställelse kommer jag att öva på kontinuerlig integration och leverera något oftare, ändra vad jag har levererat efter behov. Jag kommer att skriva en annan instruerbar för batteriladdaren, _när_ optimeringen av kontrollprogramvaran/hårdvaran är klar. Jag kommer att påpeka var optimeringarna behövs när vi går igenom detta.

En del av anledningen till detta tillvägagångssätt är feedback från kunder. Om ni ser ett behov eller har ett bättre tillvägagångssätt, kommentera, men kom ihåg att jag inte kan leverera allt och kanske inte till en tidsram som passar dig. Eftersom dessa förklaringar verkar mindre relevanta kommer de att raderas från den här artikeln.

Vad detta inkluderar:

1. Använd LDR från den ursprungliga Instructable för att känna solens ungefärliga plats.
2. Flytta servon mot solen.
3. Alternativ för rörelsens känslighet.
4. Alternativ för stegstorlek när du flyttar till solen.
5. Alternativ för vinkelbegränsningarna som används på servon.
6. Alternativ för fördröjningar av rörelserna.
7. I2C -gränssnitt för inställning/hämtning av värden mellan MCU: er.
8. Djupt sömn mellan rörelser.

Vad detta inte inkluderar (och kommer att behandlas när tiden tillåter):

1. Använd bara ström under dagsljus.
2. Kommer ihåg gryningspositionen och åker dit vid skymningsstängning.
3. Ta bort regulatorn från MCU.
4. Inaktivera lysdioderna på MCU: n.
5. Omdirigerar strömmen via VCC snarare än RAW.
6. Tillhandahåller lösningar för blinkning utan reglerad ström från USB till seriell TTL -omvandlare.
7. Batterispänningsmätare.

HISTORIA

20 dec 2017 V0.1 KOD

Initialversionen spårar ljuskällan, alltid på, ingen laddning

7 jan 2018 V0.2 KOD

• HÅRDVARUFÖRÄNDRINGAR

  • Lägg till I2C -stift
  • Lägg till switch till servo -GND: er
  • Tryckt etikett på controllerboxen

• PROGRAMVÄNDRINGAR

  • Läs konfiguration från EEPROM
  • I2C -bussstöd som slav till en annan MCU (3.3V)
  • Ställ in konfiguration via I2C
  • Set Enabled via I2C
  • Få konfiguration via I2C
  • Få körtidsegenskaper via I2C (för närvarande aktiverad och aktuell ljusintensitet)
  • Ta bort seriell loggning (det påverkade I2C -värden)

19 jan, 2018 V0.3 KOD

• HÅRDVARA

  Etiketten uppdaterad. Switch används nu för att välja antingen CONFIG eller TRACK -läge

• PROGRAMVARA
  • I2C används endast för konfiguration
  • Styrenheten väntar 5 sekunder innan spårningen initieras, möjliggör rörelse av händer
  • För att kunna använda I2C -konfiguration måste SPDT vara på CONFIG som enhetsstövlar
  • Mellan spårningsrörelsen är enheten i djupt viloläge för konfigurationsvärdet SLEEP MINUTES (standard 20 minuter).

Steg 1: Material och verktyg

Det finns nu en fullständig lista över material och källor.

1. 3D -tryckta delar.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 av 4x6cm dubbel sida prototyp PCB Universal kretskort (ska skäras i hälften)
4. 1 av 40P hanrubrik (ska klippas i storlek).
5. 1 av 40P kvinnlig header (ska klippas i storlek).
6. 4 av 10K 1/4W restistorer.
7. Anslutningstråd.
8. Löd och järn.
9. 20 av 4G x 6 mm rostfria pannhuvud självgängande skruvar.
10. 4 av 4G x 6 mm rostfria försänkta självgängande skruvar.
11. 1 av 3,7V LiPo -batteri och hållare (avslutas i 2P dupont -kontakter).
12. 1 av 2P manlig rätvinklig header
13. 1 av SPDT -omkopplare 3 -stifts 2,54 mm delning
14. Kraftigt cyanoakrylatlim
15. Dupont -kontaktdon 1P -header (1 av blått, 1 av grönt).

Steg 2: Montera kretsen

Kretsen har för närvarande inte spänningsdelaren (voltmätare).

1. Skär 4x6cm dubbelsidiga prototyp PCB Universal Printed Circuit Board i hälften över den långa axeln.

2. Skär 40P hanrubriken i bitar:

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

3. Skär 40P kvinnlig header i bitar:

   1. 2 av 12P
   2. 1 av 6P
4. Löd 2 av 12Pemal header som visas.
5. Limma distansen bort från en 3P han (extra) rubrik på undersidan av SPDT -omkopplaren med cyanoakrylatlim
6. På andra sidan placera sedan löd 6 av 2P, 2 av 3Pmale header och SPDT -omkopplaren som visas.
7. Löd 4 av 10K motstånd (A, B, C, D svart) via ledning till GND -stifthuvud (#2 svart) och till A0 - A3 -huvudstiften (#5, #6, #7, #8) sedan genom hålet (gul) som visas (3 bilder + 1 diagram).
8. Spåra 3.3V från LDR PINS -lödnings -PINS #4, #6, #8, #10 och trä genom hålet till feamale header VCC pin (grön).
9. Spåra 3.3V på kvinnlig rubriksida som visas (röd) lödning till PINS #1, #12, #15.
10. 3.3V genomgående hål, lödd över sidan (röd) RAW header PIN #1.
11. Spåra orange anslutning från PIN #11 genom hålet till lödhonan stift på andra sidan som visas.
12. Spåra och löd blå anslutningstråd från #20 till #30 och från #31 till #13 och #16.
13. Lödning Kvinna Rubrik PIN #11 till Manlig Rubrik PIN #11 genomgående hål.
14. Förbered 2 dupont -kontakter 30 mm långa med 1P -hona (1 av blått, 1 av grönt). Strimla och plåt andra änden.
15. Lödblå Dupont -tråd till #28; lödgrön Dupont -tråd till #29.
16. På ovansidan av Arduino fixar du 6P kvinnlig rubrik och sedan löd.
17. På ovansidan av Arduino fixa 2P rätvinklig kvinnlig rubrik int #29 och #30 sedan lödning.
18. På undersidan av Arduino fixera de 2 av 12P och 1 av 3P hanstiften och löd sedan.
19. Sätt i Arduino hane 12P -stift i PCB 12P honhuvuden.

Steg 3: Blinkar MCU

Arduino Pro Mini blinkar bekvämt med hjälp av en FTDI232 USB till TTL -omvandlare med 6P kvinnlig rubrik. Se bilden ovan för inriktningen av de två brädorna.

Se till att 3.3V -inställningen är vald på din FTDI232. Följ instruktionerna här med koden nedan (använd länk till GIST).

Lowpower-biblioteket (bifogat och https://github.com/rocketscream/Low-Power) måste installeras.

När Arduino Pro Mini + PCB har installerats i höljet kan det fortfarande blinka när huvudstiften exponeras. Koppla bara bort styrenheten från panelramen och exponerar rubriken.

Tilt pan solar tracker med I2C/EEPROM -konfiguration och sömncykel mellan rörelser. Sömncykelns varaktighet minskar när längden ökar, men tillräcklig för detta ändamål

/*

* modifierad från kod

* av Mathias Leroy

*

* V0.2 MODIFIKATIONER

** I2C SET GET

** EEPROM SET GET

** TA BORT SERIALUTGÅNGEN - PÅVERKAD I2C

** Aktivera/inaktivera spårning

** FLYT TJÄNSTER TILL GRÄNSER VIA I2C

** LÄS AKTUELL AVG INTENSITET VIA I2C

* V0.3 MODIFIKATIONER

** KOPPLING FÖR 2 LÄGEN - TRACK (NO I2C) och CONFIGURE (USES I2C)

** SÖVN I SPÅRLÄGE (MYCKET LÅG PRECISION TILL 8 ANDRA BITTER)

** KOPPLING/FÄST SERVOS PÅ SÖVN/VAKNING (TRANSISTOR ANVÄNDS EVENTUELLT)

** TA BORT KONFIGURERBAR INLEDNINGSPOSITION (REDUNDANT)

** TA BORT KONFIGURERBARA WAKE SECONDS (REDUNDANT)

** TA BORT KONFIGURERBAR AKTIVERA/INAKTIVERA (REDUNDANT)

** TA BORT KONFIGURERBART TRACKER AKTIVERAT (ANVÄND HARDWARE SWITCH)

** TA BORT SPÄNNINGSGETTER - SKA ANVÄNDA SEPARAT I2C -KOMPONENT

** LÄGG TILL SERIELLOGGNING OM DU IKKE ANVÄNDER I2C

*/

#omfatta

#omfatta

#omfatta

#omfatta

#omfatta

#definieraEEPROM_VERSION1

#definiera2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definieraPIN_SERVO_V11

#definieraPIN_SERVO_H5

#definieraIDX_I2C_ADDR0

#definieraIDX_V_ANGLE_MIN1

#definieraIDX_V_ANGLE_MAX2

#definieraIDX_V_SENSITIVITY3

#definieraIDX_V_STEP4

#definieraIDX_H_ANGLE_MIN5

#definieraIDX_H_ANGLE_MAX6

#definieraIDX_H_SENSITIVITY7

#definieraIDX_H_STEP8

#definieraIDX_SLEEP_MINUTES9

#definieraIDX_V_DAWN_ANGLE10

#definieraIDX_H_DAWN_ANGLE11

#definieraIDX_DAWN_INTENSITY12 // genomsnitt av alla LDRS

#definieraIDX_DUSK_INTENSITY13 // genomsnitt av alla LDRS

#definieraIDX_END_EEPROM_SET14

#definieraIDX_CURRENT_INTENSITY15 // genomsnitt av alla LDRS - används för att beräkna IDX_DAWN_INTENSITY ambient non -direct light

#definieraIDX_END_VALUES_GET16

#definieraIDX_SIGN_117

#definieraIDX_SIGN_218

#definieraIDX_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 ("Config Mode");

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

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ReceiveEvent);

Wire.onRequest (requestEvent);

}annan{

Serial.println ("Spårningsläge");

fördröjning (5000); // tid att få händerna ur vägen när du ansluter batteriet etc.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// ToDo: TÄNDA PÅ TRANSISTORBRYTAREN

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

för (int i = 0; i <20; i ++) {

om (i! = 0) {

getLightValues ();

}

moveServos ();

}

fördröjning (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: STÄNG AV TRANSISTORBRYTAREN

fördröjning (500);

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

}

}

// --------------------------------- AKTUELLT LÄGE

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom () {

om(

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

för (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");

för (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 ();

byte index = Wire.read ();

byte värde = Wire.read ();

switch (cmd) {

case'G ':

if (index <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [index];

}

ha sönder;

fallets:

if (index <IDX_END_EEPROM_SET) {

_i2cVals [index] = värde;

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

}

ha sönder;

standard:

lämna tillbaka;

}

}

}

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

}

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

voidmoveServos () {

Serial.println ("moveServos");

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

// går vänster

Serial.println ("moveServos går till vänster");

delay (_slowingDelay);

för (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]) {

// går rätt

Serial.println ("moveServos går till vänster");

delay (_slowingDelay);

för (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH ++);

delay (_servoLoopDelay);

}

}

annat {

// gör inget

Serial.println ("moveServos gör ingenting");

delay (_slowingDelay);

}

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

// Går upp

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

delay (_slowingDelay);

för (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]) {

// går ner

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

delay (_slowingDelay);

för (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV--);

delay (_servoLoopDelay);

}

}

annat {

Serial.println ("moveServos gör ingenting");

delay (_slowingDelay);

}

}

//---------------------------------SÖMN

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

för (unsignedint sleepCounter = eightSecondSegments; sleepCounter> 0; sleepCounter--)

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

visa rawtilt_pan_tracker_0.3.ino värd med ❤ av GitHub

Steg 4: Montering av kretshöljet

1. Se till att Ardiuno Pro Mini är isatt i sidhuvudena på kretskortet.
2. Sätt i SOLAR TRACKER -styrlådans bas i SOLAR TRACKER -styrlådans väggar och fäst med 2 av 4G x 6 mm försänkta självgängande skruvar.
3. Sätt i Ardiuno Pro Mini + PCB med 6P Header som hakar in i tomrummet i SOLAR TRACKER -styrboxens bas.
4. Sätt in locket till SOLAR TRACKER -styrboxen i SOLAR TRACKER -styrlådans väggar och fäst med 2 av 4G x 6 mm försänkta självgängande skruvar.
5. Fäst monteringen ovan på panelramens bas med 4 av 4G x 6 mm rostfria försänkta självgängande skruvar.

Steg 5: Ansluta riggkablarna till styrenheten

De relevanta anslutningarna som är klara från föregående instruerbara är 4 av 2P LDR -anslutningar och 2 av 3P -anslutningar från servon. Det som är tillfälligt tills laddningen är klar är batteriet. Använd en 3,7V LiPo som slutar i en 2P DuPont -anslutning för tillfället.

1. Sätt i LDR -anslutningarna (ingen polaritet) uppifrån:

   1. Överst till höger
   2. Övre vänstra
   3. Nere till höger
   4. Nedre vänstra

2. Sätt i servoanslutningarna (med signalkabeln till vänster) uppifrån:

   1. Horisontell
   2. Vertikal
3. Vänta tills det är klart för testet: Sätt i 3,7V likströmsledning +ve upptill, -ve till botten.

Steg 6: Testa styrenheten

Som tidigare nämnts har programvaran inte optimerats för arbetsflöde för solcellsladdning. Det kan dock testas och finjusteras med hjälp av naturliga (sol) och onaturliga ljuskällor.

För att testa spårningen i en kontrollerad miljö kan det vara bekvämt att ställa in SLEEP MINUTES till ett lägre värde (se nästa steg).

Steg 7: Konfigurera Via I2C med hjälp av konsolinmatning

Detta förklarar hur du konfigurerar regulatorn via en andra MCU, anger inställningar i ett konsolfönster.

1. Ladda upp följande skript till en D1M WIFI -BLOCK (eller Wemos D1 Mini).
2. Koppla bort USB från datorn

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

   SDA (styrenhet) => D2 (D1M)

4. Vrid SPDT -omkopplaren till CONFIG
5. Anslut USB till PC
6. Från Arduino IDE starta ett konsolfönster med rätt COM -port
7. Se till att "Newline" och "9600 baud" är markerade
8. Kommandona kommer in i textrutan Skicka följt av Enter -tangenten
9. Kommandona har formatet Teckenbyte -byte
10. Om den andra byten (tredje segmentet) inte ingår 0 (noll) skickas av skriptet
11. Var försiktig med att använda seriell ingång; granska vad du har angett innan du trycker på "Enter". Om du är utelåst (till exempel ändrar I2C -adressen till ett värde du har glömt) måste du blinka styrenhetens firmware igen.

De variationer som stöds i det första kommandotecknet är:

• E (Aktivera servospårning) användbar för att stoppa rörelse under konfiguration. Detta matas in med: E 0
• D (Inaktivera servospårning) användbart för att starta automatisk spårning om enheten inte startas om. Detta matas in med: D 0
• G (Hämta konfigurationsvärde) läser värden från EEPROM och IN -MEMORY: Detta matas in med: G (index är giltiga bytevärden 0 - 13 och 15)
• S (Ställ in EEPROM -värde) anger värden till EEPROM som är tillgängliga efter omstart. Detta matas in med: S (index är giltiga bytevärden 0 - 13, värdet är giltiga bytevärden och varierar per egenskap)

Koden är sanningens punkt för indexen men följande används för en guide för giltiga värden/kommentarer:

• I2C ADRESS 0 - controller -slavadress, mastern behöver detta för att kommunicera med regulatorn (standard 10)
• MINIMAL VERTIKAL VINKEL 1 - vertikal vertikal servo nedre gräns (standard 10, intervall 0 - 180)
• MAXIMAL VERTIKAL VINKEL 2 - vertikal vertikal servo övre gräns (standard 170, område 0 - 180)
• KÄNSLIGHET VERTIKAL LDR 3 - Vertikal LDR -läsmarginal (standard 20, intervall 0 - 1024)
• VERTIKALVINKEL STEG 4 - vertikala vertikala servosteg vid varje justering (standard 5, intervall 1 - 20)
• MINIMAL HORIZONTAL VINKEL 5 - vinkel horisontell servo nedre gräns (standard 10, intervall 0-180)
• MAXIMAL HORISONTAL VINKEL 6 - vinkel horisontell servo övre gräns (standard 170, intervall 0-180)
• KÄNSLIGHET HORIZONTAL LDR 7 - Horisontell LDR -läsmarginal (standard 20, intervall 0 - 1024)
• HORISONTALVINKELSTEG 8 - horisontella servosteg vid varje justering (standard 5, intervall 1 - 20)
• SLEEP MINUTES 9 - den ungefärliga sömnperioden mellan spårning (standard 20, intervall 1 - 255)
• VERTICAL DAWN ANGLE 10 - FRAMTIDANVÄNDNING - den vertikala vinkeln att återgå till när solen går ner
• HORIZONTAL DAWN ANGLE 11 - FRAMTIDA ANVÄNDNING - den horisontella vinkeln att återgå till när solen går ner
• DAWN INTENSITY 12 - FRAMTIDIG ANVÄNDNING - lägsta genomsnitt av alla LDR: er som utlöser en start av daglig solspårning
• DUSK INTENSITY 13 - FRAMTIDIG ANVÄNDNING - lägsta genomsnitt av alla LDR: er som utlöser ett slut på daglig solspårning
• SLUT AV EEPROM -VÄRDEMÄRKARE 14 - VÄRDE ANVÄNDS INTE
• AKTUELL INTENSITET 15 - den aktuella genomsnittliga procentandelen av ljusintensiteten
• SLUT PÅ MINNESVÄRDE MARKERING 16 - VÄRDE ANVÄNDS INTE.

Fångar seriell ingång (tangentbordsinmatning i konsolfönstret) och vidarebefordrar den till en I2C -slav i formatet char, byte, byte

#omfatta

#definiera2C_MSG_IN_SIZE2

#definiera2C_MSG_OUT_SIZE3

#definiera2C_SLAVE_ADDRESS10

booleska _newData = false;

const byte _numChars = 32;

char _receivedChars [_numChars]; // en array för att lagra mottagen data

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

fördröjning (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

statisk byte ndx = 0;

char endMarker = '\ n';

röding;

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

rc = Serial.read ();

if (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

if (ndx> = _numChars) {

ndx = _numChars - 1;

}

} annat {

_receivedChars [ndx] = '\ 0'; // avsluta strängen

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

om (_newData == true) {

constchar delim [2] = "";

char *token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

byteindex = 0;

byte värde = 0;

int i = 0;

medan (token! = NULL) {

//Serial.println(token);

i ++;

växla (i) {

fall 1:

token = strtok (NULL, delim);

index = atoi (token);

ha sönder;

case2:

token = strtok (NULL, delim);

if (token! = NULL) {

värde = atoi (token);

}

ha sönder;

standard:

token = NULL;

}

}

sendCmd (cmd, index, värde);

_newData = false;

}

}

voidsendCmd (char cmd, byte index, byte värde) {

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

Serial.println ("Skickar kommando:");

Serial.println ("\ t" + String (cmd) + "" + String (index) + "" + String (värde));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // överföra till enhet

Wire.write (cmd); // skickar en röding

Wire.write (index); // skickar en byte

Wire.write (värde); // skickar en byte

Wire.endTransmission ();

bytesvar = 0;

bool hadResponse = false;

if (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

medan (Wire.available ()) // slav kan skicka mindre än begärt

{

hadResponse = true;

svar = Wire.read ();

}

if (hadResponse == true) {

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

Serial.println (svar);

}annan{

Serial.println ("Inget svar, kontrollera adressen/anslutningen");

}

}

}

visa rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino värd med ❤ av GitHub

Steg 8: Nästa steg

Kontrollera regelbundet för att kontrollera om det finns ändringar i programvara/hårdvara.

Ändra programvaran/hårdvaran efter dina krav.

Kommentera eventuella önskemål/optimeringar.