IOT123 - SOLAR TRACKER - CONTROLLER: 8 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Dit is 'n uitbreiding van die Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL FRAME, LDR MOUNTS RIG. Hier konsentreer ons op die bediener van die servo's, en sensors van die son se posisie. Dit is belangrik om daarop te wys dat hierdie ontwerp veronderstel dat 2 MCU's gebruik sal word: een (3.3V 8mHz Arduino Pro Mini) vir die sonopsporing en een onafhanklike MCU vir u sensors/akteurs.

Dit is weergawe 0.3

Eerder as om al die projekte na volledige tevredenheid te publiseer, sal ek voortdurende integrasie beoefen en iets meer gereeld lewer, wat ek aanpas soos ek nodig het. Ek sal nog 'n instruksie vir die batterylaaier skryf, _ wanneer_ die optimalisering van die sagteware/hardeware van die kontroleerder voltooi is. Ek sal wys waar die optimalisering nodig is terwyl ons hierdeur stap.

Deel van die rede vir hierdie benadering is terugvoer van kliënte. As u 'n behoefte het of 'n beter benadering het, kan u kommentaar lewer, maar hou in gedagte dat ek nie alles kan lewer nie, moontlik nie in 'n tydsbestek wat u pas nie. Aangesien hierdie verduidelikings minder relevant lyk, word dit uit hierdie artikel verwyder.

Wat dit insluit:

1. Gebruik die LDR's van die oorspronklike Instructable om die benaderde ligging van die son te sien.
2. Beweeg die servo's na die son.
3. Opsies vir die sensitiwiteit van die bewegings.
4. Opsies vir die trapprootte wanneer u na die son beweeg.
5. Opsies vir die hoekbeperkings wat op die servo's gebruik word.
6. Opsies vir die vertragings van die bewegings.
7. I2C -koppelvlak om waardes tussen MCU's in te stel/te kry.
8. Diep slaap tussen bewegings.

Wat dit nie insluit nie (en sal aangespreek word soos die tyd dit toelaat):

1. Gebruik slegs krag gedurende daglig.
2. Onthou die dagbreekposisie en gaan daar teen skemer.
3. Verwyder die reguleerder van die MCU.
4. Skakel die LED (s) op die MCU uit.
5. Herlei die krag deur VCC eerder as RAW.
6. Voorsien oplossings vir flits sonder gereguleerde krag vanaf die USB na Serial TTL -omskakelaar.
7. Battery spanning monitor.

GESKIEDENIS

20 Desember 2017 V0.1 KODE

Aanvanklike weergawe volg ligbron, altyd aan, sonder laai

7 Jan 2018 V0.2 KODE

• HARDWARE VERANDERINGS

  • Voeg I2C -penne by
  • Voeg skakelaar by servo -GND's
  • Gedrukte etiket op kontroleerderkas

• Sagteware verander

  • Lees die konfigurasie van EEPROM
  • I2C -bussteun as slaaf van 'n ander MCU (3.3V)
  • Stel die konfigurasie op via I2C
  • Stel geaktiveer via I2C
  • Kry konfigurasie via I2C
  • Kry runtime -eiendomme via I2C (tans geaktiveer en huidige ligintensiteit)
  • Verwyder seriële aanmelding (dit het I2C -waardes beïnvloed)

19 Jan 2018 V0.3 KODE

• HARDWARE

  Etiket opgedateer. Die skakelaar word nou gebruik om die CONFIG- of TRACK -modus te kies

• SAGTEWARE

  • I2C word slegs vir konfigurasie gebruik
  • Die beheerder wag 5 sekondes voordat die opsporing begin word, sodat hande kan beweeg
  • Om I2C -opset te gebruik, moet SPDT as CONFIG as eenheidstewels wees
  • Tussen die spoorbeweging is die eenheid in die diep slaapmodus vir die konfigurasiewaarde SLEEP MINUTES (standaard 20 minute).

