IOT123 - SOLAR TRACKER - CONTROLLER - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Dies ist eine Erweiterung des Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL FRAME, LDR MOUNTS RIG. Hier konzentrieren wir uns auf die Steuerung der Servos und Sensoren des Sonnenstandes. Es ist wichtig darauf hinzuweisen, dass dieses Design davon ausgeht, dass 2 MCUs verwendet werden: eine (3.3V 8mHz Arduino Pro Mini) für den Solartracker und eine unabhängige MCU für Ihre Sensoren/Aktoren.

Dies ist Version 0.3

Anstatt alle Projekte nach vollständiger Zufriedenheit zu veröffentlichen, werde ich kontinuierliche Integration praktizieren und öfter etwas liefern und das, was ich geliefert habe, nach Bedarf modifizieren. Ich werde ein weiteres anweisbares für das Ladegerät schreiben, _wenn_ die Optimierung der Controller-Software / -Hardware abgeschlossen ist. Ich werde darauf hinweisen, wo die Optimierungen erforderlich sind, während wir dies durchziehen.

Ein Grund für diesen Ansatz ist das Kundenfeedback. Wenn Sie einen Bedarf sehen oder einen besseren Ansatz haben, kommentieren Sie bitte, aber denken Sie daran, dass ich nicht alles und möglicherweise nicht in einem für Sie passenden Zeitrahmen liefern kann. Da diese Erläuterungen weniger relevant erscheinen, werden sie aus diesem Artikel gestrichen.

Was dazu gehört:

1. Verwenden Sie die LDRs aus dem ursprünglichen Instructable, um die ungefähre Position der Sonnen zu erfassen.
2. Bewegen Sie die Servos so, dass sie der Sonne zugewandt sind.
3. Optionen für die Empfindlichkeit der Bewegungen.
4. Optionen für die Schrittweite beim Bewegen zur Sonne.
5. Optionen für die bei den Servos verwendeten Winkelbeschränkungen.
6. Optionen für die Verzögerungen der Bewegungen.
7. I2C-Schnittstelle zum Setzen/Abrufen von Werten zwischen MCUs.
8. Tiefer Schlaf zwischen den Bewegungen.

Was dies nicht beinhaltet (und als zeitliche Erlaubnis behandelt wird):

1. Strom nur bei Tageslicht verbrauchen.
2. Erinnern Sie sich an die Morgendämmerungsposition und gehen Sie bei der Abenddämmerung dorthin.
3. Entfernen des Reglers von der MCU.
4. Deaktivieren der LED(s) an der MCU.
5. Umleitung des Stroms über VCC statt RAW.
6. Bereitstellung von Problemumgehungen für das Flashen ohne geregelte Stromversorgung vom USB-zu-Seriell-TTL-Konverter.
7. Batteriespannungswächter.

GESCHICHTE

20.12.2017 V0.1 CODE

Erste Version verfolgt Lichtquelle, immer an, kein Aufladen

7. Januar 2018 V0.2 CODE

• HARDWARE-ÄNDERUNGEN

  • I2C-Pins hinzufügen
  • Schalter zu Servo GNDs hinzufügen
  • Gedrucktes Etikett auf der Frontseite der Controller-Box

• SOFTWARE-ÄNDERUNGEN

  • Konfiguration aus EEPROM lesen
  • I2C-Bus-Unterstützung als Slave zu einer anderen MCU (3,3 V)
  • Konfiguration über I2C. einstellen
  • Aktiviert über I2C. setzen
  • Holen Sie sich die Konfiguration über I2C
  • Abrufen von Laufzeiteigenschaften über I2C (derzeit aktiviert und aktuelle Lichtintensität)
  • Entfernen Sie die serielle Protokollierung (es betraf die I2C-Werte)

19.01.2018 V0.3 CODE

• HARDWARE

  Etikett aktualisiert. Der Schalter wird jetzt verwendet, um entweder den CONFIG- oder den TRACK-Modus zu wählen

