Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Arduino com optoacopladores NeoPixel controlando muitos relés

Componentes e suprimentos

SparkFun LilyPad Rainbow LED (faixa de 7 cores)
ou semelhante (corte de uma tira Led 5m / rolo DC5V ws2812b 300led 60leds / m 5050 RGB individualmente endereçável ), vários fornecedores
× 1
Resistor 10k ohm
27 k Ohm
× 4
Resistor de foto
também chamado de LDR (Light Dependent Resistor) https://en.wikipedia.org/wiki/Photoresistor
× 4
RobotGeek Relay
ou https://www.conrad.nl/p/relaiskaart-5vdc-4-voudig- voor-arduino-raspberry-pi-etc-095841
× 4
Lâmpada LED
× 1
Arduino UNO
qualquer tipo de Arduino pode ser usado, neste aplicativo eu usei um Node MCU ESP32
× 1

Ferramentas e máquinas necessárias

Ferro de soldar (genérico)
Ferramentas comuns
como estará disponível em uma casa / oficina normal

Aplicativos e serviços online

Filme

Sobre este projeto


Este projeto é sobre como controlar vários relés ou outros atuadores a partir de um único pino de saída do Arduino.

Essa solução pode ser usada para situações típicas em que a quantidade de pinos de saída do Arduino disponíveis é insuficiente e mais atuadores, como relés, precisam ser controlados em paralelo a partir de um único pino de saída.

O princípio de operação é baseado no uso de uma faixa de LED de vários NeoPixels (LEDs SMD5050 com chips controladores WS2812B). Cada pixel é colocado junto com um LDR (Light Dependent Resistor), criando assim um optoacoplador DIY (quantos você quiser, apenas limitado pelo comprimento da faixa de LED, por exemplo, 300 pixels e fonte de alimentação de 5 V disponível). Desta forma, uma conversão serial para paralela é criada (de 1 para muitos)

Cada LED individual é endereçado a partir de um e o mesmo pino de saída do Arduino. Cada LDR (em série com um resistor de 27kOhm), é conectado a um relé de 5V. Desta forma, muitas combinações NeoPixel / LDR podem ser controladas a partir de 1 PIN de saída do Arduino usando a biblioteca Adafruit NeoPixel. Em vez de relés, também outros dispositivos atuadores podem ser conectados, usando os LDRs como uma entrada para qualquer circuito.

Para este projeto, que faz parte de um plano maior, é utilizado um ESP32 (NodeMCU); entretanto, um Arduino Uno normal (ou quase qualquer outro modelo) fará o trabalho.





Etapa 1:fazer os optoacopladores NeoPixel


O optoacoplador DIY é feito com os seguintes materiais:
  • um pedaço de tira de LED consistindo de 10 LEDs WS2812 (cortado de uma tira mais longa), apenas 4 são realmente usados ​​no projeto
  • um pedaço de espuma cinza escuro
  • uma tira de protoboard
  • fita adesiva preta



Nota:a separação dos pontos é igual à separação dos LEDs.

É importante separar a luz de cada LED individual dos LDRs dos outros para evitar "luz cruzada . "Descobriu-se que na prática isso é quase impossível e, portanto, a quantidade de luz emitida por cada LED no estado" ligado "foi definida para níveis baixos no software.

A faixa de LED usada tem 10 LEDs de comprimento, mas apenas 4 pixels são usados ​​em combinação com 4 LDRs neste projeto (para mantê-lo simples)





Etapa 2:a configuração eletrônica


Na configuração do breadboard, usei um ESP32s (NodeMCU), no entanto, qualquer Arduino pode fazer o trabalho.

O diagrama do circuito (feito com Fritzing) é o seguinte:

Na prática, isso se parece com o seguinte:

Como você pode ver, apenas 1 pino de saída é usado para controlar 4 relés em paralelo. Esse número pode chegar a 300! (tantos LEDs quantos disponíveis em uma faixa de 5 m de comprimento).

O dispositivo ESP32 funciona com níveis de 3,3 Volt (um regulador de voltagem de 3,3 V integrado), enquanto a faixa de LED com 5050 leds funciona com 5 V. O ESP32 é alimentado com energia de 5 V (via porta USB de um adaptador de 5 V ou 5 V banco de poder). Os LEDs NeoPixel obtêm a alimentação de 5 V diretamente do pino de 5 V do ESP32 e os relés usados ​​também são do tipo 5 V.

Neste exemplo, 4 circuitos optoacopladores são usados ​​controlando 4 relés conectados a uma lâmpada de 230 V cada.

O pino de saída usado é GPIO PIN 21 e os relés são controlados por meio dos números de pixel 1, 2, 3, 4.





Etapa 3:Fazendo o software


A função de loop no Arduino Sketch é simples e consiste em uma série de loops "for" para mostrar diferentes padrões de troca de lâmpadas controlando cada um dos relés.

