IOT123 - SOLAR TRACKER - CONTROLLER - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Dit is een uitbreiding van de Instructable

IOT123 - SOLAR TRACKER - KANTEL/PAN, PANEEL FRAME, LDR BEVESTIGT RIG. Hier concentreren we ons op de controller van de servo's en sensoren van de positie van de zon. Het is belangrijk erop te wijzen dat dit ontwerp ervan uitgaat dat er 2 MCU's worden gebruikt: één (3,3V 8mHz Arduino Pro Mini) voor de zonne-tracker en één onafhankelijke MCU voor uw sensoren/actoren.

Dit is versie 0.3

In plaats van alle projecten na volledige tevredenheid te publiceren, zal ik continue integratie oefenen en vaker iets leveren, waarbij ik wat ik heb geleverd aanpas als ik dat nodig heb. Ik zal nog een instructie schrijven voor de batterijlader, _wanneer_ de optimalisatie van de controllersoftware/hardware is voltooid. Ik zal aangeven waar de optimalisaties nodig zijn terwijl we dit doorlopen.

Een deel van de reden voor deze aanpak is feedback van klanten. Als jullie een behoefte zien of een betere aanpak hebben, reageer dan alsjeblieft, maar houd er rekening mee dat ik niet alles kan leveren en mogelijk niet binnen een tijdsbestek dat bij je past. Omdat deze uitleg minder relevant lijkt, worden ze uit dit artikel verwijderd.

Wat houdt dit in:

1. Gebruik de LDR's van de originele Instructable om de geschatte locatie van de zon te voelen.
2. Verplaats de servo's naar de zon gericht.
3. Opties voor de gevoeligheid van de bewegingen.
4. Opties voor de stapgrootte bij verplaatsing naar de zon.
5. Opties voor de hoekbeperkingen die op de servo's worden gebruikt.
6. Opties voor de vertragingen van de bewegingen.
7. I2C-interface voor het instellen/krijgen van waarden tussen MCU's.
8. Diepe slaap tussen bewegingen.

Wat dit niet omvat (en zal worden behandeld als de tijd het toelaat):