Stap 1: materiaal en gereedskap

Daar is nou 'n volledige lys van materiaal en bronne.

1. 3D -gedrukte onderdele.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 van 4x6 cm dubbele sy prototipe PCB universele printplaat (in die helfte gesny)
4. 1 uit 40P manlike kopstuk (op maat gesny).
5. 1 uit 40P vroulike kopstuk (op maat gesny).
6. 4 af 10K 1/4W -restors.
7. Aansluitdraad.
8. Soldeer en yster.
9. 20 af 4G x 6 mm vlekvrye pankop selfkopskroewe.
10. 4 af 4G x 6mm vlekvrye versinkte self -tappende skroewe.
11. 1 af 3,7V LiPo -battery en houer (eindig in 2P dupont -verbindings).
12. 1 uit 2P manlike reghoekige kop
13. 1 af SPDT -skakelaar 3 -pen 2,54mm -toonhoogte
14. Sterk Cyanoacrylate gom
15. Dupont -aansluitings vroulike 1P -kop (1 van blou, 1 van groen).

Stap 2: Monteer die stroombaan

Die stroombaan het tans nie die Voltage Divider Circuit (voltmeter) nie.

1. Sny die 4x6cm dubbelkant -prototipe PCB -universele printplaat in die helfte oor die lang as.

2. Sny die 40P manlike kop in stukke:

   1. 2 van 12P
   2. 3 van 3P
   3. 6 van 2P.

3. Sny die 40P vroulike kopstuk in stukke:

   1. 2 van 12P
   2. 1 van 6P
