IOT123 - SOLÁRNÍ SLEDOVAČ - REGULÁTOR: 8 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:23

Toto je rozšíření Instructable

IOT123 - SOLÁRNÍ SLEDOVAČ - VÝKLOP/PAN, RÁM PANELU, RIG MOUNTS RIG. Zde se soustředíme na ovladač serv a senzory polohy slunce. Je důležité zdůraznit, že tento design předpokládá, že budou použity 2 MCU: jeden (3.3V 8mHz Arduino Pro Mini) pro solární tracker a jeden nezávislý MCU pro vaše senzory/herce.

Toto je verze 0.3

Spíše než publikovat všechny projekty po úplné spokojenosti, budu procvičovat kontinuální integraci a dodávat něco častěji a upravovat to, co jsem dodal, jak potřebuji. Napíšu další instrukce pro nabíječku baterií, _dokončí -li se optimalizace softwaru/hardwaru ovladače. Jak postupujeme, upozorním na to, kde jsou optimalizace potřeba.

Jedním z důvodů tohoto přístupu je zpětná vazba od klientů. Pokud vidíte potřebu nebo máte lepší přístup, vyjádřete se, ale mějte na paměti, že nemohu dodat vše a možná ani v časovém rámci, který vám vyhovuje. Protože se tato vysvětlení zdají méně relevantní, budou z tohoto článku odstraněna.

Co to zahrnuje:

1. Použijte LDR z původního Instructable ke zjištění přibližné polohy sluncí.
2. Pohybujte servy tváří ke slunci.
3. Možnosti citlivosti pohybů.
4. Možnosti velikosti kroku při pohybu na slunce.
5. Možnosti pro úhlová omezení použitá na servech.
6. Možnosti zpoždění pohybů.

7. Rozhraní I2C pro nastavení/získávání hodnot mezi MCU.

8. Hluboký spánek mezi pohyby.

Co to nezahrnuje (a bude řešeno jako časová povolení):

1. Používání energie pouze za denního světla.
2. Vzpomínka na polohu úsvitu a cesta tam za soumraku.
3. Odebrání regulátoru z MCU.
4. Deaktivace LED diod na MCU.
5. Přesměrování napájení přes VCC spíše než RAW.
6. Poskytuje řešení pro blikání bez regulovaného napájení z převodníku USB na sériový TTL.
7. Monitor napětí baterie.

DĚJINY

20. prosince 2017 V0.1 KÓD

Počáteční verze sleduje světelný zdroj, vždy zapnutý, bez nabíjení

7. ledna 2018 V0.2 KÓD

• ZMĚNY HARDWARU

  • Přidejte piny I2C
  • Přidejte přepínač do GND serv
  • Vytištěný štítek na palubní desce ovladače

• ZMĚNY SOFTWARU

  • Přečíst konfiguraci z EEPROM
  • Podpora sběrnice I2C jako slave jiného MCU (3,3 V)
  • Nastavte konfiguraci přes I2C
  • Nastavte Povoleno přes I2C
  • Získejte konfiguraci přes I2C
  • Získejte vlastnosti runtime přes I2C (aktuálně povoleno a aktuální intenzita světla)
  • Odebrat sériové protokolování (ovlivnilo hodnoty I2C)

19. ledna 2018 V0.3 KÓD

• HARDWARE

  Štítek aktualizován. Přepínač se nyní používá k výběru režimu KONFIGURACE nebo STOPY

• SOFTWARE

  • I2C slouží pouze ke konfiguraci
  • Ovladač čeká 5 sekund před inicializací sledování, umožňuje pohyb rukou
  • Chcete -li použít konfiguraci I2C, musí být SPDT na CONFIG jako bootování jednotek
  • Mezi sledováním pohybu je jednotka v režimu hlubokého spánku pro konfigurační hodnotu SLEEP MINUTES (výchozí 20 minut).

Krok 1: Materiály a nástroje

Nyní je k dispozici úplný seznam materiálů a zdrojů.

