IOT123 - CEGŁA PRZEKAŹNIKA 2CH I2C: 5 kroków (ze zdjęciami)

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

KLOCKI IOT123 to modułowe jednostki DIY, które można łączyć z innymi KLOCKAMI IOT123, aby dodać funkcjonalność do węzła lub urządzenia do noszenia. Oparte są na calowych kwadratowych, dwustronnych płytach prototypowych z połączonymi ze sobą otworami przelotowymi.

Oczekuje się, że wiele z tych KLOCKÓW będzie znajdować się w wielu węzłach (główne MCU - ESP8266 lub ATTINY84) w witrynie. MCU nie wymaga wcześniejszej wiedzy na temat przeznaczenia czujników ani potrzeb oprogramowania. Skanuje w poszukiwaniu węzłów I2C, a następnie żąda zrzutu właściwości (danych z czujnika) od każdego urządzenia podrzędnego. Te cegiełki dostarczają 5,0 V, 3,3 V i inną linię AUX, którą można dostosować.

Ten I2C 2CH RELAY BRICK rozszerza funkcjonalność I2C KY019 BRICK i ma dwie właściwości odczytu/zapisu:

PRZEKAŹNIKI 2CH[0] (prawda/fałsz)

PRZEKAŹNIKI 2CH[1] (prawda/fałsz)

Otwory przelotowe przylegające do ATTINY85 pozostały niewykorzystane, aby umożliwić programowanie pinów pogo podczas lutowania DIP8 do płytki drukowanej. Opracowywana jest kolejna abstrakcja, pakowanie CEGŁY w małe cylindry, które podłącza się do koncentratora D1M WIFI BLOCK, pompując wartości do serwera MQTT.

Krok 1: Materiały i narzędzia

Istnieje pełna lista Bill of Material and Sourcing.

1. Przekaźnik 2-kanałowy (1)
2. ATTINY85 20PU (1)
3. Dwustronna płyta prototypowa 1" (1)
4. Kolektor męski 90º (3P, 3P)
5. Męski nagłówek (2P, 2P)
6. Bocznik zworki (1)
7. Przewód przyłączeniowy (~7)
8. Lut i żelazo (1)

Krok 2: Przygotuj ATTINY85

UWAGA: Jeśli zamierzasz zintegrować Crouton, skorzystaj z biblioteki stąd i użyj przykładu zainstalowanego "attiny_2ch_relay".

Potrzebny jest AttinyCore od Boards Manager. Wypal bootloader "EEPROM Retained", "8mHZ Internal" (wszystkie konfiguracje pokazane powyżej).

Repozytorium kodu można znaleźć tutaj.

ZIP biblioteki można znaleźć tutaj.

Instrukcje dotyczące „Importowania biblioteki ZIP” znajdują się tutaj.

Po zainstalowaniu biblioteki możesz otworzyć przykład "attiny_2ch_relay".

Aby przesłać oprogramowanie układowe do ATTINY85, możesz znaleźć więcej informacji w tych instrukcjach:

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/Programming-the-…

Najlepiej przetestować za pomocą płytki prototypowej przed kontynuowaniem.

Jeśli masz istniejące ASSIMILATE SENSORS, upewnij się, że adres slave jest inny w kombinacji hosta CZUJNIK/MCU, tj. wszyscy aktorzy przekaźnika mogą mieć ten sam adres, o ile masz tylko jednego aktora przekaźnika na MCU/węźle.

Krok 3: Złóż obwód