Para controlar um relé específico, a seguinte função é chamada de dentro do código de loop :
  void ControlRelais (int RelaisNo, bool RelaisState) {strip.setPixelColor (RelaisNo, RelaisState * 15, RelaisState * 15, RelaisState * 15); // liga / desliga o LED que pertence ao RelaisNo strip.show (); Serial.print ("RelaisNo"); Serial.print (RelaisNo); Serial.print ("="); Serial.println (RelaisState); }  

Na verdade, tudo o que essa função faz é ligar um LED específico ou desligar.

Um endereço de LED corresponde ao respectivo número do relé. Os LEDs são acesos em um nível de luz baixo, apenas o suficiente para acionar o relé por meio do LDR, evitando assim a poluição luminosa (também referido acima como "luz cruzada".

O resultado de todo o esforço e do esboço particular, é mostrado no seguinte filme:


Código

  • Sketch para controlar vários relés por meio de optoacopladores NeoPixel de fabricação própria
Sketch para controlar vários relés por meio de acopladores ópticos NeoPixel feitos por nós mesmos Arduino
Este esboço mostra como controlar um número de relés através de múltiplos optoacopladores feitos com NeoPixels controlados a partir de 1 pino de saída ARDUINO
 / * Este código para controlar vários Relais ou outros atuadores de um único pino de saída Arduino, foi desenvolvido e produzido por Pierre Pennings (dezembro de 2018) Esta solução pode ser usada para situações típicas onde a quantidade de pinos de saída do Arduino disponíveis é insuficiente e mais atuadores como Relais precisam ser controlados em paralelo. O princípio de operação é baseado no uso de uma faixa de vários Neopixels (LEDs SMD5050 com chips controladores WS2812B) Cada pixel é colocado junto com um LDR (resistor dependente de luz), criando assim um optoacoplador DIY. Cada LED individual é endereçado a partir de um e o mesmo pino de saída ARDUINO e do LDR (em série com um resistor de 27kOhm ), está conectado a um Relais de 5 V. Desta forma, muitas combinações de Neopixel / LDR podem ser controladas a partir de 1 PIN de saída do Arduino usando a biblioteca Adafruit Neopixel. Para este projeto, que faz parte de um plano maior, um ESP 32 (NodeMCU) é usado, porém um ARDUINO UNO normal (ou quase qualquer outro modelo) fará o trabalho (é claro que as configurações no código precisarão ser ajustadas , por exemplo, devido a diferentes alocações de Pin) O dispositivo ESP 32 funciona com níveis de 3,3 Volt (um regulador de voltagem de 3,3 V integrado), enquanto a faixa de LED com 5050 leds funciona com 5 V O ESP 32 é alimentado com 5 V de energia (via a porta USB de um adaptador de 5 V ou powerbank de 5 V) Os LEDs Neopixel obtêm a alimentação de 5 V diretamente do pino de 5 V do ESP 32 e os Relais usados ​​também são do tipo 5 V. Neste exemplo, uma faixa de LED de 10 LEDs é usada, por razões de simplicidade, apenas 4 circuitos optoacopladores são feitos controlando 4 Relais conectados a uma lâmpada LED de 230V cada. O pino de saída usado é GPIO PIN 21 e os RELAIS são controlados por números de Pixel 1,2,3,4. Este código é licenciado sob a licença GPL3 +. * / # Include  #define NUM_LEDS 10 ////// /////////////////////////////////////////////// Inicializar o GPIO pinconst int RelaisPin =21; // pino 21 envia dados de controle (0 -3,3 V) para o Relaisint RelaisNo =0; // Variável para o Relais aplicável ser controladobool RelaisState =false; int r =0; Adafruit_NeoPixel strip =Adafruit_NeoPixel (NUM_LEDS, RelaisPin, NEO_RGB + NEO_KHZ800); /////////////////// //////////////////////////////////////// o código de configuração que se segue, será executado uma vez após "Ligar" ou depois uma configuração RESETvoid () {Serial.begin (115200); pinMode (RelaisPin, OUTPUT); // Inicializa o RelaisPin como saída strip.begin (); // Inicializa todos os LEDs para "desligados" para (int t =0; t <10; t ++) {strip.setPixelColor (t, 15, 15, 15); // Após ligar todos os LEDs da faixa são testados uma vez strip.show (); // observe que a ordem das cores da faixa de LED WS2812 é R, G, B delay (500); strip.setPixelColor (t, 0, 0, 0); // E voltar para off}} ////////////////////////////////////////// ///////// o código de loop que se segue, será executado repetidamente até "Desligar" ou um loop RESETvoid () {for (int r =1; r <5; r ++) // ligar o 4 Relais uma após a outra forma de contagem 1 a 4 {atraso (500); ControlRelais (r, verdadeiro); atraso (500); ControlRelais (r, falso); } for (int k =4; k> 0; k--) // ligar os 4 Relais um após o outro contando 4 a 1 {delay (500); ControlRelais (k, verdadeiro); atraso (500); ControlRelais (k, falso); } for (int r =1; r <5; r ++) // ligar os 4 Relais em um padrão {for (int k =4; k> 0; k--) {delay (500); ControlRelais (r, verdadeiro); ControlRelais (k, verdadeiro); atraso (500); ControlRelais (r, falso); ControlRelais (k, falso); }}} ////////////////// END of LOOP ////////////////////////////// ////////////////////////////////////// //////////////// /////////////////////////////////////// A seguir segue a Função para controlar o Relais (chamado de dentro do loop) void ControlRelais (int RelaisNo, bool RelaisState) {strip.setPixelColor (RelaisNo, RelaisState * 15, RelaisState * 15, RelaisState * 15); // liga / desliga o LED que pertence ao RelaisNo strip.show (); Serial.print ("RelaisNo"); Serial.print (RelaisNo); Serial.print ("="); Serial.println (RelaisState); } 

Esquemas

Configure para controlar vários relés ou outros atuadores de um único pino Arduino neopixel_optocoupler_relais__hNIrhGIMtD.fzz

Processo de manufatura

  1. Controle de um efeito com sensores reais
  2. Painel LCD com Arduino para o simulador de vôo
  3. Switch / Painel de LED com Arduino para FS2020
  4. Diversão do giroscópio com anel NeoPixel
  5. Smart Blinds
  6. Arduino com Bluetooth para controlar um LED!
  7. Sensor de obstáculo simples com Arduino
  8. Controle de um robô Roomba com Arduino e dispositivo Android
  9. Arduino Quadruped
  10. Controle do Servo Motor com Arduino e MPU6050