IOT123 - I2C HEARTBEAT TIJOLO: 6 etapas

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

Os TIJOLOS IOT123 são unidades modulares DIY que podem ser combinadas com outros TIJOLOS IOT123, para adicionar funcionalidade a um nó ou vestível. Eles são baseados em protoboards de dois lados, quadrados, de polegada quadrada com orifícios de passagem interconectados.

Espera-se que vários desses BRICKS estejam em vários nós (MCUs Master - ESP8266 ou ATTINY84) em um site. O MCU não precisa de conhecimento prévio da finalidade dos sensores ou das necessidades de software. Ele faz a varredura em busca de nós I2C e, em seguida, solicita um despejo de propriedade (dados do sensor) de cada escravo. Estes TIJOLOS fornecem 5,0V, 3,3V e outra linha AUX personalizável.

Este TIJOLO I2C HEARTBEAT indica se o escravo ATTINY está ativo, também o tráfego I2C, e tem uma propriedade:

STATUS ("VIVO")

PB1 (branco) indica saúde ATTINY.

PB3 (amarelo) alterna com solicitações I2C do mestre.

PB4 (laranja) alterna com recebimento I2C do mestre.

Os orifícios adjacentes ao ATTINY85 foram deixados sem uso, para permitir um programador de pogo pin enquanto o DIP8 é soldado ao PCB. Uma outra abstração, empacotando os BRICKS em pequenos cilindros que se conectam a um hub D1M WIFI BLOCK, bombeando os valores para um servidor MQTT, está sendo desenvolvida.

Etapa 1: Materiais e Ferramentas

Há uma lista completa de Bill of Material and Sourcing.

1. PCB de papel (7 x 7 orifícios)
2. LEDS (vermelho, verde, azul)
3. Resistores (3 desligados 1K)
4. ATTINY85 20PU (1)
5. 1 "Protoboard dupla face (1)
6. Cabeçalho Masculino 90º (3P, 3P)
7. Cabeçalho Masculino (2P, 2P)
8. Jumper Shunt (1)
9. Fio de conexão (~ 7)
10. Solda e Ferro (1)

Etapa 2: Prepare o ATTINY85

NOTA: Se pretende ter integração com Crouton, por favor, use a biblioteca a partir daqui e use o exemplo instalado "attiny_heartbeat"

AttinyCore do gerenciador de placas é necessário. Grave bootloader "EEPROM Retained", "8mHZ Internal" (todas as configurações mostradas acima).

O repositório de código pode ser encontrado aqui.

Um ZIP da biblioteca pode ser encontrado aqui.

Instruções para "Importar uma biblioteca ZIP" aqui.

Assim que a biblioteca estiver instalada, você pode abrir o exemplo "attiny_heartbeat".

Para fazer o upload do firmware para o ATTINY85, você pode encontrar mais detalhes nestas instruções:

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

Melhor testar através do breadboard antes de continuar.

Se você tiver SENSORES ASSIMILADOS, certifique-se de que o endereço do escravo seja diferente em uma combinação SENSOR / Host MCU, por exemplo, todos os atores de retransmissão podem ter o mesmo endereço, desde que você tenha apenas um ator de retransmissão em um MCU / nó.

Etapa 3: Montagem dos indicadores

Os indicadores devem ser totalmente personalizáveis. São os sinais de evento do circuito principal que são vistos como batimentos cardíacos. Para esta construção, usaremos indicadores LED; sua construção pode usar relés (sim, o VCC está quebrado) ou outro indicador visual / baseado em sinal. Os valores do resistor dependerão da preferência pessoal de quão brilhante você deseja.

