IOT123 - I2C BRICK MASTER JIG : 4 étapes

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

Lors du développement des CAPTEURS ASSIMILÉS et des ACTEURS, je garde un UNO à portée de main pour envoyer des commandes I2C adhoc aux prototypes en cours de développement. L'un des avantages des BRICKS I2C est le brochage standardisé. Plutôt que d'utiliser des fils de planche à pain à chaque fois (voir les Fritzings), un robuste bouclier lo-tech est utilisé.

Étape 1: Matériaux et outils

1. PCB Uninersal 4cm x 6cm (1)
2. Fil de branchement (~6)
3. Résistances 4K7 (2)6
4. Embase mâle (12P, 8P)
5. Embase femelle (9P, ou 3P, 3P)
6. Soudure et fer (1)

Étape 2: Assemblage

Si vous utilisez 2 connecteurs femelles 3P au lieu de 1 connecteur femelle 9P, les CAPTEURS/ACTEURS ASSIMILÉS s'adapteront au JIG sans les démonter.

Avec le câblage, dénudez jusqu'à 10 mm aux extrémités et étamez les extrémités.

1. Au bas du PCB, insérez le connecteur mâle (1) (2) et soudez sur le dessus.
2. En haut du PCB, insérez l'embase femelle (3) et soudez en bas.
3. Sur le dessus, traversez un fil rouge dans RED1 et RED2.
4. En bas, fil traversant de RED1 à RED3.
5. En bas, fil traversant de RED2 à RED5, et soudure.
6. Sur le dessus, fil traversant de RED3 vers RED4, et soudure.
7. Sur le dessus, traversez un fil rouge dans RED6 et RED7.
8. En bas, fil traversant de RED6 à RED8.
9. En bas, fil traversant de RED7 à RED10, et soudure.
10. Sur le dessus, fil traversant de RED8 vers RED9, et soudure.
11. Sur le dessus, traversez un fil noir dans BLACK1 et BLACK2.
12. En bas, fil traversant de BLACK1 à BLACK3.
13. En bas, fil traversant de BLACK2 à BLACK5, et soudure.
14. Sur le dessus, fil traversant de BLACK3 à BLACK4 et à souder.
15. En haut, faites passer un fil bleu dans BLUE1 et BLUE2.
16. En bas, fil traversant de BLUE1 à BLUE3.
17. En bas, fil traversant de BLUE2 vers BLUE5, et soudure.
18. Sur le dessus, fil traversant de BLUE3 vers BLUE4, et soudure.
19. Sur le dessus, traversez un fil vert dans GREEN1 et GREEN2.
20. En bas, fil traversant de GREEN1 à GREEN3.
21. En bas, fil traversant de GREEN2 à GREEN5, et soudure.
22. Sur le dessus, fil traversant de GREEN3 dans GREEN4, et soudure.
23. En haut, traversez une résistance 4K7 dans SILVER3 et SILVER4.
24. En bas, fil traversant de SILVER3 vers GREEN5, et soudure.
25. En bas, fil traversant de SILVER4 vers RED10, et soudure.
26. Sur le dessus, traversez une résistance 4K7 dans SILVER1 et SILVER2.
27. En bas, fil traversant de SILVER1 vers BLUE5, et soudure.
28. En bas, fil traversant de SILVER2 vers RED10, et soudure.

Étape 3: Coder pour l'ONU

Le croquis est ici rudimentaire. Il vous permet d'utiliser l'entrée de la console pour que l'UNO envoie des messages I2C au I2C ATTINY85 BRICK.

Toutes les instructions sont imprimées à l'écran, avec les options prises en charge.

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 4: prochaines étapes

À partir des versions présentées, il y a suffisamment de pièces mobiles pour que vous puissiez créer votre propre réseau ASSIMILATE IOT.

Chacune des fonctions individuelles des nœuds (capteurs et acteurs) est contrôlable de manière décentralisée, ne dépendant pas du maître MCU pour avoir une quelconque connaissance des fonctionnalités prises en charge.

Toute application se connectant au courtier MQTT peut contrôler/observer toutes les fonctionnalités du nœud IOT. C'est M2M, applications Web, IFTTT et ainsi de suite. Des interfaces beaucoup plus simples (ou plus riches si vous le souhaitez) avec votre monde IOT.