IOT123 - BRIQUE DE RELAIS I2C 2CH : 5 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Les BRIQUES IOT123 sont des unités modulaires de bricolage qui peuvent être mélangées avec d'autres BRIQUES IOT123, pour ajouter des fonctionnalités à un nœud ou à un appareil portable. Ils sont basés sur des protoboards double face en pouces carrés avec des trous traversants interconnectés.

Un certain nombre de ces BRICKS devraient se trouver sur plusieurs nœuds (MCU maîtres - ESP8266 ou ATTINY84) sur un site. Le MCU n'a besoin d'aucune connaissance préalable de l'objectif des capteurs ou des besoins logiciels. Il recherche les nœuds I2C puis demande un vidage des propriétés (données du capteur) à chaque esclave. Ces briques fournissent 5,0 V, 3,3 V et une autre ligne AUX personnalisable.

Cette brique de relais I2C 2CH étend les fonctionnalités de la brique I2C KY019 et possède deux propriétés de lecture/écriture:

RELAIS 2CH[0] (vrai/faux)

RELAIS 2CH[1] (vrai/faux)

Les trous traversants adjacents à l'ATTINY85 ont été laissés inutilisés, pour permettre un programmeur de broches pogo pendant que le DIP8 est soudé au PCB. Une autre abstraction, emballer les BRIQUES dans de petits cylindres qui se branchent sur un hub D1M WIFI BLOCK, pompant les valeurs vers un serveur MQTT, est en cours de développement.

Étape 1: Matériaux et outils

Il existe une liste complète de la nomenclature et de l'approvisionnement.

1. Relais 2 canaux (1)
2. ATTINY85 20PU (1)
3. 1" Protoboard double face (1)
4. Connecteur mâle 90º (3P, 3P)
5. Embase mâle (2P, 2P)
6. Shunt de cavalier (1)
7. Fil de branchement (~7)
8. Soudure et fer (1)

Étape 2: Préparez l'ATTINY85

REMARQUE: Si vous souhaitez intégrer Crouton, veuillez utiliser la bibliothèque d'ici et utiliser l'exemple installé "attiny_2ch_relay".

AttinyCore du Boards Manager est nécessaire. Gravez le bootloader "EEPROM Retained", "8mHZ Internal" (toutes les configurations présentées ci-dessus).

Le référentiel de code peut être trouvé ici.

Un ZIP de la bibliothèque peut être trouvé ici.

Instructions pour "Importer une bibliothèque ZIP" ici.

Une fois la librairie installée vous pouvez ouvrir l'exemple "attiny_2ch_relay".

Pour télécharger le firmware sur l'ATTINY85, vous pouvez trouver plus de détails dans ces instructables:

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-…

Il est préférable de tester via la maquette avant de continuer.

Si vous avez des CAPTEURS ASSIMILÉS existants, assurez-vous que l'adresse esclave est différente sur une combinaison d'hôtes CAPTEUR/MCU, c'est-à-dire que tous les acteurs relais peuvent avoir la même adresse tant que vous n'avez qu'un seul acteur relais sur un MCU/nœud.

Étape 3: Assembler le circuit

1. A l'avant, insérez les composants ATTINY85 (1), les embases mâles 3P 90deg (2)(3), les embases mâles 3P (4)(5) et soudez à l'arrière.
2. À l'arrière, tracez un fil jaune de JAUNE1 à JAUNE2 et soudez.
3. A l'arrière, tracez un fil orange d'ORANGE1 à ORANGE2 et soudez.
4. À l'arrière, tracez un fil bleu de BLUE1 à BLUE2 et soudez.
5. À l'arrière, tracez un fil vert de GREEN1 à GREEN2 et soudez.
6. A l'arrière, tracez un fil noir de NOIR1 à NOIR2 et soudez.
7. A l'arrière, tracez un fil noir de BLACK3 à BLACK4 et soudez.
8. À l'arrière, tracez un fil rouge de RED1 à RED2 et soudez.
9. À l'arrière, tracez un fil nu de RED3 à RED4 et soudez.
10. À l'arrière, tracez un fil nu de SILVER1 à SILVER2 et soudez.
11. Ajoutez un cavalier sur la ligne 5V ou 3V3.

Le relais peut maintenant être connecté directement via ses broches au PCB ou via des fils, aux points indiqués dans le contrat de broche.

Étape 4: Tester

Un certain nombre de ces BRICKS devraient se trouver sur plusieurs nœuds (MCU - ESP8266 ou ATTINY84) dans un environnement. Il s'agit d'un test unitaire: envoie des commandes I2C de l'UNO à l'ATTINY qui ouvre ou ferme les relais.

Nous avons déjà construit un I2C SHIELD pour Arduino.

Si vous souhaitez le tester à la place:

1. Connectez le 5.0V sur UNO à un VCC sur BRICK.
2. Connectez le GND sur UNO à GND sur BRICK.
3. Connectez l'A5 sur UNO à SCL sur BRICK.
4. Connectez l'A4 sur UNO à SDA sur BRICK.
5. Connectez une résistance de rappel 4K7 de SDA à VCC.
6. Connectez une résistance de rappel 4K7 de SCL à VCC.

Exécution du test

