IOT123 - ŚLEDZENIE SŁONECZNE - STEROWNIK: 8 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

To jest rozszerzenie Instructable

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL RAMA, LDR MOUNTS RIG. Tutaj skupiamy się na sterowniku serwomechanizmów i czujnikach położenia słońca. Ważne jest, aby podkreślić, że ten projekt zakłada zastosowanie 2 MCU: jeden (3.3V 8mHz Arduino Pro Mini) dla trackera słonecznego i jeden niezależny MCU dla twoich czujników/aktorów.

To jest wersja 0.3

Zamiast publikować wszystkie projekty po pełnej satysfakcji, będę ćwiczyć ciągłą integrację i dostarczać coś częściej, modyfikując to, co dostarczyłem, zgodnie z potrzebami. Napiszę kolejną instrukcję dla ładowarki akumulatora, _kiedy_ optymalizacja oprogramowania/sprzętu kontrolera zostanie zakończona. Wskażę, gdzie potrzebne są optymalizacje, gdy będziemy przez to przechodzić.

Jednym z powodów takiego podejścia są opinie klientów. Jeśli widzicie potrzebę lub macie lepsze podejście, proszę o komentarz, ale pamiętajcie, że nie mogę dostarczyć wszystkiego i prawdopodobnie nie w odpowiednim dla was terminie. Ponieważ te wyjaśnienia wydają się mniej istotne, zostaną usunięte z tego artykułu.

Co to obejmuje:

1. Użyj LDR z oryginalnego Instructable, aby wyczuć przybliżoną lokalizację słońc.
2. Przesuń serwa w stronę słońca.
3. Opcje czułości ruchów.
4. Opcje rozmiaru kroku podczas wychodzenia na słońce.
5. Opcje ograniczeń kątowych używanych w serwomechanizmach.
6. Opcje opóźnień ruchów.
7. Interfejs I2C do ustawiania/pobierania wartości między MCU.
8. Głęboki sen między ruchami.

Czego to nie obejmuje (i zostanie rozwiązane w miarę możliwości czasu):

1. Korzystanie z zasilania tylko w ciągu dnia.
2. Zapamiętywanie pozycji świtu i pójście tam o zmierzchu.
3. Wyjmowanie regulatora z MCU.
4. Wyłączanie diod LED na MCU.
5. Przekierowanie zasilania przez VCC zamiast RAW.
6. Zapewnienie obejścia dla flashowania bez regulowanego zasilania z konwertera USB na Serial TTL.
7. Monitor napięcia akumulatora.

HISTORIA

20 grudnia 2017 V0.1 KOD

Wersja początkowa śledzi źródło światła, zawsze włączone, bez ładowania

7 stycznia 2018 V0.2 KOD

• ZMIANY SPRZĘTOWE

  • Dodaj piny I2C
  • Dodaj przełącznik do serwomechanizmu GND
  • Drukowana etykieta na konsoli skrzynki sterownika

• ZMIANY W OPROGRAMOWANIU

  • Odczytaj konfigurację z EEPROM
  • Obsługa magistrali I2C jako slave do innego MCU (3,3 V)
  • Ustaw konfigurację przez I2C
  • Ustaw Włączone przez I2C
  • Uzyskaj konfigurację przez I2C
  • Uzyskaj właściwości środowiska wykonawczego za pośrednictwem I2C (obecnie włączone i natężenie światła bieżącego)
  • Usuń logowanie szeregowe (wpłynęło to na wartości I2C)

19 stycznia 2018 V0.3 KOD

• SPRZĘT KOMPUTEROWY

  Zaktualizowano etykietę. Przełącznik jest teraz używany do wyboru trybu CONFIG lub TRACK