4. Soldeer 2 af 12 Vroulike kop soos getoon.
5. Plak die afstandhouer wat verwyder is uit 'n 3P -kop (bykomend) op die onderkant van die SPDT -skakelaar met cyanoakrylaatgom
6. Plaas aan die ander kant soldeer 6 van 2P, 2 van 3Pmale kop en die SPDT -skakelaar soos aangedui.
7. Soldeer 4 uit 10K weerstande (A, B, C, D swart) via leiding na GND -penkop (#2 swart) en na A0 - A3 -kopstukke (#5, #6, #7, #8) dan deur gat (geel) soos getoon (3 foto's + 1 diagram).
8. Spoor 3.3V van LDR PINS soldeer PINS #4, #6, #8, #10 en ryg deur die gat na die vroulike kop VCC pen (groen).
9. Volg 3.3V aan die vroulike kopkant soos getoon (rooi) soldeer na PINS #1, #12, #15.
10. 3.3V deurgat, gesoldeerde (rooi) RAW koptekst PIN #1.
11. Trek die oranje aansluiting van PIN #11 deur die gat na die soldeerpen, aan die ander kant, soos aangedui.
12. Spoor en soldeer blou aansluitdraad van #20 tot #30 en van #31 tot #13 en #16.
13. Soldeer Female Header PIN #11 tot Male Header PIN #11 deur gat.
14. Berei 2 dupont -aansluitings van 30 mm lank voor met 'n vroulike 1P -kopstuk (1 van blou, 1 van groen). Strooi en blik die ander kant.
15. Soldeerblou Dupont -draad na #28; soldeergroen Dupont -draad tot #29.
16. Bevestig die 6P -vroulike kopstuk aan die bokant van die Arduino, dan soldeer.
17. Maak aan die bokant van die Arduino die 2P reghoekige vroulike kop int #29 en #30 vas, soldeer dan.
18. Bevestig die 2 van 12P en 1 van 3P mannetjiespenne aan die onderkant van die Arduino en soldeer dan.
19. Plaas Arduino manlike 12P penne in PCB 12P vroulike kopstukke.

Stap 3: Flits die MCU

Die Arduino Pro Mini word gerieflik geflits met 'n FTDI232 USB na TTL -omskakelaar met behulp van die 6P vroulike kop. Sien die foto hierbo vir die belyning van die 2 borde.

Maak seker dat die 3.3V -instelling op u FTDI232 gekies is. Volg die instruksies hier met behulp van die onderstaande kode (gebruik die skakel na GIST).

Die lowpower-biblioteek (aangeheg en https://github.com/rocketscream/Low-Power) moet geïnstalleer word.

Sodra die Arduino Pro Mini + PCB in die omhulsel geïnstalleer is, kan dit steeds flits terwyl die koppenne blootgestel word. Ontkoppel net die beheereenheid van die paneelraamwerk wat die opskrif blootstel.

Kantelbare sonopsporing met I2C/EEPROM -konfigurasie en slaapsiklus tussen bewegings. Die presisie van die slaapsiklus neem af namate die duur toeneem, maar voldoende vir hierdie doel

/*

* gewysig van kode

* deur Mathias Leroy

*

* V0.2 WYSIGINGS

** I2C SET KRY

** EEPROM SET GET

** VERWYDER SERIE -UITPUT - GERAAKTE I2C

** INSKAKEL/UITSKAKELING SPOOR

** SKUI SERVO'S NA Beperkings VIA I2C

** LEES HUIDIGE AVG -INTENSITEIT VIA I2C

* V0.3 WYSIGINGS

** SKAKEL VIR 2 MODES - TRACK (NO I2C) en CONFIGURE (GEBRUIK I2C)

** SLAAP IN SPOORMODUS (BAIE LAE PRESISIE AAN 8 TWEEDE STUKKE)

** AFSNIT/HEG SERVOS AAN SLAAP/WAKKER (TRANSISTOR GEBRUIK EVENTUEL)

** VERWYDER KONFIGURERBARE OORSPRONKLIKE POSITIE (REDUNDANT)

** VERWYDER KONFIGURERBARE WAKE -SEKONDES (OORTOENDELIK)

** VERWYDER KONFIGURERBARE MAKLIK/AFSKAKELAAR (OORTRONDIG)

** VERWYDER KONFIGURERBARE TRACKER GEMAKKELD (GEBRUIK HARDWARE SKAKELAAR)

** HEF SPANNING GETTER - SAL AFSONDERDE I2C KOMPONENT GEBRUIK

** VOOR SERIE -AANMELDING TOE AS NIE I2C GEBRUIK NIE

*/

#insluit

#insluit

#insluit

#insluit

#insluit

#definieerEEPROM_VERSION1

#definieerI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definieerPIN_SERVO_V11

#definieerPIN_SERVO_H5

#definieerIDX_I2C_ADDR0

#definieerIDX_V_ANGLE_MIN1

#definieerIDX_V_ANGLE_MAX2

#definieerIDX_V_SENSITIVITY3

#definieerIDX_V_STEP4

#definieerIDX_H_ANGLE_MIN5

#definieerIDX_H_ANGLE_MAX6

#definieerIDX_H_SENSITIVITEIT7

#definieerIDX_H_STEP8

#definieerIDX_SLEEP_MINUTES9

#definieerIDX_V_DAWN_ANGLE10

#definieerIDX_H_DAWN_ANGLE11

#definieerIDX_DAWN_INTENSITY12 // gemiddelde van alle LDRS

#definieerIDX_DUSK_INTENSITY13 // gemiddelde van alle LDRS

#definieerIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // gemiddelde van alle LDRS - gebruik vir die berekening van IDX_DAWN_INTENSITY ambient non -direct light

#definieerIDX_END_VALUES_GET16

#definieerIDX_SIGN_117

#definieerIDX_SIGN_218

#definieerIDX_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 = vals;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

as (inConfigMode ()) {

Serial.println ("Config Mode");

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

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ontvangEvent);

Wire.onRequest (requestEvent);

} anders {

Serial.println ("Opsporingsmodus");

vertraging (5000); // tyd om hande uit die weg te ruim as u die battery aansluit, ens.

}

}