1. Gebruik alleen stroom bij daglicht.
2. Onthoud de positie van de dageraad en ga daarheen bij zonsondergang.
3. De regelaar uit de MCU verwijderen.
4. De LED('s) op de MCU uitschakelen.
5. De stroom omleiden via VCC in plaats van RAW.
6. Biedt tijdelijke oplossingen voor flitsen zonder gereguleerde stroom van de USB naar seriële TTL-converter.
7. Accuspanningsmonitor.

GESCHIEDENIS

20 dec. 2017 V0.1 CODE

Eerste versie volgt lichtbron, altijd aan, niet opladen

7 jan. 2018 V0.2 CODE

• HARDWAREWIJZIGINGEN

  • I2C-pinnen toevoegen
  • Schakelaar toevoegen aan servo-GND's
  • Gedrukt label op het dashboard van de controllerbox

• SOFTWAREWIJZIGINGEN

  • Configuratie lezen van EEPROM
  • I2C-busondersteuning als slave naar een andere MCU (3.3V)
  • Configuratie instellen via I2C
  • Ingeschakeld via I2C
  • Configuratie ophalen via I2C
  • Krijg runtime-eigenschappen via I2C (momenteel ingeschakeld en huidige lichtintensiteit)
  • Verwijder seriële logging (dit had invloed op I2C-waarden)

19 jan. 2018 V0.3 CODE

• HARDWARE

  Etiket bijgewerkt. Schakelaar wordt nu gebruikt om de CONFIG- of TRACK-modus te kiezen

• SOFTWARE

  • I2C alleen gebruikt voor configuratie
  • Controller wacht 5 seconden voordat de tracking wordt geïnitialiseerd, zodat de handen kunnen worden verplaatst
  • Om de I2C-configuratie te gebruiken, moet SPDT op CONFIG staan als de eenheid opstart
  • Tussen het volgen van bewegingen door bevindt het apparaat zich in de diepe slaapmodus voor de configuratiewaarde SLEEP MINUTES (standaard 20 minuten).

Stap 1: Materialen en gereedschappen

Er is nu een volledige lijst van materialen en bronnen.

1. 3D geprinte onderdelen.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 van 4x6cm dubbelzijdig prototype PCB universele printplaat (doormidden te knippen)
4. 1 off 40P mannelijke header (op maat te knippen).
5. 1 off 40P female header (op maat te knippen).
6. 4 van 10K 1/4W-weerstanden.
7. Aansluitdraad.
8. Soldeer en ijzer.
9. 20 stuks 4G x 6 mm roestvrijstalen zelftappende zelftappende schroeven.
10. 4 stuks 4G x 6 mm roestvrijstalen verzonken zelftappende schroeven.
11. 1 off 3.7V LiPo-batterij en houder (eindigend in 2P dupont-connectoren).
12. 1 uit 2P mannelijke haakse header
13. 1 uit SPDT-schakelaar 3-pins 2,54 mm pitch
14. Sterke cyanoacrylaatlijm
15. Dupont connectoren female 1P header (1 uit blauw, 1 uit groen).

Stap 2: Het circuit monteren

Het circuit heeft momenteel geen spanningsdelercircuit (voltmeter).

1. Snijd de 4x6 cm dubbelzijdige prototype PCB universele printplaat doormidden over de lange as.

2. Snijd de 40P mannelijke header in stukken:

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

3. Snijd de 40P vrouwelijke header in stukken:

   1. 2 van 12P
   2. 1 van 6P
4. Soldeer 2 uit 12Pfemale header zoals afgebeeld.
5. Lijm de afstandhouder die is verwijderd van een 3P mannelijke (extra) header op de onderkant van de SPDT Switch met cyanoacrylaatlijm
6. Aan de andere kant soldeer dan 6 uit 2P, 2 uit 3Pmale header en de SPDT-schakelaar zoals afgebeeld.
7. Soldeer 4 van 10K weerstanden (A, B, C, D zwart) via kabel naar GND pin header (#2 zwart) en naar A0 - A3 header pins (#5, #6, #7, #8) en dan door gat (geel) zoals afgebeeld (3 foto's + 1 diagram).
8. Traceer 3,3 V van LDR PINS soldeer PINS #4, #6, #8, #10 en rijg door het gat naar vrouwelijke header VCC pin (groen).
9. Traceer 3,3 V aan de vrouwelijke kopzijde zoals afgebeeld (rood) en soldeer naar PINS #1, #12, #15.
10. 3.3V doorgaand gat de gesoldeerde (rode) RAW header PIN #1 aan de zijkant.
11. Trek de oranje aansluiting van PIN #11 door het gat om de vrouwelijke pin aan de andere kant te solderen, zoals afgebeeld.
12. Traceer en soldeer blauwe aansluitdraad van #20 tot #30 en van #31 tot #13 en #16.
13. Soldeer vrouwelijke header PIN #11 naar mannelijke header PIN #11 door het gat.
14. Bereid 2 dupont-connectoren van 30 mm lang voor met vrouwelijke 1P-header (1 uit blauw, 1 uit groen). Strip en vertin het andere uiteinde.
15. Soldeer blauwe Dupont draad naar #28; soldeer groene Dupont draad aan #29.
16. Bevestig aan de bovenkant van de Arduino de 6P vrouwelijke header en soldeer vervolgens.
17. Bevestig aan de bovenkant van de Arduino de 2P haakse vrouwelijke header int #29 en #30 en soldeer vervolgens.
18. Bevestig aan de onderkant van de Arduino de 2 van 12P en 1 uit 3P mannelijke pinnen en soldeer vervolgens.
19. Steek Arduino mannelijke 12P-pinnen in PCB 12P vrouwelijke headers.

Stap 3: De MCU knipperen

De Arduino Pro Mini wordt handig geflitst met behulp van een FTDI232 USB naar TTL-converter met behulp van de 6P vrouwelijke header. Zie de foto hierboven voor de uitlijning van de 2 planken.

Zorg ervoor dat de 3.3V-instelling is gekozen op uw FTDI232. Volg de instructies hier met behulp van de onderstaande code (gebruik link naar GIST).

De lowpower-bibliotheek (bijgevoegd en https://github.com/rocketscream/Low-Power) moet worden geïnstalleerd.

Zodra de Arduino Pro Mini + PCB in de behuizing is geïnstalleerd, kan deze nog steeds worden geflitst omdat de header-pinnen zichtbaar zijn. Koppel gewoon de controllereenheid los van het paneelframe, zodat de kop vrijkomt.

Tilt pan solar tracker met I2C/EEPROM configuratie en slaapcyclus tussen bewegingen. De nauwkeurigheid van de slaapcyclusduur neemt af naarmate de duur toeneemt, maar is voldoende voor dit doel

/*

* gewijzigd van code

* door Mathias Leroy

*

* V0.2 WIJZIGINGEN

** I2C SET GET

** EEPROM SET GET

** VERWIJDER SERILE UITGANG - BETROKKEN I2C

** TRACKING IN-/UITSCHAKELEN

** VERPLAATS SERVO'S NAAR LIMIETEN VIA I2C

** LEES HUIDIGE AVG-INTENSITEIT VIA I2C

* V0.3 WIJZIGINGEN

** SCHAKEL NAAR 2 MODI - TRACK (GEEN I2C) en CONFIGUREER (GEBRUIK I2C)

** SLEEP IN TRACK-MODUS (ZEER LAGE PRECISIE DOOR 8 SECONDE CHUNKS)

** DETACH/BEVESTIG SERVO'S OP SLEEP/WAKE (TRANSISTOR GEBRUIKT EVENTUEEL)

** VERWIJDER CONFIGUREERBARE OORSPRONKELIJKE POSITIE (REDUNDANT)

** VERWIJDER CONFIGUREERBARE WAKE SECONDEN (REDUNDANT)

** VERWIJDER CONFIGUREERBAAR IN-/UITSCHAKELEN (REDUNDANT)

** VERWIJDER CONFIGUREERBARE TRACKER INGESCHAKELD (GEBRUIK HARDWARE-SCHAKELAAR)

** VERWIJDER VOLTAGE GETTER - ZAL EEN APART I2C-COMPONENT GEBRUIKEN

** SERILE LOGGING TOEVOEGEN WANNEER I2C NIET GEBRUIKT wordt

*/

#erbij betrekken

#erbij betrekken

#erbij betrekken

#erbij betrekken

#erbij betrekken

#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// gemiddelde van alle LDRS

#defineIDX_DUSK_INTENSITY13// gemiddelde van alle LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15// gemiddelde van alle LDRS - gebruikt voor het berekenen van IDX_DAWN_INTENSITY niet-direct omgevingslicht

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

int _angleV = 90;

int _gemiddeldeTop = 0;

int _gemiddeldeRight = 0;

int _gemiddeldeBottom = 0;

int _gemiddeldeLeft = 0;

byte _i2cResponse = 0;

bool _inConfigMode = false;

voidsetup()

{

Serieel.begin(115200);

getFromEeprom();

if (inConfigMode()){

Serial.println ("Config-modus");

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

Serial.println(_i2cVals[IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

}anders{

Serial.println("Volgmodus");

vertraging (5000);// tijd om de handen uit de weg te ruimen bij het aansluiten van de batterij enz.

}

}

voidloop()

{

getLightValues();

if (!_inConfigMode){

// ToDo: TRANSISTORSCHAKELAAR INSCHAKELEN

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

als (i != 0){

getLightValues();

}

moveServo's();

}

vertraging (500);

_servoH.detach();

_servoV.detach();

// ToDo: TRANSISTORSCHAKELAAR UITSCHAKELEN

vertraging (500);

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

}

}

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

boolinConfigMode(){

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

retourneer _inConfigMode;

}

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

voidgetFromEeprom(){

indien(

EEPROM.read(IDX_SIGN_1) != 'S' ||

EEPROM.read(IDX_SIGN_2) != 'T' ||

EEPROM.lezen(IDX_SIGN_3) != EEPROM_VERSION

) EEPROM_write_default_configuration();

EEPROM_read_configuration();

}

voidEEPROM_write_default_configuration(){

Serial.println ("EEPROM_write_default_configuration");

voor (int i = 0; ik < 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");

voor (int i = 0; ik < IDX_END_EEPROM_SET; i++){

_i2cVals = EEPROM.lezen(i);

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

}

}

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

voidreceiveEvent(int aantal) {

if (telling == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read();

byte-index = Wire.read();

bytewaarde = Wire.read();

schakelaar (cmd) {

geval'G':

if (index< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals[index];

}

pauze;

gevallen':

if (index< IDX_END_EEPROM_SET){

_i2cVals[index] = waarde;

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

}

pauze;

standaard:

opbrengst;

}

}

}

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 + waardeBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (valueTopLeft + valueTopRight + valueBottomRight + waardeBottomLeft) / 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]) {

// naar links gaan

Serial.println("moveServos gaan naar links");

vertraging (_slowingDelay);

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

// gaat naar rechts

Serial.println("moveServos gaan naar links");

vertraging (_slowingDelay);

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

_servoH.write(_angleH++);

vertraging (_servoLoopDelay);

}

}

anders {

// niks doen

Serial.println ("moveServos doet niets");

vertraging (_slowingDelay);

}

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

// omhoog gaan

Serial.println("moveServos gaan omhoog");

vertraging (_slowingDelay);

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

// neerstorten

Serial.println("moveServos gaan naar beneden");

vertraging (_slowingDelay);

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

_servoV.write(_angleV--);

vertraging (_servoLoopDelay);

}

}