• OPROGRAMOWANIE

  • I2C używane tylko do konfiguracji
  • Kontroler czeka 5 sekund przed inicjalizacją śledzenia, pozwala na poruszanie rękami
  • Aby użyć konfiguracji I2C, SPDT musi być w trybie CONFIG podczas uruchamiania urządzenia
  • Pomiędzy śledzeniem ruchu urządzenie znajduje się w trybie głębokiego uśpienia dla wartości konfiguracyjnej MINUT UŚPIENIA (domyślnie 20 minut).

Krok 1: Materiały i narzędzia

Dostępna jest teraz pełna lista materiałów i źródeł.

1. Części drukowane w 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 z 4x6cm dwustronnie prototypowa płytka drukowana uniwersalna płytka drukowana (do przecięcia na pół)
4. 1 nagłówek męski 40P (do przycięcia na wymiar).
5. 1 nagłówek żeński 40P (do przycięcia na wymiar).
6. 4 rezystory 10K 1/4W.
7. Podłączyć przewód.
8. Lut i żelazo.
9. 20 szt. wkrętów samogwintujących ze stali nierdzewnej 4G x 6mm.
10. 4 wkręty samogwintujące ze stali nierdzewnej 4G x 6mm.
11. 1 szt. baterii LiPo 3,7 V i uchwytu (zakończone w złączach 2P dupont).
12. 1 szt. męski nagłówek kątowy 2P
13. 1 wyłącznik SPDT 3-stykowy raster 2,54 mm
14. Mocny klej cyjanoakrylowy
15. Złącza Dupont żeńskie 1P (1 szt. niebieskie, 1 szt. zielone).

Krok 2: Montaż obwodu

Obwód obecnie nie ma obwodu dzielnika napięcia (woltomierz).

1. Przetnij dwustronną prototypową płytkę drukowaną 4x6cm na pół na pół wzdłuż długiej osi.

2. Pokrój męski nagłówek 40P na kawałki:

   1. 2 z 12P
   2. 3 z 3P
   3. 6 z 2P.

3. Pokrój żeński nagłówek 40P na kawałki:

   1. 2 z 12P
   2. 1 z 6P