• SOFTWARE

  • I2C wird nur zur Konfiguration verwendet
  • Der Controller wartet 5 Sekunden, bevor er die Verfolgung initialisiert, ermöglicht das Bewegen der Hände
  • Um die I2C-Konfiguration zu verwenden, muss SPDT beim Booten des Geräts auf CONFIG stehen
  • Zwischen den Verfolgungsbewegungen befindet sich das Gerät im Tiefschlafmodus für den Konfigurationswert SLEEP MINUTEN (Standard 20 Minuten).

Schritt 1: Materialien und Werkzeuge

Es gibt jetzt eine vollständige Liste der Materialien und Quellen.

1. 3D-gedruckte Teile.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 von 4x6cm Double Side Prototyp PCB Universal Printed Circuit Board (zur Hälfte zu schneiden)
4. 1 Stück 40P Stiftleiste (zur Größe zuzuschneiden).
5. 1 Stück 40P Buchsenleiste (zuschneiden).
6. 4 von 10K 1/4W-Widerständen.
7. Anschlusskabel.
8. Löten und Eisen.
9. 20 Stück 4G x 6mm Edelstahl Flachkopf Blechschrauben.
10. 4 Stück 4G x 6mm Edelstahl Senkblechschrauben.
11. 1 Stück 3,7 V LiPo-Akku und Halter (mit 2P-Dupont-Anschlüssen).
12. 1 von 2P männlichen rechtwinkligen Header
13. 1 aus SPDT-Schalter 3 Pin 2,54 mm Rastermaß
14. Starker Cyanacrylatkleber
15. Dupont-Steckverbinder 1P-Stiftleiste (1 Stück blau, 1 Stück grün).

Schritt 2: Zusammenbau der Schaltung

Die Schaltung verfügt derzeit nicht über die Spannungsteilerschaltung (Voltmeter).

1. Schneiden Sie die 4x6cm doppelseitige Prototyp-PCB-Universal-Leiterplatte entlang der Längsachse in zwei Hälften.

2. Schneiden Sie den 40P-Stecker in Stücke:

   1. 2 von 12P
   2. 3 von 3P
   3. 6 von 2P.

3. Schneiden Sie die 40P-Buchse in Stücke:

   1. 2 von 12P
   2. 1 von 6P