anders {

Serial.println ("moveServos doet niets");

vertraging (_slowingDelay);

}

}

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

vidasleepFor(unsignedint eightSecondSegments){

Serial.println("in slaap voor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

bekijk rawtilt_pan_tracker_0.3.ino gehost met ❤ door GitHub

Stap 4: Montage van de circuitbehuizing

1. Zorg ervoor dat de Ardiuno Pro Mini in de headers op de PCB is geplaatst.
2. Plaats de SOLAR TRACKER-controllerboxbasis in de SOLAR TRACKER-controllerboxwanden en bevestig deze met 2 4G x 6 mm roestvrijstalen verzonken zelftappende schroeven.
3. Steek de Ardiuno Pro Mini + PCB met 6P-header in de leegte in de SOLAR TRACKER-controllerboxbasis.
4. Plaats het deksel van de SOLAR TRACKER-controllerbox in de wanden van de SOLAR TRACKER-controllerbox en bevestig deze met 2 roestvrijstalen verzonken zelftappende schroeven van 4G x 6 mm.
5. Bevestig de montage hierboven aan de basis van het paneelframe met 4 stuks 4G x 6 mm roestvrijstalen verzonken zelftappende schroeven.

Stap 5: De installatiekabels aansluiten op de controller

De relevante verbindingen klaar van de vorige Instructable, zijn 4 uit 2P LDR-verbindingen en 2 uit 3P-verbindingen van de servo's. Wat tijdelijk is totdat het opladen klaar is, is de batterij. Gebruik voorlopig een 3.7V LiPo die eindigt in een 2P DuPont-verbinding.

1. Plaats de LDR-aansluitingen (geen polariteit) van bovenaf:

   1. Rechtsboven
   2. Linksboven
   3. Rechts onder
   4. Linksonder

2. Steek de servo-aansluitingen (met de signaaldraad naar links) van bovenaf in:

   1. Horizontaal
   2. Verticaal
3. WACHT TOT KLAAR VOOR DE TEST DAN: Steek de 3.7V DC voedingskabel +ve naar boven, -ve naar beneden.

Stap 6: De controller testen

Zoals eerder vermeld, is de software niet geoptimaliseerd voor de Solar Charging-workflow. Het kan echter worden getest en aangepast met behulp van natuurlijke (zon) en onnatuurlijke lichtbronnen.

Om de tracking in een gecontroleerde omgeving te testen, kan het handig zijn om de SLEEP MINUTES op een lagere waarde in te stellen (zie volgende stap).

Stap 7: configureren via I2C met behulp van console-invoer

Dit verklaart het configureren van de controller via een tweede MCU, het invoeren van instellingen in een consolevenster.

1. Upload het volgende script naar een D1M WIFI BLOCK (of Wemos D1 Mini).
2. USB loskoppelen van pc

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

   SDA (Controller) => D2 (D1M)

4. Draai de SPDT-schakelaar naar CONFIG
5. Sluit USB aan op pc
6. Start vanuit de Arduino IDE een consolevenster met de juiste COM-poort
7. Zorg ervoor dat "Newline" en "9600 baud" zijn geselecteerd
8. De opdrachten worden ingevoerd in het tekstvak Verzenden gevolgd door de Enter-toets
9. De commando's hebben het formaat Character byte byte
10. Als de tweede byte (derde segment) niet is opgenomen, wordt 0 (nul) verzonden door het script
11. Wees voorzichtig bij het gebruik van seriële invoer; controleer wat u hebt ingevoerd voordat u op de "Enter"-toets drukt. Als u bent buitengesloten (bijvoorbeeld het wijzigen van het I2C-adres naar een waarde die u bent vergeten), moet u de firmware van de controller opnieuw flashen.

De ondersteunde variaties in het eerste teken van de opdracht zijn:

• E (Servo-tracking inschakelen) handig voor het stoppen van beweging tijdens configuratie. Dit wordt ingevoerd met: E 0
• D (Servo-tracking uitschakelen) handig om automatisch volgen te starten als het apparaat niet opnieuw wordt opgestart. Dit wordt ingevoerd met: D 0
• G (Configuratiewaarde ophalen) leest waarden uit EEPROM en IN-MEMORY: Dit wordt ingevoerd met: G (index is geldige bytewaarden 0 - 13 en 15)
• S (Set EEPROM value) stelt waarden in op EEPROM die beschikbaar zijn na opnieuw opstarten. Dit wordt ingevoerd met: S (index is geldige bytewaarden 0 - 13, waarde is geldige bytewaarden en verschilt per eigenschap)

De code is het punt van waarheid voor de indexen, maar het volgende wordt gebruikt als richtlijn voor geldige waarden/opmerkingen:

• I2C ADRES 0 - controller slave adres, de master heeft dit nodig om te communiceren met de controller (standaard 10)
• MINIMALE VERTICALE HOEK 1 - hoek verticale servo ondergrens (standaard 10, bereik 0 - 180)
• MAXIMALE VERTICALE HOEK 2 - hoek verticale servo bovengrens (standaard 170, bereik 0 - 180)
• GEVOELIGHEID VERTICALE LDR 3 - Verticale LDR-leesmarge (standaard 20, bereik 0 - 1024)
• VERTICALE HOEK STAP 4 - hoek verticale servostappen bij elke aanpassing (standaard 5, bereik 1 - 20)
• MINIMALE HORIZONTALE HOEK 5 - hoek horizontale servo ondergrens (standaard 10, bereik 0 - 180)
• MAXIMALE HORIZONTALE HOEK 6 - hoek horizontale servo bovengrens (standaard 170, bereik 0 - 180)
• GEVOELIGHEID HORIZONTAAL LDR 7 - Horizontale LDR-leesmarge (standaard 20, bereik 0 - 1024)
• HORIZONTALE HOEK STAP 8 - hoek horizontale servostappen bij elke aanpassing (standaard 5, bereik 1 - 20)
• SLEEP MINUTES 9 - de geschatte slaapperiode tussen tracking (standaard 20, bereik 1 - 255)
• VERTICALE DAGERAADHOEK 10 - TOEKOMSTIG GEBRUIK - de verticale hoek om naar terug te keren als de zon ondergaat
• HORIZONTALE DAGERAADHOEK 11 - TOEKOMSTIG GEBRUIK - de horizontale hoek om naar terug te keren als de zon ondergaat
• DAWN INTENSITY 12 - TOEKOMSTIG GEBRUIK - het minimumgemiddelde van alle LDR's die een start van het dagelijkse volgen van de zon veroorzaken
• DUSK INTENSITY 13 - TOEKOMSTIG GEBRUIK - het minimumgemiddelde van alle LDR's dat een einde maakt aan het dagelijks volgen van de zon
• EINDE VAN EEPROM-WAARDEN MARKER 14 - WAARDE NIET GEBRUIKT
• HUIDIGE INTENSITEIT 15 - het huidige gemiddelde percentage van de lichtintensiteit
• EINDE VAN IN-GEHEUGEN WAARDEN MARKER 16 - WAARDE NIET GEBRUIKT.

Legt seriële invoer vast (toetsenbordinvoer in het consolevenster) en stuurt deze door naar een I2C-slave in het formaat char, byte, byte

#erbij betrekken

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

const-byte _numChars = 32;

char _receivedChars[_numChars]; // een array om de ontvangen gegevens op te slaan

voidsetup() {

Serieel.begin(9600);

Draad.begin(D2, D1);

vertraging (5000);

}

voidloop() {

recvWithEndMarker();

parseSendCommands();

}

voidrecvWithEndMarker() {

statische byte ndx = 0;

char endMarker = '\n';

char rc;

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

rc = Serieel.lezen();

if (rc != endMarker) {

_receivedChars[ndx] = rc;

ndx++;

if (ndx >= _numChars) {

ndx = _numChars - 1;

}

} anders {

_receivedChars[ndx] = '\0'; // beëindig de string

ndx = 0;

_newData = waar;

}

}

}

voidparseSendCommands() {

if (_newData == waar) {

constchar delim[2] = "";

char * token;

token = strtok(_receivedChars, delim);

char cmd = _receivedChars[0];

byte-index = 0;

bytewaarde = 0;

int ik = 0;

while(token != NULL) {

//Serial.println(token);

i++;

schakelaar (ik){

zaak 1:

token = strtok (NULL, delim);

index = atoi(token);

pauze;

geval2:

token = strtok (NULL, delim);

if (token != NULL){

waarde = atoi(token);

}

pauze;

standaard:

token = NULL;

}

}

sendCmd(cmd, index, waarde);

_newData = onwaar;

}

}

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

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

Serial.println("Verzendopdracht:");

Serial.println ("\t" + String (cmd) + "" + String (index) + "" + String (waarde));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // verzenden naar apparaat

Wire.write (cmd); // stuurt een char

Wire.write (index); // verzendt één byte

Wire.write (waarde); // verzendt één byte

Wire.endTransmission();

byterespons = 0;

bool hadResponse = false;

if (cmd == 'G'){

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

while(Wire.available()) // slave kan minder verzenden dan gevraagd

{

hadResponse = waar;

reactie = Wire.read();

}

if (hadResponse == true){

Serial.println("Reactie ontvangen:");

Serial.println(antwoord);

}anders{

Serial.println("Geen reactie, controleer het adres/verbinding");

}

}

}

bekijk rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino gehost met ❤ door GitHub

Stap 8: Volgende stappen

Kom regelmatig terug om te controleren op wijzigingen in software/hardware.

Pas de software/hardware aan uw vereisten aan.

Reageer op eventuele verzoeken/optimalisaties.