voidloop ()

{

getLightValues ();

as (! _inConfigMode) {

// ToDo: SKAKEL TRANSISTOR -SKAKELAAR IN

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

as (i! = 0) {

getLightValues ();

}

moveServos ();

}

vertraging (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: SKAKEL TRANSISTORSKakelaar uit

vertraging (500);

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

}

}

// --------------------------------- HUIDIGE MODUS

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

gee _inConfigMode terug;

}

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

voidgetFromEeprom () {

as (

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

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

EEPROM.update (i, _i2cVals );

}

EEPROM.opdatering (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");

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

_i2cVals = EEPROM.read (i);

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

}

}

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

voidreceiveEvent (int count) {

as (tel == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

byte -indeks = Wire.read ();

byte waarde = Wire.read ();

skakelaar (cmd) {

case'G ':

as (indeks <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [indeks];

}

breek;

saak'S:

as (indeks <IDX_END_EEPROM_SET) {

_i2cVals [indeks] = waarde;

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

}

breek;

verstek:

terugkeer;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDR's

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

// gaan links

Serial.println ("moveServos gaan links");

vertraging (_ vertraagde vertraging);

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

_servoH.write (_angleH--);

vertraging (_servoLoopDelay);

}

}

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

// gaan regs

Serial.println ("moveServos gaan links");

vertraging (_ vertraagde vertraging);

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

_servoH.write (_angleH ++);

vertraging (_servoLoopDelay);

}

}

anders {

// niks doen nie

Serial.println ("moveServos doen niks");

vertraging (_ vertraagde vertraging);

}

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

// gaan op

Serial.println ("moveServos gaan op");

vertraging (_ vertraagde vertraging);

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

_servoV.write (_angleV ++);

vertraging (_servoLoopDelay);

}

}

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

// afgaan

Serial.println ("moveServos gaan af");

vertraging (_ vertraagde vertraging);

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

_servoV.write (_angleV--);

vertraging (_servoLoopDelay);

}

}

anders {

Serial.println ("moveServos doen niks");

vertraging (_ vertraagde vertraging);

}

}

// --------------------------------- SLAAP

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

sien rawtilt_pan_tracker_0.3.ino aangebied deur ❤ deur GitHub

Stap 4: Monteer die stroombaan

1. Maak seker dat die Ardiuno Pro Mini in die kopstukke op die PCB geplaas word.
2. Plaas die basis van die SOLAR TRACKER -kontroleerder in die mure van die SOLAR TRACKER -kontroleerder en plak dit vas met 2 afgedrukte, selfverslaanbare skroewe van 4G x 6 mm.
3. Plaas Ardiuno Pro Mini + PCB met 'n 6P -kopstuk wat in die leemte in die SOLAR TRACKER -kontroleerderboksbasis steek.
4. Plaas die deksel van die SOLAR TRACKER -kontroleerderkas in die mure van die SOLAR TRACKER -kontroleerder en plak dit vas met 2 afgedrukte, selfverskeurende skroewe van 4G x 6 mm.
5. Bevestig die samestelling hierbo aan die onderkant van die paneelraam met 4 afgemaakte, selfverskeurende skroewe van 4 x 4 mm van vlekvrye versink.

Stap 5: Koppel die riglyne aan die kontroleerder

Die relevante verbindings wat gereed is uit die vorige Instructable, is 4 uit 2P LDR -verbindings en 2 uit 3P -verbindings vanaf die servo's. Wat tydelik is totdat die herlaai gereed is, is die battery. Gebruik 'n 3.7V LiPo wat vir eers in 'n 2P DuPont -verbinding eindig.

1. Plaas die LDR -verbindings (geen polariteit) van bo af:

   1. Regs bo
   2. Links bo
   3. Onder regs
   4. Links onder

2. Plaas die Servo -verbindings (met die seindraad na links) van bo:

   1. Horisontaal
   2. Vertikaal