1. 3D tištěné díly.
2. Arduino Pro Mini 3,3 V 8 MHz
3. 1 univerzální oboustranná deska plošných spojů s oboustranným prototypem 4x6 cm (rozřízne se na polovinu)
4. 1 off 40P male header (to be cut to size).
5. 1 off 40P female header (to be cut to size).
6. 4 off 10K 1/4W restistors.
7. Propojovací drát.
8. Pájka a železo.
9. 20 off samořezných šroubů z nerezové oceli s hlavou 4G x 6 mm.
10. 4 ks nerezových zápustných šroubů 4G x 6 mm.
11. 1 vypnutá 3,7 V baterie LiPo a držák (zakončené 2P dupontovými konektory).
12. 1 off 2P male pravý úhel záhlaví
13. 1 vypnutý přepínač SPDT, 3 piny, rozteč 2,54 mm
14. Silné kyanoakrylátové lepidlo
15. Dupont konektory samice 1P záhlaví (1 off blue, 1 off green).

Krok 2: Sestavení obvodu

Obvod v současné době nemá obvod děliče napětí (voltmetr).

1. Univerzální desku plošných spojů s oboustranným prototypem 4x6 cm zkraťte na polovinu podél dlouhé osy.

2. Rozřízněte hlavičku 40P samce na kousky:

   1. 2 off 12P
   2. 3 vypnuto 3P
   3. 6 vypnuto 2P.

3. Rozřízněte hlavičku 40P na kousky:

   1. 2 off 12P
   2. 1 off 6P
4. Pájku 2 vypněte na hlavičce 12Pfemale podle obrázku.
5. Kyanoakrylátovým lepidlem přilepte rozpěrku odstraněnou z 3P vnějšího (dalšího) konektoru na spodní stranu přepínače SPDT
6. Na druhé straně umístěte pájku 6 off 2P, 2 off 3Pmale header a přepínač SPDT, jak je znázorněno na obrázku.
7. Pájením 4 vypněte 10K odpory (A, B, C, D černé) přes vývod na konektor GND (#2 černý) a na vývody A0 - A3 (#5, #6, #7, #8) a poté skrz otvor (žlutá), jak je znázorněno (3 fotografie + 1 diagram).
8. Zaznamenejte 3,3 V z pájecích PINŮ LDR PINS #4, #6, #8, #10 a provlékněte otvorem do feamale konektoru VCC pin (zelený).
9. Trasujte 3,3 V na straně samice záhlaví, jak je znázorněno (červené), pájení na PINS #1, #12, #15.
10. 3,3 V skrz otvor pájený přes stranu (červený) RAW záhlaví PIN #1.
11. Trasujte oranžovou přípojku od PINu č. 11 skrz otvor k pájení Zásuvka na druhé straně, jak je znázorněno na obrázku.
12. Trasujte a pájejte modrý propojovací vodič od #20 do #30 a od #31 do #13 a #16.
13. Pájecí zásuvka PIN #11 na PIN #11 konektoru propojte skrz otvor.
14. Připravte si 2 dupontní konektory o délce 30 mm se zásuvkou 1P female (1 modrá, 1 zelená). Odizolujte a opečte druhý konec.
15. Pájecí modrý vodič Dupont na #28; pájet zeleně Dupont drát na #29.
16. Na horní straně Arduina upevněte 6P zásuvku a poté pájejte.

17. Na horní straně Arduina upevněte 2P pravoúhlý konektor samice int #29 a #30 a poté pájejte.

18. Na spodní stranu Arduina upevněte 2 12P a 1 off 3P samčí piny a poté pájejte.
19. Vložte samčí 12P piny Arduino do samičích konektorů PCB 12P.

Krok 3: Blikání MCU

Arduino Pro Mini se pohodlně flashuje pomocí převaděče FTDI232 USB na TTL pomocí 6P konektoru. Zarovnání 2 desek naleznete na fotografii výše.

Ujistěte se, že je na vašem FTDI232 vybráno nastavení 3,3 V. Postupujte podle pokynů zde pomocí níže uvedeného kódu (použijte odkaz na GIST).

Je třeba nainstalovat knihovnu s nízkou spotřebou (připojenou a

Jakmile je deska Arduino Pro Mini + nainstalována v pouzdře, lze ji stále blikat, protože jsou odkryté kolíky záhlaví. Stačí odpojit řídicí jednotku od rámečku panelu, čímž se odhalí záhlaví.

Tilt pan solární tracker s konfigurací I2C/EEPROM a spánkovým cyklem mezi pohyby. Přesnost doby trvání spánkového cyklu se s rostoucí délkou snižuje, ale pro tento účel dostatečná

/*

* upraveno z kódu

* od Mathiase Leroye

*

* V0.2 ÚPRAVY

** ZÍSKEJTE I2C

** ZÍSKEJTE EEPROM

** ODSTRANIT SÉRIOVÝ VÝSTUP - OVLIVNĚNO I2C

** POVOLIT/ZAKÁZAT SLEDOVÁNÍ

** POSUNTE SLUŽBY NA OMEZENÍ PŘES I2C

** ČTĚTE AKTUÁLNÍ PRŮMĚRNOU INTENZITU POMOCÍ I2C

* V0.3 ÚPRAVY

** SPÍNAČ PRO 2 REŽIMY - TRACK (BEZ I2C) a KONFIGURACE (POUŽÍVÁ I2C)

** SPÁNEK V REŽIMU SLEDOVÁNÍ (VELMI NÍZKÁ PŘESNOST DŮVODU 8 DRUHÝCH ČÁSTÍ)

** DETACH/ATTACH SERVOS ON SLEEP/WAKE (TRANSISTOR USEN EVENTUALLY)

** ODSTRANIT KONFIGUROVATELNOU PŮVODNÍ POZICI (ZPŮSOBIT)

** ODEBRAT KONFIGUROVATELNÉ SEKUNDY PROBUZENÍ (ZPŮSOBENÉ)

** ODSTRANIT KONFIGUROVATELNÉ POVOLIT/ZAKÁZAT (ZPĚT)

** ODEBRAT KONFIGUROVATELNÝ TRACKER POVOLEN (POUŽÍVAT HARDWAROVÝ SPÍNAČ)

** ODSTRANĚTE NAPĚTÍ GETTER - BUDE POUŽÍVAT ODDĚLENÝ KOMPONENT I2C

** PŘI NEPOUŽÍVÁNÍ I2C PŘIDAT SÉRIOVOU PŘIHLÁŠENÍ

*/

#zahrnout

#zahrnout

#zahrnout

#zahrnout

#zahrnout

#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 // průměr všech LDRS

#defineIDX_DUSK_INTENSITY13 // průměr všech LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // průměr všech LDRS - používá se pro výpočet IDX_DAWN_INTENSITY ambiantní nepřímé světlo

#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 _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 ("Režim konfigurace");

Serial.print ("Adresa I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (receiveEvent);

Wire.onRequest (requestEvent);

}jiný{

Serial.println („Režim sledování“);

delay (5000); // čas dostat se z cesty při připojení baterie atd.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// ToDo: ZAPNĚTE SPÍNAČ TRANZISTORU

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

if (i! = 0) {

getLightValues ();

}

moveServos ();

}

zpoždění (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: VYPNOUT SPÍNAČ TRANZISTORU

zpoždění (500);

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

}

}

// --------------------------------- SOUČASNÝ REŽIM

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

vrátit _inConfigMode;

}

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

