IOT123 - I2C BRICK MASTER JIG: 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Ao desenvolver os SENSORES e ATORES ASSIMILATE, mantenho um UNO à mão para enviar comandos I2C ad hoc para os protótipos que estão sendo desenvolvidos. Um dos benefícios dos TIJOLOS I2C são as pinagens padronizadas. Em vez de usar fios de protoboard a cada vez (veja os Fritzings), um escudo robusto de baixa tecnologia é usado.

Etapa 1: Materiais e Ferramentas

1. PCB uninersal de 4 cm x 6 cm (1)
2. Fio de conexão (~ 6)
3. Resistores 4K7 (2) 6
4. Cabeçalho Masculino (12P, 8P)
5. Cabeçalho feminino (9P, ou 3P, 3P)
6. Solda e Ferro (1)

Etapa 2: Montagem

Se você usar 2 cabeçotes 3P fêmea em vez do 1 cabeçote 9P fêmea, o ASSIMILATE SENSOR / ACTORS vai caber no JIG sem desmontá-los.

Com a fiação, retire até 10 mm nas pontas e estanhe as pontas.

1. Na parte inferior da placa de circuito impresso, insira o coletor macho (1) (2) e solde na parte superior.
2. Na parte superior do PCB, insira o coletor fêmea (3) e solde na parte inferior.
3. No topo, através do orifício um fio vermelho em RED1 e RED2.
4. Na parte inferior, fio através do orifício de RED1 para RED3.
5. Na parte inferior, fio através do orifício de RED2 para RED5 e solda.
6. Na parte superior, fio de passagem de RED3 para RED4 e solda.
7. No topo, através do orifício um fio vermelho em RED6 e RED7.
8. Na parte inferior, fio através do orifício de RED6 para RED8.
9. Na parte inferior, passe o fio do RED7 para o RED10 e solda.
10. Na parte superior, fio de passagem de RED8 para RED9 e solda.
11. Na parte superior, faça um furo através de um fio preto em BLACK1 e BLACK2.
12. Na parte inferior, passe o fio de BLACK1 para BLACK3.
13. Na parte inferior, passe o fio do BLACK2 para o BLACK5 e solde.
14. Na parte superior, passe o fio do BLACK3 para o BLACK4 e solde.
15. No topo, faça um orifício através de um fio azul em AZUL1 e AZUL2.
16. Na parte inferior, passe o fio de BLUE1 para BLUE3.
17. Na parte inferior, passe o fio do BLUE2 para o BLUE5 e solde.
18. Na parte superior, arame através do orifício de BLUE3 para BLUE4 e soldar.
19. Na parte superior, passe um fio verde em GREEN1 e GREEN2.
20. Na parte inferior, passe o fio de VERDE1 para VERDE3.
21. Na parte inferior, passe o fio de GREEN2 para GREEN5 e solde.
22. Na parte superior, passe o fio de GREEN3 para GREEN4 e solde.
23. No topo, através do orifício um resistor 4K7 em PRATA3 e PRATA4.
24. Na parte inferior, passe o fio de PRATA3 para VERDE5 e solde.
25. Na parte inferior, arame através do orifício de SILVER4 para RED10 e soldar.
26. No topo, através do orifício um resistor 4K7 em PRATA1 e PRATA2.
27. Na parte inferior, passe o fio do PRATA1 para o BLUE5 e solde.
28. Na parte inferior, fio através do furo de PRATA2 para RED10 e solda.

Etapa 3: Código para o UNO

O esboço aqui é rudimentar. Ele permite que você use a entrada do console, para fazer o UNO enviar mensagens I2C para o TIJOLO I2C ATTINY85.

Todas as instruções são impressas na tela, com as opções compatíveis.

Comandos adhoc I2C BRICK para escravos do mestre UNO

#incluir

const byte _num_chars = 32;

char _received_chars [_num_chars]; // um array para armazenar os dados recebidos

booleano _has_new_data = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

Serial.println ("ASSIMILATE IOT ACTOR / SENSOR EEPROM EDITOR");

Serial.println ("garantir nova linha selecionada na janela do console");

Serial.println ();

Serial.println ("ENDEREÇO 1 CONFIRMAR RECIBO DE METADADOS N / A (PARA M2M)");

Serial.println ("COMANDO DO ATOR ENDEREÇO 2");

Serial.println ();

Serial.println ("ENDEREÇOS NO BUS:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

para (endereço de byte = 8; endereço <127; endereço ++)

{

Wire.beginTransmission (endereço);

erro de byte const = Wire.endTransmission ();

if (erro == 0)

{

Serial.println (endereço);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

byte estático 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;

}

}

outro {

_received_chars [ndx] = '\ 0'; // termina a string

ndx = 0;

_has_new_data = true;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = String (_received_chars);

if (_has_new_data == true) {

int idx1 = string_recebida.indexOf ('');

Endereço da string = string_recebido.substring (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("ENTRADA DE ENDEREÇO INVÁLIDA:");

Serial.println (endereço);

Retorna;

}

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

Código de string;

if (idx2 == -1) {

código = string_recebida.substring (idx1 + 1);

}outro{

código = string_recebida.substring (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

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

Serial.println ("ENTRADA DE CÓDIGO INVÁLIDA:");

Serial.println (código);

Retorna;

}

bool has_parameter = idx2> -1;

Parâmetro String;

if (has_parameter) {

parâmetro = string_recebido.substring (idx2 + 1, idx2 + 17); // 16 caracteres no máximo

if (parameter.length () <1) {

Serial.println ("PARTAMETER MIN. LENGTH 1");

_has_new_data = false;

Retorna;

}

}outro{

if (code_int> 1) {

Serial.println ("PARÂMETRO NECESSÁRIO!");

_has_new_data = false;

Retorna;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (cadeia_de_recebida);

Serial.print ("endereço =");

Serial.println (endereço);

Serial.print ("código =");

Serial.println (código);

Serial.print ("parâmetro =");

Serial.println (parâmetro);

// ENVIAR VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parameter.trim ();

strcpy (param_buf, parameter.c_str ());

Wire.write (param_buf);

}

Wire.endTransmission ();

Serial.println ();

Serial.println ("ENVIADO VIA I2C!");

Serial.println ();

Serial.println ("");

_has_new_data = false;

}

}

visualizar rawuno_i2c_command_input.ino hospedado com ❤ por GitHub

Etapa 4: Próximas etapas

A partir das compilações apresentadas, existem peças móveis suficientes para você construir sua própria REDE IOT ASSIMILATE.

Cada uma das funções individuais dos nós (sensores e atores) são controláveis de forma descentralizada, não dependendo do mestre MCU para ter conhecimento dos recursos suportados.

Qualquer aplicativo conectado ao corretor MQTT pode controlar / observar todos os recursos do Nó IOT. Isso é M2M, aplicativos da web, IFTTT e assim por diante. Interfaces muito mais simples (ou mais ricas, se preferir) para o seu mundo IOT.