IOT123 - BRIQUE HEARTBEAT I2C : 6 étapes

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 I2C HEARTBEAT BRICK indique si l'esclave ATTINY est vivant, ainsi que le trafic I2C, et a une propriété:

STATUT ("VIVANT")

PB1 (blanc) indique la santé ATTINY.

PB3 (jaune) bascule avec les requêtes I2C du maître.

PB4 (orange) bascule avec la réception I2C du maître.

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. PCB papier (7 x 7 trous)
2. LED (rouge, vert, bleu)
3. Résistances (3 sur 1K)
4. ATTINY85 20PU (1)
5. 1" Protoboard double face (1)
6. Connecteur mâle 90º (3P, 3P)
7. Embase mâle (2P, 2P)
8. Shunt de cavalier (1)
9. Fil de branchement (~7)
10. 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_heartbeat"

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 bibliothèque installée, vous pouvez ouvrir l'exemple "attiny_heartbeat".

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

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

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

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

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

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, par ex. 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: Assemblage des indicateurs

Les indicateurs sont censés être entièrement personnalisables. Ce sont les signaux d'événement du circuit principal qui sont considérés comme des battements de cœur. Pour cette construction, nous utiliserons des indicateurs LED; votre build peut utiliser des relais (oui, le VCC est éclaté) ou un autre indicateur visuel/signal. Les valeurs de résistance dépendront de vos préférences personnelles quant à la luminosité souhaitée.

1. En haut, insérez une LED bleue dans RED1 (+) et BLACK1 (G), et soudez en bas.
2. En bas, pliez le fil de RED1 de manière à ce qu'il touche le tampon de cuivre sur SILVER8 et coupez.
3. En bas, coupez le plomb de BLACK1 au-dessus de la soudure.
4. En haut, insérez une LED verte dans RED2 (+) et BLACK2 (G), et soudez en bas.
5. En bas, pliez le fil de RED2 de manière à ce qu'il touche le tampon de cuivre sur SILVER9 et coupez.
6. En bas, coupez le plomb de BLACK2 au-dessus de la soudure.
7. En haut, insérez une LED rouge dans RED3 (+) et BLACK3 (G), et soudez en bas.
8. En bas, pliez le fil de RED3 de manière à ce qu'il touche le tampon de cuivre sur SILVER10 et coupez.
9. En bas, coupez le plomb de BLACK3 au-dessus de la soudure.
10. En haut, insérez une résistance de 1K dans les trous traversants SILVER1 et SILVER4.
11. En bas, tracez, coupez et soudez le fil de SILVER1 sur BLACK1.
12. En haut, insérez une résistance de 1K dans les trous traversants SILVER2 et SILVER4.
13. En bas, tracez, coupez et soudez le fil de SILVER2 sur BLACK2.
14. En haut, insérez une résistance de 1K dans les trous traversants SILVER3 et SILVER4.
15. En bas, tracez, coupez et soudez le fil de SILVER3 sur BLACK3.
16. En bas, soudez les fils sur SILVER4 et coupez à environ 5 mm d'extension.
17. En bas, soudez un fil noir sur SILVER4.
18. En bas, soudez un fil blanc dans SILVER5, assurant la continuité au fil de RED1.
19. En bas, soudez un fil jaune dans SILVER6, assurant la continuité au fil de RED2.
20. En bas, soudez un fil orange dans SILVER7, assurant la continuité au fil de RED3.

Étape 4: Assemblage du circuit principal

Assemblée:

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. À l'arrière, tracez un fil blanc de WHITE1 à WHITE2 et soudez.
7. A l'arrière, tracez un fil noir de NOIR1 à NOIR2 et soudez.
8. A l'arrière, tracez un fil noir de BLACK3 à BLACK4 et soudez.
9. À l'arrière, tracez un fil rouge de RED1 à RED2 et soudez.
10. À l'arrière, tracez un fil nu de RED3 à RED4 et soudez.
11. À l'arrière, tracez un fil nu de SILVER1 à SILVER2 et soudez.
12. Ajoutez un cavalier sur la ligne 5V ou 3V3.

Si vous utilisez les indicateurs ci-dessus (reportez-vous au schéma de brochage):

1. À l'arrière, soudez le fil blanc dans PB1.
2. À l'arrière, soudez le fil jaune dans PB3.
3. À l'arrière, soudez le fil orange dans PB4.
4. À l'arrière, soudez le fil noir dans GND.

Étape 5: 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 fait basculer la LED de réception. La LED ATTINY ALIVE reste allumée.

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. Lorsque, entrez dans la boîte d'envoi 2 1 (donc 16 2 1), et la LED de réception s'allume.
7. Quand, entrez dans la case d'envoi 2 0 (donc 16 2 0), et la LED de réception 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 6: Étapes suivantes

La suite ASSIMILATE ACTOR: HEARTBEAT 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.