1. Connectez votre UNO à votre Dev PC avec USB.
2. Téléchargez le code à l'ONU.
3. Ouvrez la console Arduino.
4. Choisissez 9600 bauds (redémarrez l'UNO et rouvrez la console si nécessaire).
5. L'adresse de l'esclave sera imprimée sur la console.

6. Quand, entrez dans la case d'envoi 2 0:1 (donc 15 2 0:1), et le relais CH1 s'allume.

7. Quand, entrez dans la case d'envoi 2 0:0 (donc 15 2 0:0), et le relais CH1 s'éteint.
8. Lorsque, entrez dans la boîte d'envoi 2 1:1 (donc 15 2 1:1), et le relais CH2 s'allume.
9. Quand, entrez dans la case d'envoi 2 1:0 (donc 15 2 0:0), et le relais CH2 s'éteint.

Commandes I2C BRICK adhoc pour les esclaves du maître UNO

#comprendre

octet const _num_chars = 32;

char _received_chars[_num_chars]; // un tableau pour stocker les données reçues

booléen _has_new_data = false;

void setup() {

Serial.begin(9600);

Serial.println();

Serial.println("ASSIMILER L'ÉDITEUR EEPROM DE L'ACTEUR IOT/CAPTEUR");

Serial.println("assurez-vous que la nouvelle ligne est sélectionnée dans la fenêtre de la console");

Serial.println();

Serial.println("ADRESSE 1 CONFIRMER LA RECEPTION DES METADONNEES N/A (POUR M2M)");

Serial.println("ADRESSE 2 COMMANDE ACTEUR");

Serial.println();

Serial.println("ADRESSES SUR BUS:");

scan_i2c_addresses();

Serial.println();

Serial.println("");

}

voidscan_i2c_addresses(){

int device_count = 0;

pour (adresse d'octet = 8; adresse < 127; adresse++)

{

Wire.beginTransmission(adresse);

erreur d'octet const = Wire.endTransmission();

si (erreur == 0)

{

Serial.println(adresse);

}

}

}

boucle vide() {

recv_with_end_marker();

envoyer_à_i2c();

}

voidrecv_with_end_marker() {

octet statique ndx = 0;

char end_marker = '\n';

char rc;

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

rc = Serial.read();

if (rc != end_marker) {

_received_chars[ndx] = rc;

ndx++;

if (ndx >= _num_chars) {

ndx = _num_chars - 1;

}

}

autre {

_received_chars[ndx] = '\0'; // termine la chaîne

ndx = 0;

_has_new_data = vrai;

}

}

}

voidsend_to_i2c() {

char param_buf[16];

const String receive_string = String(_received_chars);

if (_has_new_data == true) {

int idx1 = receive_string.indexOf('');

Adresse de chaîne = receive_string.substring(0, idx1);

int address_int = address.toInt();

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

Serial.println("ENTREE ADRESSE INVALIDE:");

Serial.println(adresse);

revenir;

}

int idx2 = receive_string.indexOf('', idx1+1);

Code de chaîne;

si (idx2 == -1){

code = chaîne_réception.sous-chaîne(idx1+1);

}autre{

code = chaîne_réception.sous-chaîne(idx1+1, idx2+1);

}

int code_int = code.toInt();

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

Serial.println("ENTREE DE CODE INVALIDE:");

Serial.println(code);

revenir;

}

bool has_parameter = idx2 > -1;

Paramètre de chaîne;

if (a_paramètre){

paramètre = receive_string.substring(idx2 + 1, idx2 + 17); // 16 caractères max

if (paramètre.longueur() < 1){

Serial.println("PARTAMETRES MIN. LONGUEUR 1");

_has_new_data = false;

revenir;

}

}autre{

si (code_int >1){

Serial.println("PARAMETRE REQUIS !");

_has_new_data = false;

revenir;

}

}

Serial.println();

Serial.print("input orig = ");

Serial.println(received_string);

Serial.print("adresse = ");

Serial.println(adresse);

Serial.print("code = ");

Serial.println(code);

Serial.print("paramètre = ");

Serial.println(paramètre);

// ENVOYER VIA I2C

Wire.beginTransmission(address_int);

Wire.write(code_int);

if (a_paramètre){

paramètre.trim();

strcpy(param_buf, parameter.c_str());

Wire.write(param_buf);

}

Wire.endTransmission();

Serial.println();

Serial.println("ENVOYÉ VIA I2C!");

Serial.println();

Serial.println("");

_has_new_data = false;

}

}

voir rawuno_i2c_command_input.ino hébergé avec ❤ par GitHub

Étape 5: Étapes suivantes

La suite ASSIMILATE ACTOR: 2CH RELAY qui utilise cette brique a une configuration automatique pour Crouton via les métadonnées déjà installées dans l'ATTINY85 ici. Le paquet JSON envoyé à Crouton est envoyé via le dernier firmware pour l'ICOS10. Vous pouvez faire une preuve de concept sur un ESP8266 ordinaire, si la construction est trop importante pour le moment.

L'esquisse UNO utilisée dans les tests a une fonction pour enregistrer une nouvelle adresse d'esclave dans l'EEPROM sur l'ATTINY85, si vous avez un conflit sur votre bus I2C cible. Quelques schémas ont été ajoutés, mais il existe différentes manières de câbler le circuit en aval en fonction de ce que vous souhaitez réaliser, je vous laisse donc cela:)