4. Przylutuj 2 z nagłówka 12Pfemale, jak pokazano.
5. Przyklej przekładkę usuniętą z męskiego nagłówka 3P (dodatkowego) na spód przełącznika SPDT za pomocą kleju cyjanoakrylowego
6. Z drugiej strony przylutuj 6 szt. 2P, 2 szt. 3Pmęski nagłówek i przełącznik SPDT, jak pokazano.
7. Przylutuj 4 rezystory 10K (A, B, C, D czarny) przez przewód do listwy GND (#2 czarny) i do pinów A0 - A3 (#5, #6, #7, #8), a następnie przez otwór (żółty) jak pokazano (3 zdjęcia + 1 schemat).
8. Prześledzić 3,3 V z kołków LDR przylutować kołki #4, #6, #8, #10 i przewlec przez otwór do kołka żeńskiego VCC (zielony).
9. Śledź 3,3 V po stronie złącza żeńskiego, jak pokazano (czerwony), lutując do STYKÓW #1, #12, #15.
10. 3,3V przez otwór lutowany z boku (czerwony) PIN nr 1 nagłówka RAW.
11. Śledź pomarańczowe połączenie od PIN #11 przez otwór do lutowania żeńskiego pinu po drugiej stronie, jak pokazano.
12. Śledzenie i lutowanie niebieskiego przewodu łączącego od #20 do #30 i od #31 do #13 i #16.
13. Przylutuj żeńskie złącze PIN #11 do męskiego złącza PIN #11 przez otwór.
14. Przygotuj 2 złącza dupontowe o długości 30 mm z żeńskim nagłówkiem 1P (1 szt. niebieski, 1 szt. zielony). Drugi koniec taśmy i cyny.
15. Przylutuj niebieski przewód Dupont do #28; przylutuj zielony drut Dupont do #29.
16. W górnej części Arduino zamocuj żeński nagłówek 6P, a następnie przylutuj.
17. W górnej części Arduino zamocuj żeński nagłówek kątowy 2P int #29 i #30, a następnie przylutuj.
18. Na spodzie Arduino przymocuj 2 piny 12P i 1 pin 3P, a następnie przylutuj.
19. Włóż męskie piny Arduino 12P do żeńskich nagłówków PCB 12P.

Krok 3: Flashowanie MCU

Arduino Pro Mini jest wygodnie flashowany za pomocą konwertera FTDI232 USB na TTL przy użyciu żeńskiego złącza 6P. Zobacz zdjęcie powyżej dla wyrównania 2 desek.

Upewnij się, że w twoim FTDI232 wybrano ustawienie 3,3 V. Postępuj zgodnie z instrukcjami, korzystając z poniższego kodu (użyj linku do GIST).

Należy zainstalować bibliotekę lowpower (w załączniku i

Po zainstalowaniu płytki drukowanej Arduino Pro Mini + w obudowie, nadal można ją flashować, ponieważ styki nagłówka są odsłonięte. Wystarczy odłączyć jednostkę sterującą od ramy panelu, odsłaniając nagłówek.

Lokalizator solarny Tilt Pan z konfiguracją I2C/EEPROM i cyklem uśpienia między ruchami. Dokładność czasu trwania cyklu snu zmniejsza się wraz ze wzrostem czasu trwania, ale wystarcza do tego celu

/*

* zmodyfikowany z kodu

* autorstwa Mathiasa Leroy

*

* MODYFIKACJE V0.2

** ZESTAW I2C POBIERZ

** ZESTAW EEPROM GET

** USUŃ WYJŚCIE SZEREGOWE - USTERKA I2C

** WŁĄCZ / WYŁĄCZ ŚLEDZENIE

** PRZESUŃ SERWA DO LIMITÓW PRZEZ I2C

** ODCZYTAJ AKTUALNĄ ŚREDNĄ INTENSYWNOŚĆ PRZEZ I2C

* MODYFIKACJE V0.3

** PRZEŁĄCZNIK NA 2 TRYBY - ŚCIEŻKA (BEZ I2C) i KONFIGURACJA (UŻYWA I2C)

** UŚPIENIE W TRYBIE TRASOWYM (BARDZO NISKA PRECYZJA ZE WZGLĘDU NA 8 SEKUNDOWYCH KAWAŁKÓW)

** ODŁĄCZ / PODŁĄCZ SERWA PODCZAS UŚPIENIA / WYBUDZENIA (W PRZYPADKU UŻYWANIA TRANZYSTORA)

** USUŃ KONFIGUROWALNĄ POZYCJĘ POCZĄTKOWĄ (NADMIAROWĄ)

** USUŃ KONFIGUROWALNE SEKUNDY WYBUDZANIA (NADMIAROWE)

** USUŃ KONFIGUROWALNE AKTYWNE/NIEAKTYWNE (NADMIAROWE)

** USUŃ KONFIGUROWALNY TRACK WŁĄCZONY (UŻYJ PRZEŁĄCZNIKA SPRZĘTOWEGO)

** USUŃ WZMACNIACZ NAPIĘCIA - BĘDZIE UŻYWAĆ ODDZIELNEGO KOMPONENTU I2C

** DODAJ REJESTROWANIE SZEREGOWE, GDY NIE UŻYWASZ I2C

*/

#włączać

#włączać

#włączać

#włączać

#włączać

#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// średnia wszystkich LDRS

#defineIDX_DUSK_INTENSITY13// średnia wszystkich LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15// średnia wszystkich LDRS - używana do obliczania światła otoczenia niebezpośredniego IDX_DAWN_INTENSITY

#defineIDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

Serwo _serwoH;

Serwo _servoV;

bajt _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_kątH = 90;

int_kątV = 90;

int _averageTop = 0;

int _średniaPrawo = 0;

int _averageBottom = 0;

int _averageLeft = 0;

bajt _i2cOdpowiedź = 0;

bool _inConfigMode = false;

voidsetup()

{

Serial.początek(115200);

pobierzOdEeprom();

if (inConfigMode()){

Serial.println("Tryb konfiguracji");

Serial.print("Adres I2C: ");

Serial.println(_i2cVals[IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive(odbierzZdarzenie);

Wire.onRequest(requestEvent);

}w przeciwnym razie{

Serial.println("Tryb śledzenia");

opóźnienie (5000);// czas na usunięcie rąk z drogi, jeśli podłączasz baterię itp.

}

}

pętla pustej()

{

getLightValues();

jeśli (!_inConfigMode){

// Do zrobienia: WŁĄCZ PRZEŁĄCZNIK TRANZYSTOROWY

_servoH.attach(PIN_SERVO_H);

_servoV.attach(PIN_SERVO_V);

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

jeśli (i != 0){

getLightValues();

}

przesuńSerwa();

}

opóźnienie (500);

_serwoH.odłącz();

_servoV.detach();

// Do zrobienia: WYŁĄCZ PRZEŁĄCZNIK TRANZYSTOROWY

opóźnienie (500);

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

}

}

//---------------------------------AKTUALNY TRYB

boolinConfigMode(){

pinMode (PIN_SERVO_H, WEJŚCIE);

_inConfigMode = digitalRead(PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom(){

Jeś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_konfiguracja_odczytu();

}

voidEEPROM_write_default_configuration(){

Serial.println("EEPROM_write_default_configuration");

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

EEPROM.update(i, _i2cVals);

}

EEPROM.update(IDX_SIGN_1, 'S');

Aktualizacja EEPROM (IDX_SIGN_2, 'T');

Aktualizacja EEPROM (IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration(){

Serial.println("Konfiguracja_odczytu_EEPROM");

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

_i2cVals = EEPROM.odczyt(i);

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

}

}

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

voidreceiveEvent(liczba int) {

jeśli (liczba == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read();

indeks bajtów = Wire.read();

wartość bajtu = Wire.read();

przełącznik (cmd) {

przypadek „G”:

if (indeks< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals[indeks];

}

przerwa;

sprawy':

if (indeks< IDX_END_EEPROM_SET){

_i2cVals[indeks] = wartość;

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

}

przerwa;

domyślny:

powrót;

}

}

}

voidrequestZdarzenie()

{

Wire.write(_i2cResponse);

}

//---------------------------------LDR

voidgetLightValues(){

int wartośćTopLeft = analogRead(PIN_LDR_TL);

int wartośćTopRight = analogRead(PIN_LDR_TR);

int wartośćBottomRight = analogRead(PIN_LDR_BR);

int wartośćBottomLeft = analogRead(PIN_LDR_BL);

_averageTop = (valueTopLeft + valueTopRight) / 2;

_średniaPrawa = (wartośćPrawa górna + wartośćPrawa dolna) / 2;

_averageBottom = (wartośćBottomRight + wartośćBottomLeft) / 2;

_averageLeft = (wartośćBottomLeft + wartośćTopLeft) / 2;

int avgIntensity = (wartośćGóraLeft + wartośćGóraPrawa + wartośćDółPrawo + wartośćDółLeft) / 4;

_i2cVals[IDX_CURRENT_INTENSITY] = map(avgIntensity, 0, 1024, 0, 255);

}

//---------------------------------SERWA

voidmoveServos(){

Serial.println("przenieśSerwa");

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

// idąc w lewo

Serial.println("moveServos idąc w lewo");

opóźnienie(_slowingDelay);

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

_servoH.write(_angleH--);

opóźnienie(_servoLoopDelay);

}

}

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

// idąc w prawo

Serial.println("moveServos idąc w lewo");

opóźnienie(_slowingDelay);

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

_servoH.write(_angleH++);

opóźnienie(_servoLoopDelay);

}

}

w przeciwnym razie {

// nic nie robić

Serial.println("moveServos nic nie robią");

opóźnienie(_slowingDelay);

}

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

// idąc w górę

Serial.println("moveServos rośnie");

opóźnienie(_slowingDelay);

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

_servoV.write(_angleV++);

opóźnienie(_servoLoopDelay);

}

}

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