3. WAG DAN TERUG GEREED DAN: Steek die 3,7V DC -kragkabel +ve bo -aan, onder na onder.

Stap 6: Toets die beheerder

Soos voorheen gesê, is die sagteware nie geoptimaliseer vir die werkstroom van sonopladings nie. Dit kan egter getoets en aangepas word met behulp van natuurlike (son) en onnatuurlike ligbronne.

Om die opsporing in 'n beheerde omgewing te toets, kan dit handig wees om die SLAAPMINUTE op 'n laer waarde in te stel (sien volgende stap).

Stap 7: Stel via I2C op met behulp van die konsole -invoer

Dit verduidelik die konfigurasie van die beheerder via 'n tweede MCU, om instellings in 'n konsolevenster in te voer.

1. Laai die volgende skrif na 'n D1M WIFI BLOCK (of Wemos D1 Mini) op.
2. Ontkoppel USB van die rekenaar

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

   SDA (beheerder) => D2 (D1M)

4. Draai die SPDT -skakelaar na CONFIG
5. Koppel USB aan 'n rekenaar
6. Begin 'n konsole -venster met die korrekte COM -poort vanaf die Arduino IDE
7. Maak seker dat "Newline" en "9600 baud" gekies is
8. Die opdragte word in die stuur teksboks ingevoer, gevolg deur die Enter -sleutel
9. Die opdragte is in die formaat Character byte byte
10. As die tweede greep (derde segment) nie ingesluit is nie, word 0 (nul) deur die skrif gestuur
11. Wees versigtig met die gebruik van reeksinvoer; kyk na wat u ingevoer het voordat u op die "Enter" -toets druk. As u geblokkeer is (byvoorbeeld om die I2C -adres te verander na 'n waarde wat u vergeet het), moet u die firmware van die kontroleerder weer flits.

Die ondersteunde variasies in die opdrag eerste karakter is:

• E (Aktiveer servo -opsporing) wat nuttig is om beweging tydens konfigurasie te stop. Dit word ingevoer met: E 0
• D (deaktiveer servospoor) is handig om outomatiese opsporing te begin as die toestel nie herlaai word nie. Dit word ingevoer met: D 0
• G (Kry konfigurasiewaarde) lees waardes van EEPROM en IN -MEMORY: Dit word ingevoer met: G (indeks is geldige bytewaardes 0 - 13 en 15)
• S (Stel EEPROM -waarde in) stel waardes op EEPROM wat beskikbaar is na herlaai. Dit word ingevoer met: S (indeks is geldige greepwaardes 0 - 13, waarde is geldige greepwaardes en wissel per eiendom)

Die kode is die punt van waarheid vir die indekse, maar die volgende word gebruik vir 'n gids vir geldige waardes/opmerkings:

• I2C ADRES 0 - beheerder slaaf adres, die meester benodig dit om met die beheerder te kommunikeer (standaard 10)
• MINIMUM VERTICALE HOEK 1 - hoek vertikale servo ondergrens (standaard 10, reeks 0 - 180)
• MAKSIMALE VERTIKALE HOEK 2 - vertikale hoek van die vertikale servo boonste limiet (standaard 170, reeks 0 - 180)
• SENSITIVITEIT VERTIKAAL LDR 3 - Vertikale LDR -leesmarge (standaard 20, reeks 0 - 1024)
• VERTICALE HOEKSTAP 4 - vertikale servostappe by elke verstelling (standaard 5, reeks 1 - 20)
• MINIMUM HORISONTALE HOEK 5 - hoek horisontale servo ondergrens (standaard 10, reeks 0 - 180)
• MAKSIMALE HORISONTALE HOEK 6 - hoek horisontale servo boonste limiet (standaard 170, reeks 0 - 180)
• GEVOEL HORISONTALE LDR 7 - Horisontale LDR -leesmarge (standaard 20, reeks 0 - 1024)
• HORISONTALE HOEKSTAP 8 - horisontale servostappe by elke verstelling (standaard 5, reeks 1 - 20)
• SLAAPMINUTE 9 - die geskatte slaaptyd tussen opsporing (standaard 20, reeks 1 - 255)
• VERTICAL DAWN HOEK 10 - TOEKOMSTIGE GEBRUIK - die vertikale hoek om na terug te keer wanneer die son ondergaan
• HORISONTALE DAAGHOEK 11 - TOEKOMSTIGE GEBRUIK - die horisontale hoek om na terug te keer wanneer die son ondergaan
• DAWN INTENSITY 12 - TOEKOMSTIGE GEBRUIK - die minimum gemiddelde van al die LDR's wat 'n begin met daaglikse sonopsporing veroorsaak
• DUSK INTENSITEIT 13 - TOEKOMSTIG GEBRUIK - die minimum gemiddelde van al die LDR's wat 'n einde maak aan die daaglikse sonopsporing
• EINDE VAN EEPROM WAARDES PUNT 14 - WAARDE NIE GEBRUIK NIE
• HUIDIGE INTENSITEIT 15 - die huidige gemiddelde persentasie van die ligintensiteit
• EINDE VAN GEHEUGSWAARDES MERKER 16 - WAARDE NIE GEBRUIK NIE.

Vang seriële invoer op (sleutelbordinvoer in die konsole -venster) en stuur dit na 'n I2C -slaaf in die formaat char, byte, byte

#insluit

#definieerI2C_MSG_IN_SIZE2

#definieerI2C_MSG_OUT_SIZE3

#definieerI2C_SLAVE_ADDRESS10

boolean _newData = false;

const byte _numChars = 32;

char _receivedChars [_numChars]; // 'n skikking om die ontvangde data te stoor

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

vertraging (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

statiese greep ndx = 0;

char endMarker = '\ n';

char rc;

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

rc = Serial.read ();

as (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

as (ndx> = _numChars) {

ndx = _numChars - 1;

}

} anders {

_receivedChars [ndx] = '\ 0'; // eindig die string

ndx = 0;

_newData = waar;

}

}

}