1. Z przodu włóż komponenty ATTINY85 (1), złącza męskie 3P 90deg (2)(3), złącza męskie 3P (4)(5) i przylutuj z tyłu.
2. Z tyłu prześledź żółty przewód od ŻÓŁTEGO1 do ŻÓŁTEGO2 i przylutuj.
3. Z tyłu prześledź pomarańczowy przewód od ORANGE1 do ORANGE2 i przylutuj.
4. Z tyłu prześledź niebieski przewód od BLUE1 do BLUE2 i przylutuj.
5. Z tyłu prześledź zielony przewód od ZIELONEGO1 do ZIELONEGO2 i przylutuj.
6. Z tyłu prześledź czarny przewód od BLACK1 do BLACK2 i przylutuj.
7. Z tyłu prześledź czarny przewód od BLACK3 do BLACK4 i przylutuj.
8. Z tyłu prześledź czerwony przewód od RED1 do RED2 i przylutuj.
9. Z tyłu prześledź goły przewód od RED3 do RED4 i przylutuj.
10. Z tyłu prześledź goły drut od SILVER1 do SILVER2 i lut.
11. Dodaj zworkę na linii 5V lub 3V3.

Przekaźnik można teraz podłączyć bezpośrednio za pomocą swoich pinów do płytki drukowanej lub za pomocą przewodów do punktów pokazanych w umowie pinów.

Krok 4: Testowanie

Oczekuje się, że wiele z tych KLOCKÓW będzie znajdować się na wielu węzłach (MCU - ESP8266 lub ATTINY84) w środowisku. To jest test jednostkowy: wysyła polecenia I2C z UNO do ATTINY, który otwiera lub zamyka przekaźniki.

Wcześniej zbudowaliśmy I2C SHIELD dla Arduino.

Jeśli zamiast tego chcesz to zrobić:

1. Podłącz 5.0V na UNO do VCC na BRICK.
2. Podłącz GND na UNO do GND na BRICK.
3. Podłącz A5 na UNO do SCL na BRICK.
4. Podłącz A4 na UNO do SDA na BRICK.
5. Podłącz rezystor podciągający 4K7 z SDA do VCC.
6. Podłącz rezystor podciągający 4K7 z SCL do VCC.

Przeprowadzenie testu

1. Podłącz UNO do swojego Dev PC za pomocą USB.
2. Prześlij kod do UNO.
3. Otwórz konsolę Arduino.
4. Wybierz 9600 bodów (zrestartuj UNO i ponownie otwórz konsolę, jeśli musisz).
5. Adres urządzenia podrzędnego zostanie wydrukowany na konsoli.

6. Gdy, wpisz w polu wysyłania 2 0:1 (czyli 15 2 0:1), a przekaźnik CH1 włączy się.

7. Gdy w polu wysyłania wpisujemy 2 0:0 (czyli 15 2 0:0), a przekaźnik CH1 wyłącza się.
8. Gdy, wpisz w polu wysyłania 2 1:1 (czyli 15 2 1:1), a przekaźnik CH2 się włączy.
9. Gdy w polu wysyłania wpisujemy 2 1:0 (czyli 15 2 0:0), a przekaźnik CH2 wyłącza się.

Polecenia adhoc I2C BRICK dla urządzeń podrzędnych z mastera UNO

#włączać

stały bajt _liczba_znaków = 32;

char _otrzymane_znaki[_liczba_znaków]; // tablica do przechowywania otrzymanych danych

wartość logiczna _ma_nowe_dane = fałsz;

voidsetup() {

Serial.początek(9600);

Serial.println();

Serial.println("ASYMILACJA AKTORA IOT/EDYTOR CZUJNIKA EEPROM");

Serial.println("zapewnij zaznaczenie nowej linii w oknie konsoli");

Serial.println();

Serial.println("ADRES 1 POTWIERDŹ POTWIERDZENIE METADANYCH NIE DOTYCZY (DLA M2M)");

Serial.println("POLECENIE AKTORA DLA ADRESU 2");

Serial.println();

Serial.println("ADRESY W BUS:");

scan_i2c_addresses();

Serial.println();

Serial.println("");

}

voidscan_i2c_addresses(){

int liczba_urządzeń = 0;

for (adres bajtu = 8; adres < 127; adres++)

{

Wire.beginTransmisja(adres);

błąd const byte = Wire.endTransmission();

jeśli (błąd == 0)

{

Serial.println(adres);

}

}

}