voidgetFromEeprom () {

li(

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

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

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

bajtová hodnota = Wire.read ();

přepínač (cmd) {

case'G ':

if (index <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [index];

}

přestávka;

případ'S ':

if (index <IDX_END_EEPROM_SET) {

_i2cVals [index] = hodnota;

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

}

přestávka;

výchozí:

vrátit se;

}

}

}

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

// jít doleva

Serial.println ("moveServos jít doleva");

delay (_slowingDelay);

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

_servoH.write (_angleH--);

zpoždění (_servoLoopDelay);

}

}

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

// jít doprava

Serial.println ("moveServos jít doleva");

delay (_slowingDelay);

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

_servoH.write (_angleH ++);

zpoždění (_servoLoopDelay);

}

}

jinak {

// nicnedělání

Serial.println ("moveServos nic nedělá");

delay (_slowingDelay);

}

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

// stoupat

Serial.println ("moveServos up up");

delay (_slowingDelay);

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

_servoV.write (_angleV ++);

zpoždění (_servoLoopDelay);

}

}

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

// klesat

Serial.println ("moveServos klesající");

delay (_slowingDelay);

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

_servoV.write (_angleV--);

zpoždění (_servoLoopDelay);

}

}

jinak {

Serial.println ("moveServos nic nedělá");

delay (_slowingDelay);

}

}

//---------------------------------SPÁT

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

zobrazit rawtilt_pan_tracker_0.3.ino hostitelem ❤ od GitHub

Krok 4: Sestavení obvodového pláště