voidparseSendCommands () {

as (_newData == waar) {

constchar delim [2] = "";

char *teken;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

greepindeks = 0;

byte waarde = 0;

int i = 0;

terwyl (teken! = NULL) {

// Serial.println (teken);

ek ++;

skakel (i) {

saak 1:

token = strtok (NULL, delim);

indeks = atoi (token);

breek;

geval 2:

token = strtok (NULL, delim);

as (teken! = NULL) {

waarde = atoi (token);

}

breek;

verstek:

token = NULL;

}

}

sendCmd (cmd, indeks, waarde);

_newData = vals;

}

}

voidsendCmd (char cmd, byte -indeks, bytewaarde) {

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

Serial.println ("Stuur opdrag:");

Serial.println ("\ t" + string (cmd) + "" + string (indeks) + "" + string (waarde));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // stuur na toestel

Draad.skryf (cmd); // stuur 'n char

Wire.write (indeks); // stuur een greep

Wire.write (waarde); // stuur een greep

Wire.endTransmission ();

byte reaksie = 0;

bool hadResponse = false;

as (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

terwyl (Wire.available ()) // slaaf minder kan stuur as wat versoek is

{

hadResponse = waar;

reaksie = Wire.read ();

}

as (hadResponse == waar) {

Serial.println ("Kry reaksie:");

Serial.println (reaksie);

} anders {

Serial.println ("Geen antwoord, kyk na die adres/verbinding");

}

}

}

sien rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino aangebied deur ❤ deur GitHub

Stap 8: Volgende stappe

Gaan gereeld terug om na veranderinge in sagteware/hardeware te kyk.

Pas die sagteware/hardeware aan volgens u vereistes.

Lewer kommentaar op enige versoeke/optimalisering.