voidloop() {

recv_with_end_marker();

wyślij_do_i2c();

}

voidrecv_with_end_marker() {

bajt statyczny ndx = 0;

char end_marker = '\n';

char rc;

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

rc = Serial.odczyt();

if (rc != end_marker) {

_otrzymane_znaki[ndx] = rc;

ndx++;

if (ndx >= _liczba_znaków) {

ndx = _liczba_znaków - 1;

}

}

w przeciwnym razie {

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

ndx = 0;

_ma_nowe_dane = prawda;

}

}

}

voidsend_to_i2c() {

char param_buf[16];

const String odebrany_string = String(_otrzymane_znaki);

jeśli (_has_new_data == prawda) {

int idx1 = odebrany_ciąg.indexOf('');

Adres ciągu = odebrany_ciąg.substring(0, idx1);

int adres_int = adres.toInt();

if (adres_int < 8 || adres_int >127){

Serial.println("NIEPRAWIDŁOWE WPROWADZENIE ADRESU:");

Serial.println(adres);

powrót;

}

int idx2 = odebrany_ciąg.indexOf('', idx1+1);

Kod ciągu;

jeśli (idx2 == -1){

kod = odebrany_ciąg.podciąg(idx1+1);

}w przeciwnym razie{

kod = odebrany_ciąg.podciąg(idx1+1, idx2+1);

}

int kod_int = kod.toInt();

if (kod_int < 0 || code_int >5){

Serial.println("WPROWADZONY NIEPRAWIDŁOWY KOD:");

Serial.println(kod);

powrót;

}

bool has_parameter = idx2 > -1;

parametr ciągu;

jeśli (ma_parametr){

parametr = odebrany_ciąg.substring(idx2 + 1, idx2 + 17); // maks. 16 znaków

if (parametr.długość() < 1){

Serial.println("MIN. DŁUGOŚĆ PARTAMENTU 1");

_ma_nowe_dane = fałsz;

powrót;

}

}w przeciwnym razie{

jeśli (kod_int >1){

Serial.println("WYMAGANY PARAMETR!");

_ma_nowe_dane = fałsz;

powrót;

}

}

Serial.println();

Serial.print("input orig = ");

Serial.println(otrzymany_ciąg);

Serial.print("adres = ");

Serial.println(adres);

Serial.print("kod = ");

Serial.println(kod);

Serial.print("parametr = ");

Serial.println(parametr);

// WYŚLIJ PRZEZ I2C

Wire.beginTransmission(adres_int);

Wire.write(kod_int);

jeśli (ma_parametr){

parametr.przycinanie();

strcpy(param_buf, parametr.c_str());

Wire.write(param_buf);

}

Wire.endTransmission();

Serial.println();

Serial.println("WYSŁANE PRZEZ I2C!");

Serial.println();

Serial.println("");

_ma_nowe_dane = fałsz;

}

}

zobacz rawuno_i2c_command_input.ino hostowane z ❤ przez GitHub

Krok 5: Kolejne kroki

Kontynuacja ASIMILATE ACTOR: 2CH RELAY, która wykorzystuje tę cegłę, ma automatyczną konfigurację dla Croutona za pomocą metadanych już zainstalowanych w ATTINY85 tutaj. Pakiet JSON wysłany do Croutona jest wysyłany za pośrednictwem najnowszego oprogramowania układowego dla ICOS10. Możesz zrobić dowód koncepcji na zwykłym ESP8266, jeśli kompilacja to na razie za dużo.

Szkic UNO używany w testowaniu ma funkcję zapisywania nowego adresu urządzenia podrzędnego w pamięci EEPROM na ATTINY85, jeśli wystąpi konflikt na docelowej magistrali I2C. Dodano kilka schematów, ale są różne sposoby okablowania obwodu odpływowego w zależności od tego, co chcesz osiągnąć, więc zostawię to dla Ciebie:)