IOT123 - TIJOLO I2C 2CH RELAY: 5 etapas (com imagens)

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 I2C 2CH RELAY BRICK estende a funcionalidade do I2C KY019 BRICK e tem duas propriedades de leitura / gravação:

2CH RELAYS [0] (verdadeiro / falso)

2CH RELAYS [1] (verdadeiro / falso)

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. Relé de 2 canais (1)
2. ATTINY85 20PU (1)
3. 1 "Protoboard dupla face (1)
4. Cabeçalho Masculino 90º (3P, 3P)
5. Cabeçalho Masculino (2P, 2P)
6. Jumper Shunt (1)
7. Fio de conexão (~ 7)
8. Solda e Ferro (1)

Etapa 2: Prepare o ATTINY85

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

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_2ch_relay".

Para fazer o upload do firmware para o ATTINY85, você pode encontrar mais detalhes nestes 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-…

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, ou seja, 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: montar o circuito

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 preto de BLACK1 a BLACK2 e solde.
7. Na parte traseira, trace um fio preto de BLACK3 a BLACK4 e solde.
8. Na parte traseira, trace um fio vermelho de RED1 a RED2 e solde.
9. Na parte traseira, trace um fio desencapado de RED3 a RED4 e solde.
10. Na parte traseira, trace um fio desencapado de PRATA1 a PRATA2 e solde.
11. Adicione um jumper na linha 5V ou 3V3.

O relé agora pode ser conectado diretamente por meio de seus pinos ao PCB ou por meio de fios, aos pontos mostrados no contrato de pino.

Etapa 4: 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 abre ou fecha os relés.

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 0: 1 (então 15 2 0: 1), e o relé CH1 liga.

7. Quando, entre na caixa de envio 2 0: 0 (então 15 2 0: 0), e o relé CH1 desliga.
8. Quando, entre na caixa de envio 2 1: 1 (então 15 2 1: 1), e o relé CH2 liga.
9. Quando, entre na caixa de envio 2 1: 0 (então 15 2 0: 0), e o relé CH2 desliga.

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

O acompanhamento ASSIMILATE ACTOR: 2CH RELAY 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. Alguns esquemas foram adicionados, mas existem várias maneiras de conectar o circuito downstream, dependendo do que você deseja alcançar, então vou deixar isso para você:)