4. Löten Sie 2 von 12Female-Header wie abgebildet.
5. Kleben Sie den Abstandshalter, der von einem 3P-Stecker (zusätzlich) entfernt wurde, mit Cyanacrylatkleber auf die Unterseite des SPDT-Schalters
6. Auf der anderen Seite platzieren Sie dann 6 von 2P, 2 von 3Pmale Header und den SPDT-Schalter wie gezeigt.
7. Löten Sie 4 von 10K-Widerständen (A, B, C, D schwarz) über das Kabel an die GND-Stiftleiste (#2 schwarz) und an die A0 - A3-Header-Pins (#5, #6, #7, #8) dann durch das Loch (gelb) wie abgebildet (3 Fotos + 1 Diagramm).
8. Verfolgen Sie 3,3 V von den LDR PINS, löten Sie die PINS #4, #6, #8, #10 und fädeln Sie durch das Loch zum VCC-Stift (grün) der Buchsenleiste.
9. Verfolgen Sie 3,3 V auf der Buchsenleistenseite wie gezeigt (rot) und löten Sie an PINS #1, #12, #15.
10. 3.3V durch die gelötete Seite (rot) des RAW-Headers PIN #1.
11. Verfolgen Sie den orangefarbenen Anschluss von PIN #11 durch das Loch, um den Buchsenstift auf der anderen Seite wie gezeigt zu löten.
12. Verfolgen und löten Sie das blaue Anschlusskabel von #20 bis #30 und von #31 bis #13 und #16.
13. Löten Sie den Buchsenleisten-PIN #11 auf den Steckerleisten-PIN #11 durch das Loch.
14. Bereiten Sie 2 Dupont-Steckverbinder mit einer Länge von 30 mm mit 1P-Buchse vor (1 Stück blau, 1 Stück grün). Das andere Ende abstreifen und verzinnen.
15. Blauen Dupont-Draht an #28 anlöten; Grünen Dupont-Draht an #29 anlöten.
16. Auf der Oberseite des Arduino die 6P-Buchse befestigen und dann löten.
17. Auf der Oberseite des Arduino befestigen Sie die 2P rechtwinklige Buchsenleiste int #29 und #30 und löten dann.
18. Auf der Unterseite des Arduino befestigen Sie die 2 von 12P und 1 von 3P-Steckerstiften und löten Sie dann.
19. Stecken Sie Arduino männliche 12P Pins in PCB 12P Buchsenleisten.

Schritt 3: Flashen der MCU

Der Arduino Pro Mini wird bequem mit einem FTDI232-USB-zu-TTL-Konverter mit der 6P-Buchse geflasht. Siehe das Foto oben für die Ausrichtung der 2 Bretter.

Stellen Sie sicher, dass auf Ihrem FTDI232 die Einstellung 3,3 V ausgewählt ist. Befolgen Sie die Anweisungen hier mit dem folgenden Code (verwenden Sie den Link zu GIST).

Die Low-Power-Bibliothek (angehängt und https://github.com/rocketscream/Low-Power) muss installiert werden.

Sobald das Arduino Pro Mini + PCB im Gehäuse installiert ist, kann es immer noch geflasht werden, da die Header-Pins freigelegt sind. Trennen Sie einfach die Controller-Einheit vom Panel-Rahmen und legen Sie den Header frei.

Tilt-Pan-Solartracker mit I2C/EEPROM-Konfiguration und Schlafzyklus zwischen den Bewegungen. Die Genauigkeit der Schlafzyklusdauer nimmt mit zunehmender Dauer ab, ist aber für diesen Zweck ausreichend

/*

* geändert vom Code

* von Mathias Leroy

*

* V0.2 MODIFIKATIONEN

** I2C-SET ERHALTEN

** EEPROM-SET GET

** SERIELLER AUSGANG ENTFERNEN - BETROFFENES I2C

** TRACKING AKTIVIEREN/DEAKTIVIEREN

** SERVOS ÜBER I2C. AN GRENZEN BEWEGEN

** AKTUELLE DURCHSCHNITTLICHE INTENSITÄT ÜBER I2C LESEN

* V0.3 MODIFIKATIONEN

** SCHALTER FÜR 2 MODI - TRACK (KEIN I2C) und KONFIGURIEREN (VERWENDET I2C)

** SCHLAF IM TRACK-MODUS (SEHR GERINGE PRÄZISION DURCH 8 SEKUNDEN CHUNKS)

** SERVOS BEI SCHLAF/WACH ABNEHMEN/ANSCHLIESSEN (TRANSISTOR EVENTUELL VERWENDET)

** KONFIGURIERBARE ANFANGSPOSITION ENTFERNEN (REDUNDANT)

** KONFIGURIERBARE WAKE SEKUNDEN ENTFERNEN (REDUNDANT)

** KONFIGURIERBAR ENTFERNEN AKTIVIEREN/DEAKTIVIEREN (REDUNDANT)

** KONFIGURIERBAREN TRACKER ENTFERNEN AKTIVIERT (HARDWARE-SCHALTER VERWENDEN)

** SPANNUNGSGETTER ENTFERNEN - VERWENDET SEPARATE I2C-KOMPONENTE

** SERIELLE AUFZEICHNUNG HINZUFÜGEN, WENN I2C NICHT VERWENDET WIRD

*/

#enthalten

#enthalten

#enthalten

#enthalten

#enthalten

#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// Durchschnitt aller LDRS

#defineIDX_DUSK_INTENSITY13// Durchschnitt aller LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15// Durchschnitt aller LDRS - wird für die Berechnung von IDX_DAWN_INTENSITY Umgebungslicht verwendet

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

int_WinkelV = 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 ("Konfigurationsmodus");

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

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

}anders{

Serial.println ("Tracking-Modus");

Verzögerung (5000); // Zeit, um die Hände aus dem Weg zu räumen, wenn die Batterie angeschlossen wird usw.

}

}

Leerschleife()

{

getLightValues();

if (!_inConfigMode){

// ToDo: TRANSISTORSCHALTER EINSCHALTEN

_servoH.attach(PIN_SERVO_H);

_servoV.attach(PIN_SERVO_V);

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

wenn (ich != 0){

getLightValues();

}

moveServos();

}

Verzögerung (500);

_servoH.detach();

_servoV.detach();

// ToDo: TRANSISTORSCHALTER AUSSCHALTEN

Verzögerung (500);

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

}

}