// zejście

Serial.println("moveServos spada");

opóźnienie(_slowingDelay);

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

_servoV.write(_angleV--);

opóźnienie(_servoLoopDelay);

}

}

w przeciwnym razie {

Serial.println("moveServos nic nie robią");

opóźnienie(_slowingDelay);

}

}

//---------------------------------SPAĆ

voidasleepFor(unsignedint eightSecondSegments){

Serial.println("śpiącyDla");

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

{

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

zobacz rawtilt_pan_tracker_0.3.ino hostowane z ❤ przez GitHub

Krok 4: Montaż obudowy obwodu

1. Upewnij się, że Ardiuno Pro Mini jest włożony do nagłówków na płytce drukowanej.
2. Włóż podstawę skrzynki sterownika SOLAR TRACKER do ścianek skrzynki sterownika SOLAR TRACKER i przymocuj 2 nierdzewnymi wkrętami samogwintującymi z łbem stożkowym 4G x 6mm.
3. Włóż Ardiuno Pro Mini + PCB z gniazdem 6P Header do pustej przestrzeni w podstawie skrzynki sterownika SOLAR TRACKER.
4. Włóż pokrywę skrzynki sterownika SOLAR TRACKER do ścianek skrzynki sterownika SOLAR TRACKER i przymocuj 2 nierdzewnymi wkrętami samogwintującymi z łbem stożkowym 4G x 6mm.
5. Przymocuj zespół powyżej do podstawy ramy panelu za pomocą 4 samogwintujących wkrętów 4G x 6mm ze stali nierdzewnej.

Krok 5: Podłączanie przewodów rigu do kontrolera

Odpowiednie połączenia gotowe z poprzedniego Instructable to 4 połączenia 2P LDR i 2 połączenia 3P z serw. Tym, co jest tymczasowe, dopóki ładowanie nie będzie gotowe, jest bateria. Użyj na razie LiPo 3,7 V, które kończy się w połączeniu 2P DuPont.

1. Włóż połączenia LDR (bez polaryzacji) od góry:

   1. W prawym górnym rogu
   2. U góry z lewej
   3. Prawy dolny
   4. Na dole po lewej

2. Włóż połączenia Servo (z przewodem sygnałowym po lewej stronie) od góry:

   1. Poziomy
   2. Pionowy
3. POCZEKAJ, AŻ GOTOWY DO TESTU NASTĘPNIE: Podłącz przewód zasilający 3,7 V DC +ve do góry, -ve do dołu.

Krok 6: Testowanie kontrolera

Jak wspomniano wcześniej, oprogramowanie nie zostało zoptymalizowane pod kątem przepływu pracy ładowania słonecznego. Można go jednak testować i modyfikować przy użyciu naturalnych (słońce) i nienaturalnych źródeł światła.

Aby przetestować śledzenie w kontrolowanym środowisku, może być wygodne ustawienie MINUT UŚPIENIA na niższą wartość (patrz następny krok).

Krok 7: Konfiguracja przez I2C przy użyciu wejścia konsoli

Wyjaśnia to konfigurowanie kontrolera za pomocą drugiego MCU, wprowadzanie ustawień w oknie konsoli.

1. Prześlij następujący skrypt do D1M WIFI BLOCK (lub Wemos D1 Mini).
2. Odłącz USB od komputera

3. POŁĄCZENIA PIN:-ve (Kontroler) => GND (D1M)+ve (Kontroler) => 3V3 (D1M)SCL (Kontroler) => D1 (D1M)

   SDA (kontroler) => D2 (D1M)

4. Ustaw przełącznik SPDT w pozycji CONFIG
5. Podłącz USB do komputera
6. Z Arduino IDE uruchom okno konsoli z odpowiednim portem COM
7. Upewnij się, że wybrano „Nowa linia” i „9600 bodów”
8. Polecenia są wprowadzane w polu Wyślij tekst, a następnie klawisz Enter
9. Polecenia są w formacie znak bajt bajt
10. Jeśli drugi bajt (trzeci segment) nie jest uwzględniony, 0 (zero) jest wysyłane przez skrypt
11. Zachowaj ostrożność podczas korzystania z wejścia szeregowego; przejrzyj wprowadzone dane przed naciśnięciem klawisza „Enter”. Jeśli jesteś zablokowany (na przykład zmiana adresu I2C na wartość, o której zapomniałeś), będziesz musiał ponownie sflashować oprogramowanie kontrolera.

Obsługiwane odmiany pierwszego znaku polecenia to:

• E (Włącz śledzenie serwomechanizmu) przydatne do zatrzymywania ruchu podczas konfiguracji. Jest to wprowadzane za pomocą: E 0
• D (Wyłącz śledzenie serwa) przydatne do rozpoczęcia automatycznego śledzenia, jeśli urządzenie nie jest ponownie uruchamiane. Jest to wprowadzane za pomocą: D 0
• G (Get configuration value) odczytuje wartości z EEPROM i IN-MEMORY: To jest wprowadzane za pomocą: G (indeks jest prawidłowymi wartościami bajtów 0 - 13 i 15)
• S (Set EEPROM value) ustawia wartości EEPROM, które są dostępne po ponownym uruchomieniu. Jest to wprowadzane za pomocą: S (indeks jest poprawnymi wartościami bajtów od 0 do 13, wartość jest poprawnymi wartościami bajtów i zmienia się w zależności od właściwości)

Kod jest punktem prawdy dla indeksów, ale poniższy jest używany jako przewodnik dla poprawnych wartości/komentarzy:

• ADRES I2C 0 - adres podrzędny kontrolera, master potrzebuje tego do komunikacji z kontrolerem (domyślnie 10)
• MINIMUM VERTICAL ANGLE 1 - dolna granica pionowego serwomechanizmu kąta (domyślnie 10, zakres 0 - 180)
• MAKSYMALNY KĄT PIONOWY 2 - górny limit kąta pionowego serwa (domyślnie 170, zakres 0 - 180)
• CZUŁOŚĆ PIONOWY LDR 3 - Pionowy margines odczytu LDR (domyślnie 20, zakres 0 - 1024)
• VERTICAL ANGLE STEP 4 - kątowe pionowe kroki serwa przy każdej regulacji (domyślnie 5, zakres 1 - 20)
• MINIMALNY KĄT POZIOMY 5 - dolny limit kąta poziomego serwa (domyślnie 10, zakres 0 - 180)
• MAKSYMALNY KĄT POZIOMY 6 - górna granica serwomechanizmu w poziomie (domyślnie 170, zakres 0 - 180)
• CZUŁOŚĆ POZIOMA LDR 7 - Margines odczytu poziomego LDR (domyślnie 20, zakres 0 - 1024)
• KĄT POZIOMY KROK 8 - poziomy serwomechanizmu pod kątem przy każdej regulacji (domyślnie 5, zakres 1 - 20)
• MINUT UŚPIENIA 9 - przybliżony okres snu między śledzeniem (domyślnie 20, zakres 1 - 255)
• PIONOWY KĄT ŚWITOWY 10 - PRZYSZŁOŚĆ - kąt w pionie, do którego wracamy po zachodzie słońca
• HORYZONTALNY KĄT ŚWIATU 11 - PRZYSZŁOŚĆ - kąt poziomy, do którego wracamy po zachodzie słońca
• INTENSYWNOŚĆ ŚWITU 12 - WYKORZYSTANIE W PRZYSZŁOŚCI - minimalna średnia ze wszystkich wskaźników LDR, która powoduje rozpoczęcie codziennego śledzenia słońca
• INTENSYWNOŚĆ ZMIERZCHU 13 - WYKORZYSTANIE W PRZYSZŁOŚCI - minimalna średnia ze wszystkich wskaźników LDR, która powoduje zakończenie codziennego śledzenia słońca
• KONIEC WARTOŚCI EEPROM ZNACZNIK 14 - WARTOŚĆ NIEUŻYWANA
• NATĘŻENIE PRĄDU 15 - aktualny średni procent natężenia światła
• ZNACZNIK KONIEC WARTOŚCI W PAMIĘCI 16 - WARTOŚĆ NIEUŻYWANA.

Przechwytuje wejście szeregowe (wejście z klawiatury w oknie konsoli) i przekazuje je do urządzenia podrzędnego I2C w formacie char, byte, byte

#włączać

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

wartość logiczna _newData = fałsz;

stały bajt _numChars = 32;

char _receivedChars[_numChars]; // tablica do przechowywania otrzymanych danych

voidsetup() {

Serial.początek(9600);

Drut.początek(D2, D1);

opóźnienie(5000);

}

voidloop() {

recvWithEndMarker();

parseSendCommands();

}

voidrecvWithEndMarker() {

bajt statyczny ndx = 0;

char endMarker = '\n';

char rc;

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

rc = Serial.odczyt();

if (rc != endMarker) {

_otrzymaneZnaki[ndx] = rc;

ndx++;

if (ndx >= _numChars) {

ndx = _numChars - 1;

}

} w przeciwnym razie {

_receivedChars[ndx] = '\0'; // zakończ ciąg

ndx = 0;

_noweDane = prawda;

}

}

}

voidparseSendCommands() {

if (_newData == prawda) {

constchar delim[2] = "";

char *token;

token = strtok(_receivedChars, delim);

char cmd = _otrzymaneChars[0];

indeks bajtów = 0;

wartość bajtu = 0;

int i = 0;

while(token != NULL) {

//Serial.println(token);

i++;

przełącznik (i){

przypadek 1:

token = strtok(NULL, delim);

indeks = atoi(token);

przerwa;

sprawa2:

token = strtok(NULL, delim);

if (token != NULL){

wartość = atoi(token);

}

przerwa;

domyślny:

token = NULL;

}

}

sendCmd(cmd, indeks, wartość);

_noweDane = fałsz;

}

}

voidsendCmd(char cmd, indeks bajtów, wartość bajtu) {

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

Serial.println("Wysyłanie polecenia:");

Serial.println("\t" + String(cmd) + "" + String(indeks) + "" + String(wartość));

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

Wire.beginTransmission(I2C_SLAVE_ADDRESS); // prześlij do urządzenia

Wire.write(cmd); // wysyła znak

Wire.write(indeks); // wysyła jeden bajt

Wire.write(wartość); // wysyła jeden bajt

Wire.endTransmission();

odpowiedź bajtu = 0;

bool hadResponse = false;

jeśli (cmd == 'G'){

Wire.requestFrom(I2C_SLAVE_ADDRESS, 1);

while(Wire.available()) // slave może wysłać mniej niż żądano

{

hadResponse = prawda;

odpowiedź = Wire.read();

}

if (hadResponse == true){

Serial.println("Otrzymywanie odpowiedzi:");

Serial.println(odpowiedź);

}w przeciwnym razie{

Serial.println("Brak odpowiedzi, sprawdź adres/połączenie");

}

}

}

zobacz rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino hostowane z ❤ przez GitHub

Krok 8: Kolejne kroki

Sprawdzaj okresowo, aby sprawdzić zmiany oprogramowania/sprzętu.

Dostosuj oprogramowanie/sprzęt do swoich wymagań.

Komentuj wszelkie prośby/optymalizacje.