1. Na parte superior, insira um LED azul em VERMELHO1 (+) e PRETO1 (G) e solde na parte inferior.
2. Na parte inferior, dobre o cabo de RED1 para que ele toque a almofada de cobre em SILVER8 e apare.
3. Na parte inferior, corte o cabo do BLACK1 acima da solda.
4. Na parte superior, insira um LED verde em VERMELHO2 (+) e PRETO2 (G) e solde na parte inferior.
5. Na parte inferior, dobre o cabo de RED2 para que ele toque a almofada de cobre em SILVER9 e apare.
6. Na parte inferior, corte o cabo do BLACK2 acima da solda.
7. Na parte superior, insira um LED vermelho em VERMELHO3 (+) e PRETO3 (G) e solde na parte inferior.
8. Na parte inferior, dobre o cabo de RED3 para que ele toque a almofada de cobre em SILVER10 e apare.
9. Na parte inferior, corte o cabo do BLACK3 acima da solda.
10. Na parte superior, insira um resistor de 1K nos orifícios PRATA1 e PRATA4.
11. Na parte inferior, trace, apare e solde o chumbo de PRATA1 para PRETO1.
12. Na parte superior, insira um resistor de 1K nos orifícios PRATA2 e PRATA4.
13. Na parte inferior, trace, apare e solde o chumbo de PRATA2 para PRETO2.
14. Na parte superior, insira um resistor de 1K nos orifícios PRATA3 e PRATA4.
15. Na parte inferior, trace, apare e solde o chumbo de PRATA3 para PRETO3.
16. Na parte inferior, solde os fios em PRATA 4 e corte com extensão de cerca de 5 mm.
17. Na parte inferior, solde um fio preto em SILVER4.
18. Na parte inferior, solde um fio branco em PRATA 5, garantindo a continuidade ao chumbo de VERMELHO1.
19. Na parte inferior, solde um fio amarelo em PRATA 6, garantindo a continuidade ao chumbo de VERMELHO2.
20. Na parte inferior, solde um fio laranja em PRATA 7, garantindo a continuidade para chumbo de RED3.

Etapa 4: montagem do circuito principal

Conjunto:

1. Na frente, insira os componentes ATTINY85 (1), coletores macho 3P 90deg (2) (3), coletores macho 3P (4) (5) e solda na parte traseira.
2. Na parte traseira, trace um fio amarelo de AMARELO1 a AMARELO2 e solde.
3. Na parte traseira, trace um fio laranja de ORANGE1 a ORANGE2 e solde.
4. Na parte traseira, trace um fio azul de AZUL1 a AZUL2 e solde.
5. Na parte traseira, trace um fio verde de VERDE1 a VERDE2 e solde.
6. Na parte traseira, trace um fio branco de BRANCO1 a BRANCO2 e solde.
7. Na parte traseira, trace um fio preto de BLACK1 a BLACK2 e solde.
8. Na parte traseira, trace um fio preto de BLACK3 a BLACK4 e solde.
9. Na parte traseira, trace um fio vermelho de RED1 a RED2 e solde.
10. Na parte traseira, trace um fio desencapado de RED3 a RED4 e solde.
11. Na parte traseira, trace um fio desencapado de PRATA1 a PRATA2 e solde.
12. Adicione um jumper na linha 5V ou 3V3.

Se estiver usando os indicadores acima (consulte o diagrama de pinagem):

1. Na parte traseira, solde o fio branco em PB1.
2. Na parte traseira, solde o fio amarelo no PB3.
3. Na parte traseira, solde o fio laranja em PB4.
4. Na parte traseira, solde o fio preto no GND.

Etapa 5: Teste

Espera-se que vários desses BRICKS estejam em vários nós (MCUs - ESP8266 ou ATTINY84) em um ambiente. Este é um teste de unidade: envia comandos I2C do UNO para o ATTINY que alterna o LED de recepção. O LED ATTINY ALIVE permanece aceso.

Anteriormente, construímos um I2C SHIELD para Arduino.

Se você quiser fazer o breadboard em vez disso:

1. Conecte o 5.0 V no UNO a um VCC no TIJOLO.
2. Conecte o GND no UNO ao GND no BRICK.
3. Conecte o A5 em UNO a SCL em TIJOLO.
4. Conecte o A4 em UNO a SDA em TIJOLO.
5. Conecte um resistor pull-up 4K7 de SDA para VCC.
6. Conecte um resistor pull-up 4K7 de SCL para VCC.

Executando o teste

1. Conecte seu UNO ao seu Dev PC com USB.
2. Faça upload do código para o UNO.
3. Abra o console do Arduino.
4. Escolha 9600 baud (reinicie o UNO e reabra o console se for necessário).
5. O endereço do escravo será impresso no console.
6. Quando, entre na caixa de envio 2 1 (então 16 2 1), e o LED de recepção acende.
7. Quando, entre na caixa de envio 2 0 (então 16 2 0), e o LED de recepção apaga.

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 6: Próximas etapas

O acompanhamento ASSIMILATE ACTOR: HEARTBEAT que usa este brick tem configuração automática para Crouton através dos metadados já instalados no ATTINY85 aqui. O pacote JSON enviado ao Crouton é enviado por meio do firmware mais recente para o ICOS10. Você pode fazer uma prova de conceito em um ESP8266 comum, se a construção for demais por enquanto.

O esboço UNO usado no teste tem uma função para salvar um novo endereço de escravo para EEPROM no ATTINY85, se você tiver um conflito em seu barramento I2C de destino.