//---------------------------------MOMENTANER ZUSTAND

boolinConfigMode(){

pinMode (PIN_SERVO_H, EINGANG);

_inConfigMode = digitalRead(PIN_SERVO_H) == 1;

_inConfigMode zurückgeben;

}

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

voidgetFromEeprom(){

wenn(

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 (Anzahl == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read();

Byteindex = Wire.read();

Bytewert = Wire.read();

wechseln (cmd) {

Fall'G':

if (index< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals[Index];

}

brechen;

Fälle':

if (index<IDX_END_EEPROM_SET){

_i2cVals[index] = Wert;

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

}

brechen;

Ursprünglich:

Rückkehr;

}

}

}

voidrequestEvent()

{

Wire.write(_i2cResponse);

}

//---------------------------------LDRs

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 = (WertTopLeft + WertTopRight) / 2;

_averageRight = (WertTopRight + WertBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (WertTopLeft + WertTopRight + WertBottomRight + WertBottomLeft) / 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]) {

// nach links gehen

Serial.println ("moveServos geht nach links");

Verzögerung (_slowingDelay);

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

_servoH.write(_angleH--);

Verzögerung (_servoLoopDelay);

}

}

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

// nach rechts gehen

Serial.println ("moveServos geht nach links");

Verzögerung (_slowingDelay);

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

_servoH.write(_angleH++);

Verzögerung (_servoLoopDelay);

}

}

anders {

// nichts tun

Serial.println ("moveServos tut nichts");

Verzögerung (_slowingDelay);

}

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

// nach oben gehen

Serial.println ("moveServos geht nach oben");

Verzögerung (_slowingDelay);

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

_servoV.write(_angleV++);

Verzögerung (_servoLoopDelay);

}

}

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

// untergehen

Serial.println ("moveServos geht runter");

Verzögerung (_slowingDelay);

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

_servoV.write(_angleV--);

Verzögerung (_servoLoopDelay);

}

}

anders {

Serial.println ("moveServos tut nichts");

Verzögerung (_slowingDelay);

}

}

//---------------------------------SCHLAF