1. Zajistěte, aby byl Ardiuno Pro Mini vložen do záhlaví na desce plošných spojů.
2. Vložte základnu skříně ovladače SOLAR TRACKER do stěn skříně řadiče SOLAR TRACKER a připevněte 2 vypouštěcími samořeznými šrouby se zápustnou hlavou 4 G x 6 mm.
3. Vložte desku Ardiuno Pro Mini + s drážkou 6P Header do prázdna v základně řadiče SOLAR TRACKER.
4. Vložte víko skříňky ovladače SOLAR TRACKER do stěn skříně ovladače SOLAR TRACKER a připevněte 2 vypouštěcími samořeznými šrouby se zapuštěnou hlavou 4G x 6 mm.
5. Upevněte sestavu na základnu rámečku panelu pomocí 4 ks nerezových zápustných šroubů 4G x 6 mm.

Krok 5: Připojení vodičů soupravy k ovladači

Příslušná připojení připravená z předchozího Instructable, jsou 4 off 2P LDR připojení a 2 off 3P připojení ze serva. Dočasné, dokud není nabíjení připraveno, je baterie. Použijte 3,7 V LiPo, který prozatím končí připojením 2P DuPont.

1. Vložte připojení LDR (bez polarity) shora:

   1. Vpravo nahoře
   2. Vlevo nahoře
   3. Vpravo dole
   4. Vlevo dole

2. Zapojte servo připojení (signálním vodičem doleva) shora:

   1. Horizontální
   2. Vertikální
3. POČKEJTE, ABYSTE PŘIPRAVENI NA TEST POTOM: Vložte 3,7V DC napájecí kabel +ve nahoře, -ve dole.

Krok 6: Testování ovladače

Jak již bylo řečeno, software nebyl optimalizován pro pracovní postup solárního nabíjení. Lze jej však testovat a upravovat pomocí přírodních (slunečních) a nepřirozených světelných zdrojů.

Pro testování sledování v kontrolovaném prostředí může být vhodné nastavit SLEEP MINUTES na nižší hodnotu (viz další krok).

Krok 7: Konfigurace přes I2C pomocí vstupu konzoly

To vysvětluje konfiguraci ovladače přes druhý MCU, zadávání nastavení do okna konzoly.

1. Nahrajte následující skript na D1M WIFI BLOCK (nebo Wemos D1 Mini).
2. Odpojte USB od PC

3. PŘIPOJENÍ PIN: -ve (ovladač) => GND (D1M)+ve (ovladač) => 3V3 (D1M) SCL (ovladač) => D1 (D1M)

   SDA (ovladač) => D2 (D1M)

4. Otočte přepínač SPDT do polohy CONFIG
5. Připojte USB k počítači
6. Z Arduino IDE spusťte okno konzoly se správným portem COM
7. Ujistěte se, že jsou vybrány „Nový řádek“a „9600 baudů“
8. Příkazy se zadávají do pole Odeslat textové pole následované klávesou Enter
9. Příkazy jsou ve formátu byte byte byte
10. Pokud není zahrnut druhý bajt (třetí segment), skript odešle 0 (nula)
11. Buďte opatrní při použití sériového vstupu; zkontrolujte, co jste zadali, než stisknete klávesu „Enter“. Pokud jste zablokováni (například změnou adresy I2C na hodnotu, kterou jste zapomněli), budete muset firmware ovladače znovu blikat.

Podporované varianty prvního znaku příkazu jsou:

• E (Povolit sledování serva) užitečné pro zastavení pohybu během konfigurace. Toto se zadává pomocí: E 0
• D (Zakázat sledování serva) užitečné pro spuštění automatického sledování, pokud nerestartujete zařízení. Toto se zadává pomocí: D 0
• G (Získat konfigurační hodnotu) čte hodnoty z EEPROM a IN -MEMORY: Toto se zadává pomocí: G (index je platný byte hodnoty 0-13 a 15)
• S (Set EEPROM value) nastavuje hodnoty na EEPROM, které jsou k dispozici po restartu. Toto se zadává pomocí: S (index jsou platné hodnoty bajtů 0-13, hodnota je platné hodnoty bajtů a liší se podle vlastnosti)

Kód je bodem pravdy pro indexy, ale jako vodítko pro platné hodnoty/komentáře slouží následující:

