IOT123 - I2C BRICK MASTER JIG: 4 kroki

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

Podczas opracowywania ASSIMILATE SENSORS and ACTORS mam pod ręką UNO do wysyłania adhoc poleceń I2C do opracowywanych prototypów. Jedną z zalet I2C BRICKS są znormalizowane pinouty. Zamiast używać za każdym razem przewodów płytki stykowej (patrz Fritzings), używana jest wytrzymała osłona lo-tech.

Krok 1: Materiały i narzędzia

1. PCB 4cm x 6cm (1)
2. Przewód przyłączeniowy (~6)
3. Rezystory 4K7 (2)6
4. Męski nagłówek (12P, 8P)
5. Żeński nagłówek (9P lub 3P, 3P)
6. Lut i żelazo (1)

Krok 2: Montaż

Jeśli użyjesz 2 żeńskich gniazd 3P zamiast 1 żeńskiego złącza 9P, ASSIMILATE SENSOR/ACTORS zmieści się na JIG bez ich demontażu.

Za pomocą okablowania zdejmij do 10 mm na końcach i pocynuj same końce.

1. Na spodzie płytki PCB włóż męski nagłówek (1)(2) i przylutuj od góry.
2. W górnej części PCB włóż żeński nagłówek (3) i przylutuj na dole.
3. Na górze przewlecz czerwony przewód w RED1 i RED2.
4. Na dole przewód przelotowy z RED1 do RED3.
5. Na dole przewlecz przewód z RED2 na RED5 i przylutuj.
6. Na górze przewlecz przewód z RED3 na RED4 i przylutuj.
7. Na górze przewlecz czerwony przewód w RED6 i RED7.
8. Na dole przewód przelotowy z RED6 do RED8.
9. Na dole przewlecz przewód z RED7 na RED10 i przylutuj.
10. Na górze przewlecz drut z RED8 na RED9 i przylutuj.
11. Na górze przewlecz czarny przewód w CZARNY1 i CZARNY2.
12. Na dole przewód przelotowy z BLACK1 na BLACK3.
13. Na dole przewlecz przewód z BLACK2 na BLACK5 i przylutuj.
14. Na górze przewód przewlekany z BLACK3 na BLACK4 i lut.
15. Na górze przewlecz niebieski przewód na NIEBIESKI1 i NIEBIESKI2.
16. Na dole przewód przelotowy z BLUE1 na BLUE3.
17. Na dole przewlecz przewód z BLUE2 na BLUE5 i przylutuj.
18. Na górze przewlecz z BLUE3 na BLUE4 i przylutuj.
19. Na górze przełóż zielony przewód na ZIELONY1 i ZIELONY2.
20. Na dole przewód przelotowy z ZIELONEGO1 na ZIELONY3.
21. Na spodzie przewlecz przewód z ZIELONEGO na ZIELONY5 i przylutuj.
22. Na górze przewlecz przewód z ZIELONEGO 3 na ZIELONY 4 i przylutuj.
23. Na górze przewlecz rezystor 4K7 na SILVER3 i SILVER4.
24. Na spodzie przewlecz przewód ze SILVER3 na ZIELONY5 i przylutuj.
25. Na dole przewlecz przewód ze SILVER4 na RED10 i przylutuj.
26. Na górze przewlecz rezystor 4K7 na SILVER1 i SILVER2.
27. Na dole przewlecz przewód ze SILVER1 na NIEBIESKI5 i przylutuj.
28. Na dole przewlecz przewód ze SILVER2 na RED10 i przylutuj.

Krok 3: Kod dla ONZ

Szkic tutaj jest szczątkowy. Pozwala na użycie wejścia konsoli, aby UNO wysyłało komunikaty I2C do I2C ATTINY85 BRICK.

Wszystkie instrukcje są drukowane na ekranie wraz z obsługiwanymi opcjami.

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 4: Kolejne kroki

Z przedstawionych kompilacji jest wystarczająco dużo ruchomych części, abyś mógł zbudować własną sieć ASYMILATE IOT NETWORK.

Każda z indywidualnych funkcji węzłów (czujników i aktorów) jest kontrolowana w sposób zdecentralizowany, niezależnie od tego, czy jednostka główna MCU ma jakąkolwiek wiedzę na temat obsługiwanych funkcji.

Każda aplikacja łącząca się z brokerem MQTT może kontrolować/obserwować każdą funkcję węzła IOT. To M2M, aplikacje internetowe, IFTTT i tak dalej. Znacznie prostsze (lub bogatsze, jeśli chcesz) interfejsy do Twojego świata IOT.