voidasleepFor(unsignedint achtSecondSegments){

Serial.println ("schlafen für");

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

{

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

rawtilt_pan_tracker_0.3.ino anzeigen, gehostet mit ❤ von GitHub

Schritt 4: Zusammenbau des Schaltungsgehäuses

1. Stellen Sie sicher, dass der Ardiuno Pro Mini in die Header auf der Platine eingesetzt ist.
2. Setzen Sie die Basis der SOLAR TRACKER-Controllerbox in die Wände der SOLAR TRACKER-Controllerbox ein und befestigen Sie sie mit 2 Stück 4G x 6mm Edelstahl Senkblechschrauben.
3. Setzen Sie Ardiuno Pro Mini + PCB mit 6P-Header-Steckplatz in den Hohlraum in der Basis der SOLAR TRACKER-Controller-Box ein.
4. Setzen Sie den Deckel der SOLAR TRACKER-Controllerbox in die Wände der SOLAR TRACKER-Controllerbox ein und befestigen Sie ihn mit 2 Stück 4G x 6mm Edelstahl Senkblechschrauben.
5. Befestigen Sie die Baugruppe oben an der Basis des Panelrahmens mit 4 Stück 4G x 6mm Edelstahl Senkblechschrauben.

Schritt 5: Anschließen der Rig-Kabel an den Controller

Die entsprechenden Verbindungen, die aus dem vorherigen Instructable bereit sind, sind 4 von 2P LDR-Verbindungen und 2 von 3P-Verbindungen von den Servos. Was temporär ist, bis das Aufladen bereit ist, ist die Batterie. Verwenden Sie vorerst einen 3,7-V-LiPo, der in einer 2P-DuPont-Verbindung endet.

1. Stecken Sie die LDR-Anschlüsse (keine Polarität) von oben ein:

   1. Oben rechts
   2. Oben links
   3. Unten rechts
   4. Unten links

2. Stecken Sie die Servoanschlüsse (mit der Signalleitung nach links) von oben:

   1. Horizontal
   2. Vertikal
3. WARTEN SIE BIS ZUM TEST BEREIT DANN: Stecken Sie das 3,7-V-DC-Stromkabel +ve nach oben, -ve nach unten.

Schritt 6: Testen des Controllers

Wie bereits erwähnt, wurde die Software nicht für den Solarlade-Workflow optimiert. Es kann jedoch mit natürlichen (Sonne) und unnatürlichen Lichtquellen getestet und optimiert werden.

Um das Tracking in einer kontrollierten Umgebung zu testen, kann es sinnvoll sein, die SLEEP MINUTEN auf einen niedrigeren Wert einzustellen (siehe nächster Schritt).

Schritt 7: Konfiguration über I2C mit Konsoleneingabe

Dies erklärt die Konfiguration des Controllers über eine zweite MCU und die Eingabe von Einstellungen in ein Konsolenfenster.

1. Laden Sie das folgende Skript auf einen D1M WIFI BLOCK (oder Wemos D1 Mini) hoch.
2. USB vom PC trennen

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

   SDA (Controller) => D2 (D1M)

4. Drehen Sie den SPDT-Schalter auf CONFIG
5. USB mit PC verbinden
6. Starten Sie von der Arduino IDE ein Konsolenfenster mit dem richtigen COM-Port
7. Stellen Sie sicher, dass "Newline" und "9600 Baud" ausgewählt sind
8. Die Befehle werden in die Send Textbox gefolgt von der Enter-Taste eingegeben
9. Die Befehle haben das Format Zeichenbyte Byte
10. Wenn das zweite Byte (drittes Segment) nicht enthalten ist, wird 0 (Null) vom Skript gesendet
11. Seien Sie vorsichtig bei der Verwendung der seriellen Eingabe; Überprüfen Sie Ihre Eingaben, bevor Sie die Eingabetaste drücken. Wenn Sie gesperrt sind (z. B. die I2C-Adresse auf einen vergessenen Wert ändern), müssen Sie die Controller-Firmware erneut flashen.

Die unterstützten Variationen des ersten Zeichens des Befehls sind:

• E (Enable Servo Tracking) nützlich zum Stoppen der Bewegung während der Konfiguration. Dies wird eingegeben mit: E 0
• D (Servo-Tracking deaktivieren) nützlich, um das automatische Tracking zu starten, wenn das Gerät nicht neu gestartet wird. Dies wird eingegeben mit: D 0
• G (Get configuration value) liest Werte aus EEPROM und IN-MEMORY: Dies wird eingegeben mit: G (Index ist gültige Bytewerte 0 - 13 und 15)
• S (Set EEPROM value) setzt Werte im EEPROM, die nach Neustarts verfügbar sind. Dies wird eingegeben mit: S (Index ist gültige Byte-Werte 0 - 13, Wert ist gültige Byte-Werte und variiert je nach Eigenschaft)

Der Code ist der Punkt der Wahrheit für die Indizes, aber Folgendes wird als Leitfaden für gültige Werte/Kommentare verwendet:

• I2C ADDRESS 0 - Controller-Slave-Adresse, der Master benötigt diese, um mit dem Controller zu kommunizieren (Standard 10)
• MINIMUM VERTICAL ANGLE 1 - Untergrenze des vertikalen Servowinkels (Standard 10, Bereich 0 - 180)
• MAXIMALER VERTIKALER WINKEL 2 - oberer Winkel des vertikalen Servos (Standardeinstellung 170, Bereich 0 - 180)
• EMPFINDLICHKEIT VERTIKAL LDR 3 - Vertikaler LDR-Lesebereich (Standard 20, Bereich 0 - 1024)
• VERTIKALER WINKEL SCHRITT 4 - vertikale Servoschritte des Winkels bei jeder Einstellung (Standard 5, Bereich 1 - 20)
• MINIMUM HORIZONTAL ANGLE 5 - Untergrenze des horizontalen Winkelservos (Standard 10, Bereich 0 - 180)
• MAXIMALER HORIZONTALER WINKEL 6 - oberer Winkel des horizontalen Servos (Standardeinstellung 170, Bereich 0 - 180)
• EMPFINDLICHKEIT HORIZONTAL LDR 7 - Horizontaler LDR-Lesespielraum (Standard 20, Bereich 0 - 1024)
• HORIZONTALER WINKELSCHRITT 8 - horizontale Winkelservoschritte bei jeder Einstellung (Standard 5, Bereich 1 - 20)
• SCHLAFMINUTEN 9 - die ungefähre Schlafdauer zwischen den Aufzeichnungen (Standard 20, Bereich 1 - 255)
• VERTIKALER DAWN WINKEL 10 – ZUKÜNFTIGE VERWENDUNG – der vertikale Winkel, zu dem man zurückkehren kann, wenn die Sonne untergeht
• HORIZONTALER DAWN WINKEL 11 - ZUKÜNFTIGE VERWENDUNG - der horizontale Winkel, zu dem man zurückkehren kann, wenn die Sonne untergeht
• DAWN INTENSITY 12 – ZUKÜNFTIGE NUTZUNG – der minimale Durchschnitt aller LDRs, der den Start der täglichen Sonnennachführung auslöst
• DUSK INTENSITY 13 – ZUKÜNFTIGE NUTZUNG – der minimale Durchschnitt aller LDRs, der ein Ende der täglichen Sonnennachführung auslöst
• ENDE DER EEPROM-WERTE-MARKIERUNG 14 - WERT NICHT VERWENDET
• AKTUELLE INTENSITÄT 15 - der aktuelle durchschnittliche Prozentsatz der Lichtintensität
• END OF IN-MEMORY VALUES MARKER 16 - WERT NICHT VERWENDET.

Erfasst serielle Eingaben (Tastatureingaben im Konsolenfenster) und leitet sie im Format char, byte, byte an einen I2C-Slave weiter

#enthalten

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

const byte _numChars = 32;

char _receivedChars[_numChars]; // ein Array zum Speichern der empfangenen Daten

voidsetup() {

Serial.begin (9600);

Draht. Begin(D2, D1);

Verzögerung (5000);

}

Leerschleife () {

recvWithEndMarker();

parseSendCommands();

}

voidrecvWithEndMarker() {

statisches Byte 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;

}

} anders {

_receivedChars[ndx] = '\0'; // den String beenden

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands() {

if (_newData == true) {

constchar delim[2] = "";

char *token;

token = strtok(_receivedChars, delim);

char cmd = _receivedChars[0];

Byteindex = 0;

Bytewert = 0;

int i = 0;

while(token != NULL) {

//Seriell.println (Token);

i++;

Schalter (i) {

Fall 1:

Token = strtok(NULL, delim);

index = atoi (Token);

brechen;

Fall2:

Token = strtok(NULL, delim);

if (Token != NULL){

Wert = Atoi (Token);

}

brechen;

Ursprünglich:

Token = NULL;

}

}

sendCmd(cmd, Index, Wert);

_newData = false;

}

}

voidsendCmd(char cmd, Byteindex, Bytewert) {

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

Serial.println ("Befehl wird gesendet:");

Serial.println ("\t" + String (cmd) + "" + String (Index) + "" + String (Wert));

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

Wire.beginTransmission(I2C_SLAVE_ADDRESS); // zum Gerät übertragen

Wire.write (cmd); // sendet ein Zeichen

Wire.write (Index); // sendet ein Byte

Wire.write (Wert); // sendet ein Byte

Wire.endTransmission();

Byte-Antwort = 0;

bool hadResponse = false;

if (cmd == 'G'){

Wire.requestFrom(I2C_SLAVE_ADDRESS, 1);

while(Wire.available()) // Slave sendet möglicherweise weniger als angefordert

{

hadResponse = wahr;

Antwort = Wire.read();

}

if (hadResponse == true){

Serial.println ("Antwort erhalten:");

Serial.println (Antwort);

}anders{

Serial.println ("Keine Antwort, Adresse/Verbindung prüfen");

}

}

}

rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino anzeigen, gehostet mit ❤ von GitHub

Schritt 8: Nächste Schritte

Schauen Sie regelmäßig vorbei, um nach Änderungen in der Software/Hardware zu suchen.

Passen Sie die Software/Hardware an Ihre Anforderungen an.

Kommentieren Sie alle Wünsche/Optimierungen.