• I2C ADDRESS 0 - adresa slave ovladače, master to potřebuje ke komunikaci s ovladačem (výchozí 10)
• MINIMÁLNÍ VERTIKÁLNÍ ÚHEL 1 - úhel svislého spodního limitu serva (výchozí 10, rozsah 0 - 180)
• MAXIMÁLNÍ VERTIKÁLNÍ ÚHEL 2 - horní limit vertikálního serva (výchozí nastavení 170, rozsah 0 - 180)
• CITLIVOST VERTIKÁLNÍ LDR 3 - svislý okraj pro čtení LDR (výchozí 20, rozsah 0 - 1024)
• KROK VERTIKÁLNÍHO ÚHLU 4 - úhlové vertikální kroky serv při každém nastavení (výchozí 5, rozsah 1 - 20)
• MINIMÁLNÍ HORIZONTÁLNÍ ÚHEL 5 - úhel horizontálního spodního limitu servo (výchozí 10, rozsah 0 - 180)
• MAXIMÁLNÍ HORIZONTÁLNÍ ÚHEL 6 - úhel horizontální horní hranice servo (výchozí 170, rozsah 0 - 180)
• CITLIVOST HORIZONTÁLNÍ LDR 7 - horizontální okraj pro čtení LDR (výchozí 20, rozsah 0 - 1024)
• KROK HORIZONTÁLNÍ ÚHEL 8 - úhlové horizontální kroky serv při každém nastavení (výchozí 5, rozsah 1 - 20)
• SLEEP MINUTES 9 - přibližná doba spánku mezi sledováním (výchozí 20, rozsah 1 - 255)
• VERTICAL DAWN ANGLE 10 - BUDOUCÍ POUŽITÍ - svislý úhel, na který se budete vracet, když slunce zapadne
• HORIZONTÁLNÍ ÚHOL ÚHLU 11 - BUDOUCÍ POUŽITÍ - horizontální úhel, do kterého se budete vracet, když slunce zapadne
• DAWN INTENSITY 12 - BUDOUCÍ POUŽITÍ - minimální průměr všech LDR, který spouští každodenní sledování slunce
• INTENZITA DUSKU 13 - BUDOUCÍ POUŽITÍ - minimální průměr všech LDR, který spouští denní sledování slunce
• KONEC HODNOT EEPROM HODNOTY 14 - HODNOTA NEPOUŽITÁ
• SOUČASNÁ INTENZITA 15 - aktuální průměrné procento intenzity světla
• KONEC IN -MEMORY VALUES MARKER 16 - HODNOTA NEPOUŽITÁ.

Zachycuje sériový vstup (vstup z klávesnice v okně konzoly) a přeposílá jej na slave I2C ve formátu char, byte, byte

#zahrnout

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

konstantní bajt _numChars = 32;

char _receivedChars [_numChars]; // pole pro uložení přijatých dat

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

zpoždění (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

statický bajt 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;

}

} else {

_receivedChars [ndx] = '\ 0'; // ukončí řetězec

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

char *token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

byte index = 0;

bajtová hodnota = 0;

int i = 0;

while (token! = NULL) {

//Serial.println(token);

i ++;

přepínač (i) {

případ1:

token = strtok (NULL, delim);

index = atoi (token);

přestávka;

případ2:

token = strtok (NULL, delim);

if (token! = NULL) {

hodnota = atoi (token);

}

přestávka;

výchozí:

token = NULL;

}

}

sendCmd (cmd, index, hodnota);

_newData = false;

}

}

voidsendCmd (char cmd, byte byte, byte hodnota) {

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

Serial.println ("Odesílání příkazu:");

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

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // přenos do zařízení

Wire.write (cmd); // pošle znak

Wire.write (index); // odešle jeden bajt

Wire.write (hodnota); // odešle jeden bajt

Wire.endTransmission ();

byte odpověď = 0;

bool hadResponse = false;

if (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

while (Wire.available ()) // slave může odeslat méně, než je požadováno

{

hadResponse = true;

response = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Získání odpovědi:");

Serial.println (odpověď);

}jiný{

Serial.println („Žádná odpověď, zkontrolujte adresu/připojení“);

}

}

}

zobrazit rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino hostitelem ❤ od GitHub

Krok 8: Další kroky

Pravidelně kontrolujte změny softwaru/hardwaru.

Upravte software/hardware podle svých požadavků.

Komentujte všechny požadavky/optimalizace.