top of page

Light Show Brasil

Administrador
Espírito de Natal
Administrador
+4
Mais ações

Posts do fórum

Light Show Brasil
Espírito de Natal
Espírito de Natal
12 de jan. de 2025
In Módulos Relés de 12V e 5V
A principal diferença entre os módulos de relés de 12V e 5V está na tensão de alimentação necessária para acionar os relés e no circuito de controle. Veja abaixo uma comparação detalhada: Módulo Relé de 16 Canais - 12V O módulo relé de 16 canais com alimentação de 12V possui componentes adicionais na entrada da placa que garantem a conversão e estabilização da tensão para os componentes internos. Entre esses componentes estão: • Capacitores de 25V: São responsáveis por filtrar e estabilizar a tensão de entrada, removendo ruídos e picos de voltagem, garantindo uma alimentação limpa para os circuitos internos. • Diodo de Proteção: Protege o circuito contra inversão de polaridade da fonte de alimentação, prevenindo danos aos componentes do módulo em caso de conexão incorreta da tensão. • Indutor: Atua como filtro de energia, ajudando a suavizar variações bruscas de energia e fornecendo uma corrente mais estável para os componentes sensíveis do módulo. • Regulador de Tensão LM2596S: Converte a tensão de entrada de 12V para 5V, fornecendo a voltagem necessária para alimentar os optoacopladores, LEDs indicadores e relés da placa, garantindo seu funcionamento correto e eficiente. Módulo Relés 16 Canais 12V • Esse módulo permite uma faixa de tensão de entrada que pode chegar até 40V, mas também pode ser alimentado diretamente com uma fonte de 5V, caso seja necessário. Módulo Relé de 16 Canais – 5V • O módulo relé de 16 canais com alimentação de 5V não possui o regulador de tensão nem os capacitores encontrados no módulo de 12V, uma vez que opera diretamente com uma fonte de 5V. Módulo Relés 16 Canais 5V Nota: Tenha cuidado ao alimentar o módulo com uma fonte cuja tensão ultrapasse 5V, pois isso pode danificar permanentemente os componentes da placa e causar o superaquecimento dos relés, aumentando o risco de falhas graves e até de incêndio. Certifique-se sempre de utilizar uma fonte de 5V estabilizada e de qualidade. Tópicos relacionados: 📌 Esquema de Ligação de Módulo Relés 16 Canais 5V com Arduino e Fonte Externa 📌 Esquema de Ligação de Módulo Relés 16 Canais 12V com Arduino e Fonte Externa
Diferenças entre os Módulos Relés 16 Canais de 12V e 5V content media
1
0
18
Light Show Brasil
Espírito de Natal
Espírito de Natal
11 de jan. de 2025
In Módulo Relés 16 Canais 5V
Passo a passo de ligação do módulo relé de 16 canais 5V no Arduino: Imagem com demonstração detalhada abaixo: Download do esquema em PDF abaixo: 📂 Esquema de Ligação Módulo Relés 16 Canais 5V com Arduino PDF Materiais necessários • 1x Arduino UNO (ou MEGA) • 1x Módulo Relés 16 canais 5V • 1x Fonte de alimentação 5V • 16x Lâmpadas a serem controladas • 2x Plugues de tomada macho • 1x Cabo USB para o Arduino • Alguns Fios de conexão (Jumpers) Passo 1: Conectar a fonte de alimentação ao módulo relé • Conecte a saída 5V da fonte ao borne VCC do módulo relé. • Conecte o GND da fonte ao borne GND do módulo relé. • Certifique-se de que a fonte de alimentação está conectada corretamente à rede elétrica (127V ou 220V, de acordo com sua rede). Nota: As fontes de alimentação geralmente são bivolt, ou seja, podem operar em 127V ou 220V automaticamente. No entanto, verifique se a fonte que você está utilizando é realmente bivolt. Caso contrário, se for uma fonte com seleção manual de tensão, ela deve possuir uma chave seletora na lateral da carcaça. Certifique-se de que a chave está ajustada corretamente de acordo com a tensão da rede elétrica local antes de ligar a fonte. Passo 2: Fazer a ligação entre o Arduino e o módulo relé • Utilize cabos (Jumpers) para conectar os pinos do Arduino aos pinos de entrada do módulo relé: • PIN 5V do Arduino → 5V do módulo relé • PIN 2 do Arduino → IN1 do módulo relé • PIN 3 do Arduino → IN2 do módulo relé • Continue conectando até o PIN 13 do Arduino , depois utilize os pinos analógicos: • A0 → IN11  ,  A1 → IN12  , A2 → IN13 , A3 → IN14 , A4 → IN15 e A5 → IN16. • PIN GND do Arduino → GND do módulo relé Passo 3: Conectar as lâmpadas ao módulo relé • Para cada canal de relé, faça a seguinte ligação: • Conecte o fio preto (fase) da rede elétrica ao pino COM (comum) do relé. • Conecte o fio vermelho ao pino NA  (normalmente aberto) do relé e ao terminal da lâmpada. • Conecte o fio azul (neutro)  diretamente ao outro terminal da lâmpada. Passo 4: Verificar as conexões • Certifique-se de que todas as conexões estão bem firmes e seguras. • Verifique se a fonte de alimentação está ajustada para a tensão correta da rede elétrica (127V ou 220V). • Após a verificação, conecte a fonte à tomada e o Arduino ao computador via cabo USB. Conclusão Seguindo esses passos, você terá um sistema de controle de lâmpadas usando um Arduino e um Módulo de Relés de 16 canais 5V Corretamente. Lembre-se: ao trabalhar com corrente alternada (AC), é fundamental tomar todas as precauções de segurança. Se precisar de mais detalhes ou ajuda com o código Arduino, vou deixar alguns tópicos relacionados aqui abaixo e caso não ache o que está procurando, sinta-se a vontade para abrir um novo tópico. Tópicos relacionados: 📌 Esquema de Ligação de Módulo Relés 16 Canais 12V com Arduino e Fonte Externa 📌 Configuração do código para controlar módulo relés de 16 canais com Arduino no Vixen Lights
Esquema de Ligação de Módulo Relés 16 Canais 5V com Arduino e Fonte Externa content media
0
0
21
Light Show Brasil
Espírito de Natal
Espírito de Natal
11 de jan. de 2025
In Fita de LED RGB no Vixen 3
Instruções para adicionar um novo elemento no Vixen Lights e configurar 4 fitas de LED RGB para controlar com o Arduino: Nota: Caso ainda não tenha configurado sua fita de LED RGB utilizando o código no Arduino, acesse o tópico abaixo para fazer o download e realizar a configuração. Após concluir, retorne a este tópico para continuar com as próximas etapas. Tópico mencionado acima: 📌 Configuração do Código para Controlar 4 Fitas de LED RGB com Arduino no Vixen Lights Passo 1: Abra o Vixen Lights: • Inicie o software Vixen Lights no seu computador. • Na página inicial do Vixen Lights, vá até o menu "Setup Display" (Configuração do Display). Passo 2: Adicionando o Elemento (Fita de LED RGB): • No menu de configuração do setup display, vá até a aba "Elements" (Elementos). • Em Tipo de Elemento, selecione a opção "Generic Numbered Group"  (Grupo Numerado Genérico). • Clique no botão "‎‎ + " para adicionar o novo elemento. • Atribua um nome ao grupo do elemento : • No campo "Group Name" (Nome do Grupo), insira um nome para o grupo. Exemplo: "Fitas de LED RGB". • Defina o subnome para o grupo do elemento : • No campo "Item Prefix" (Prefixo do Item), insira um nome mais específico para o grupo. Exemplo: "Fita de LED RGB". • Especifique a quantidade de itens: • No campo "Item Count" (Contagem do Item), insira a quantidade de itens a serem utilizados no caso 4 Fitas de LED RGB. • Clique em "OK" para salvar. Passo 3: Adicionando e configurando curva de escurecimento do elemento (Fita de LED RGB): • Adicionado a Curva do Emento: • Na próxima aba, será exibida a mensagem "Would you like to configure a dimming curve for this property?"  (Gostaria de configurar uma curva de escurecimento para esta propriedade?). A curva de escurecimento determina como o brilho da fita de LED RGB será ajustado e permite transições suaves entre as cores. • Clique em "YES" para confirmar. • Configuração da curva de escurecimento • Nessa etapa, será exibida a seguinte mensagem: "This will set up a dimming curve for each selected element. Use the button below to configure the dimming curve for selected elements. Hint: Use a Library Curve to make editing easier." (“Isso configurará uma curva de escurecimento para cada elemento selecionado. Use o botão abaixo para configurar a curva de escurecimento dos elementos selecionados. Dica: utilize uma Curva de Biblioteca para simplificar a edição.”) • Para continuar, clique em "Setup Dimming Curve" (Configurar Curva de Escurecimento) e prossiga com a configuração. • Na próxima janela, será exibido um gráfico representando a curva de escurecimento. Não é necessário fazer alterações; apenas clique em "OK"  e na para continuar. • Curva configurada! Clique em "OK"  para prosseguir. Passo 3: Configuração da Cor RGB do Elemento (Fita de LED RGB): • Na janela "Color Configuration" (Configuração de Cor), seleciona a opção "They can be any color: they are full RGB and mix to make any color" (Eles podem ser de qualquer cor: são RGB completos e se misturam para criar qualquer cor). • Em  "Color Order"  (Ordem de Cor), selecione a opção RGB e clique em "OK" para confirmar. • Pronto! A cor RGB do elemento foi configurada com sucesso. Passo 4: Linkar o Elemento (Fita de LED RGB) ao Controlador (Arduino): • No painel esquerdo "Elements" (Elementos), selecione o elemento recém-adicionado, neste caso o grupo, "Fitas de LED RGB". • No painel direito "Controllers", selecione o controlador que você configurou anteriormente, no caso "Arduino". • Certifique-se de que o número de canais do controlador seja suficiente para os canais da fita de LED. Neste caso, será exibida a mensagem: "his will patch 12 element patch points to 12 controller outputs" ("Isso conectará 12 pontos de patch Se os números coincidirem, significa que os canais estão corretamente correspondentes"). • Clique em Patch Elements (Vincular Elementos). • O Vixen atribuirá automaticamente os canais correspondentes do controlador ao elemento RGB. Para confirmar, clique em "Graphical View" na aba "Patching". Representação do Gráfico: • Blocos azuis (à esquerda): • Representam as fitas de LED RGB, numeradas como "Fita de LED RGB-1", "Fita de LED RGB-2", "Fita de LED RGB-3", e "Fita de LED RGB-4". • Blocos amarelos (no centro): • Cada fita de LED RGB está conectada a dois blocos amarelos: • O primeiro é chamado de "Dimming Curve" (Curva de Escurecimento). • O segundo é chamado de "Color breakdown" (Divisão de cores). • Esses blocos indicam processamento intermediário, como ajuste de brilho e separação das cores RGB. • Blocos verdes (à direita): • Representam as saídas do controlador, numeradas de "Output 1" a "Output 12". • Cada saída está conectada às respectivas fitas e processadores intermediários por meio de linhas pretas. Este gráfico mostra claramente o fluxo de dados: das fitas de LED RGB, passando por ajustes de brilho e cores, até as saídas controladoras. • Para finalizar, clique em "OK" para salvar as configurações. Passo 5: Criando uma Nova Sequência: • Na página inicial do Vixen Lights, vá até o menu "New Sequence" (Nova Sequência). • A interface de edição será aberta, exibindo uma linha do tempo com os elementos configurados. . • Na aba "Effects" (Efeitos), selecione um efeito desejado, como Set Level (Definir Nível), Strobe (Estroboscópio), Pulse (Pulso), entre outros. Para esta demonstração, utilizaremos o efeito "Bars" (Barras). • Arraste o efeito para a linha do tempo, alinhando-o com o elemento Fitas de LED RGB. • Ajuste a duração do efeito clicando e arrastando as extremidades dele. • Clique no botão "Play" no menu superior para ver o efeito em funcionamento. Configurações de Efeitos na aba "Effects Editor" (Editor de Efeitos). • Effect Preview (Prévio do Efeito): • Este botão permite ativar ou desativar a pré-visualização do efeito enquanto ele é configurado. • String Setup: (Configuração de Corda) no caso do elemento (Fita de LED RGB) • Positioning (Posicionamento): Define como as barras serão posicionadas nos elementos de luz. A opção atual está configurada como "Strings" (Cordas), mas pode ser alterado para "Locations" (Locais) dependendo do efeito desejado. • Orientation (Orientação): Controla a direção das barras. Está configurado como "Vertical", mas pode ser alterado para "horizontal" dependendo do efeito desejado. • Configuration (Configuração): • Bar Type (Tipo de Barra): Define o estilo das barras. Aqui está definido como "Flat" (Plano), mas há outra opção como o "ZigZag". • Direction (Direção): Controla a direção do movimento das barras. Está definido como "Moves Up" (subindo), mas você pode alterá-lo para outras opções disponíveis no menu, de acordo com a sua preferência. • Rotation (Roração): Permite rotacionar as barras para um efeito diferenciado modificando o gráfico. • Motion (Movimento): Define o comportamento do movimento, atualmente está configurado como "Iterations" (Iterações ou Repetições), mas você pode alterá-lo para "Speed" (Velocidade). • Iterations (Iterações ou Repetições): Controla quantas vezes o efeito será repetido durante o intervalo selecionado. • Repeat (Repetir): Ajusta como as barras se repetem. • Highlight (Destaque): Ajusta como as barras se destacam. • 3D: Permite habilitar um efeito 3D para dar mais profundidade às barras. • Color (Cor): • Esta seção permite configurar o gradiente de cores das barras. Aqui, temos três cores definidas: vermelho, verde e azul. • Você pode adicionar ou remover cores no gradiente usando os botões "Add" (Adicionar) e "Remove" (Remover). • Brightness (Brilho): • Controla a intensidade do brilho do efeito. Conclusão! Com esses passos, você será capaz de adicionar e configurar 4 fitas de LED RGB no Vixen Lights para serem controladas pelo Arduino. Tópicos relacionados: 📌 Esquema de Ligação de Fita de LED RGB no Arduino 📌 Esquema de Ligação de 4 Fitas de LED RGB no Arduino 📌 Código Sequencial para Fitas de LED RGB com Arduino - 4 Canais RGB
Adicionar Fita de LED RGB no Vixen Lights para controlar com Arduino content media
0
0
6
Light Show Brasil
Espírito de Natal
Espírito de Natal
11 de jan. de 2025
In Fita RGB no Arduino e Vixen 3
Instruções para adicionar um novo controlador no Vixen Lights e configurar para controlar 4 fitas de LED RGB com o Arduino: Passo 1: Abra o Vixen Lights: • Inicie o software Vixen Lights no seu computador. • Na página inicial do Vixen Lights, vá até o menu "Setup Display" (Configuração do Display). Passo 2: Adicionando o Controlador Genérico Serial (Arduino): • No menu de configuração do setup display, vá até a aba "Controllers" (Controladores). • No tipo de controlador, selecione "Generic Serial". • Clique no botão "‎‎ + " para adicionar o controlador. • Em "Controller Name" (Nome do Controlador), atribua um nome ao controlador, como por exemplo "Arduino", e clique em OK. • No campo "Controller Output Count"  (Contagem de Saídas do Controlador), informe a quantidade total de saídas utilizadas. No exemplo, consideramos 12 saídas , referentes a 4 fitas de LED RGB, em que cada fita consome 3 canais individuais — vermelho (R), verde (G) e azul (B). Assim, cada fita ocupará 3 canais de saída do controlador. • Ajuste esse valor de acordo com a quantidade de fitas ou canais utilizados, multiplicando o número de fitas por 3 (referente aos canais vermelho, verde e azul de cada fita). Passo 4: Configurar a Porta Serial e Velocidade da Comunicação Serial: • Após selecionar o controlador Generic Serial (Arduino), clique na engrenajem ⚙️ de configuração que estará na parte inferior na aba Selected Controller (Selecionar Controlador). • Irá abrir uma janela com o nome Generic Serial Configuration (Configuração Serial Genérica). Clique em Setup/Change Serial Port (Configurar/Alterar Porta Serial). • Na próxima janela, em Port Name (Nome da Porta) você selecione a porta serial correspondente ao seu Arduino (pode ser algo como COM3, COM4, ou a porta USB que o Arduino está usando). • Em Baud Rate (Taxa de Transmissão) configure a velocidade de comunicação serial para 9600. Esta é a velocidade que está configurada no seu código Arduino para a comunicação via serial. Serial.begin(9600); Passo 5: Salvar a Configuração: • Após definir a porta serial e a velocidade de comunicação clique em "OK" em todas as janelas para salvar a configuração do controlador. Passo 6: Verificar Conexão: • Após configurar o controlador, o Vixen Lights começará a enviar os dados para o Arduino através da comunicação serial. VID_20250108_213344.mp4 Conclusão! Seguindo esses passos, você conseguirá configurar o Arduino para controlar com sucesso as 4 fitas de LED RGB no Vixen Lights. Próximo passo: Agora, siga para o próximo tópico abaixo para configurar os "Elementos" (Fitas de LED RGB) no Vixen Lights. 📌...
Configuração do Arduino no Vixen Lights para Controle de 4 Fitas de LED RGB content media
0
0
7
Light Show Brasil
Espírito de Natal
Espírito de Natal
10 de jan. de 2025
In Fita RGB no Arduino e Vixen 3
Passo a passo para configurar o código de comunicação com Arduino e Vixen Lights para controlar 4 Fitas de LED RGB. Código abaixo: //==========================> Definição dos pinos e nomes das variáveis // LED RGB 01 int LedVermelho1 = 2; int LedVerde1 = 3; int LedAzul1 = 4; // LED RGB 02 int LedVermelho2 = 5; int LedVerde2 = 6; int LedAzul2 = 7; // LED RGB 03 int LedVermelho3 = 8; int LedVerde3 = 9; int LedAzul3 = 10; // LED RGB 04 int LedVermelho4 = 11; int LedVerde4 = 12; int LedAzul4 = 13; int i = 0; int incomingByte[12]; // Array para armazenar os 12 valores RGB void setup() { //==========================> Velocidade da comunicação Serial Serial.begin(9600); //==========================> Definir os pinos como saída // LED RGB 01 pinMode(LedVermelho1, OUTPUT); pinMode(LedVerde1, OUTPUT); pinMode(LedAzul1, OUTPUT); // LED RGB 02 pinMode(LedVermelho2, OUTPUT); pinMode(LedVerde2, OUTPUT); pinMode(LedAzul2, OUTPUT); // LED RGB 03 pinMode(LedVermelho3, OUTPUT); pinMode(LedVerde3, OUTPUT); pinMode(LedAzul3, OUTPUT); // LED RGB 04 pinMode(LedVermelho4, OUTPUT); pinMode(LedVerde4, OUTPUT); pinMode(LedAzul4, OUTPUT); } void loop() { // Verifica se há 12 bytes disponíveis na comunicação serial if (Serial.available() >= 12) { // Ler os 12 valores RGB e armazená-los no array incomingByte[] for (int i = 0; i < 12; i++) { incomingByte[i] = Serial.read(); } // LED RGB 01 analogWrite(LedVermelho1, incomingByte[0]); // Pino 2 analogWrite(LedVerde1, incomingByte[1]); // Pino 3 analogWrite(LedAzul1, incomingByte[2]); // Pino 4 // LED RGB 02 analogWrite(LedVermelho2, incomingByte[3]); // Pino 5 analogWrite(LedVerde2, incomingByte[4]); // Pino 6 analogWrite(LedAzul2, incomingByte[5]); // Pino 7 // LED RGB 03 analogWrite(LedVermelho3, incomingByte[6]); // Pino 8 analogWrite(LedVerde3, incomingByte[7]); // Pino 9 analogWrite(LedAzul3, incomingByte[8]); // Pino 10 // LED RGB 04 analogWrite(LedVermelho4, incomingByte[9]); // Pino 11 analogWrite(LedVerde4, incomingByte[10]); // Pino 12 analogWrite(LedAzul4, incomingByte[11]); // Pino 13 } } Download do código para 4 Fitas de LED RGB: 📂 Código Arduino Para Controle de 4 Fitas de LED RGB com Vixen Lights Passo 1: Definição dos pinos e variáveis No início do código, são definidos os pinos do Arduino aos quais as fitas de LED RGB estão conectadas, além de um array para armazenar os valores RGB que serão recebidos. Código: // LED RGB 01 int LedVermelho1 = 2; int LedVerde1 = 3; int LedAzul1 = 4; // LED RGB 02 int LedVermelho2 = 5; int LedVerde2 = 6; int LedAzul2 = 7; // LED RGB 03 int LedVermelho3 = 8; int LedVerde3 = 9; int LedAzul3 = 10; // LED RGB 04 int LedVermelho4 = 11; int LedVerde4 = 12; int LedAzul4 = 13; int i = 0; int incomingByte[12]; // Array para armazenar os 12 valores RGB • LED RGB 01: Os LEDs estão conectados nos pinos 2, 3 e 4 do Arduino, onde o pino 2 controla o vermelho, o pino 3 o verde e o pino 4 o azul da fita 1. • LED RGB 02: Similarmente, os LEDs da fita 2 estão nos pinos 5, 6 e 7. • LED RGB 03: Os LEDs da fita 3 estão nos pinos 8, 9 e 10. • LED RGB 04: E os LEDs da fita 4 nos pinos 11, 12 e 13. • O array incomingByte[12] vai armazenar os valores RGB recebidos da comunicação serial, onde cada grupo de 3 bytes corresponde a uma fita de LED. Passo 2: Configuração inicial no setup() Código: void setup() { //==========================> Velocidade da comunicação Serial Serial.begin(9600); //==========================> Definir os pinos como saída // LED RGB 01 pinMode(LedVermelho1, OUTPUT); pinMode(LedVerde1, OUTPUT); pinMode(LedAzul1, OUTPUT); // LED RGB 02 pinMode(LedVermelho2, OUTPUT); pinMode(LedVerde2, OUTPUT); pinMode(LedAzul2, OUTPUT); // LED RGB 03 pinMode(LedVermelho3, OUTPUT); pinMode(LedVerde3, OUTPUT); pinMode(LedAzul3, OUTPUT); // LED RGB 04 pinMode(LedVermelho4, OUTPUT); pinMode(LedVerde4, OUTPUT); pinMode(LedAzul4, OUTPUT); } • Serial.begin(9600); : Inicia a comunicação serial entre o Arduino e o computador (ou outro dispositivo), com uma taxa de transmissão de 9600 bauds. • pinMode() : Cada pino que controla um LED é configurado como OUTPUT, ou seja, o Arduino irá enviar sinais para esses pinos. Isso é feito para todos os LEDs RGB das 4 fitas (um pino para cada cor de cada fita). Passo 3: Função loop() A função loop() é executada repetidamente, e nela o código verifica se há dados disponíveis na comunicação serial. Quando os dados são recebidos, o código lê esses dados e ajusta as cores dos LEDs. Código: void loop() { // Verifica se há 12 bytes disponíveis na comunicação serial if (Serial.available() >= 12) { // Ler os 12 valores RGB e armazená-los no array incomingByte[] for (int i = 0; i < 12; i++) { incomingByte[i] = Serial.read(); } // LED RGB 01 analogWrite(LedVermelho1, incomingByte[0]); // Pino 2 analogWrite(LedVerde1, incomingByte[1]); // Pino 3 analogWrite(LedAzul1, incomingByte[2]); // Pino 4 // LED RGB 02 analogWrite(LedVermelho2, incomingByte[3]); // Pino 5 analogWrite(LedVerde2, incomingByte[4]); // Pino 6 analogWrite(LedAzul2, incomingByte[5]); // Pino 7 // LED RGB 03 analogWrite(LedVermelho3, incomingByte[6]); // Pino 8 analogWrite(LedVerde3, incomingByte[7]); // Pino 9 analogWrite(LedAzul3, incomingByte[8]); // Pino 10 // LED RGB 04 analogWrite(LedVermelho4, incomingByte[9]); // Pino 11 analogWrite(LedVerde4, incomingByte[10]); // Pino 12 analogWrite(LedAzul4, incomingByte[11]); // Pino 13 } } Funções dentro do loop() : • Serial.available() >= 12 : Verifica se há pelo menos 12 bytes disponíveis para leitura na comunicação serial. Isso é necessário porque cada fita de LED precisa de 3 valores (um para cada cor: vermelho, verde e azul), totalizando 12 bytes para controlar as 4 fitas de LED RGB. • for (int i = 0; i < 12; i++) { incomingByte[i] = Serial.read(); } : Se houver 12 bytes disponíveis, o código entra em um laço que lê cada byte da comunicação serial e armazena no array incomingByte. Cada índice do array corresponde ao valor de intensidade de uma cor para uma fita de LED: • incomingByte[0] , incomingByte[1], incomingByte[2] são os valores RGB para o LED RGB 01. • incomingByte[3], incomingByte[4], incomingByte[5] são os valores RGB para o LED RGB 02. • incomingByte[6], incomingByte[7], incomingByte[8] são os valores RGB para o LED RGB 03. • incomingByte[9], incomingByte[10], incomingByte[11] são os valores RGB para o LED RGB 04. • analogWrite(pino, valor); : Para cada fita de LED, a função analogWrite() é usada para enviar um valor PWM (Pulse Width Modulation) ou (Modulação de Largura de Pulso) para os pinos correspondentes. O valor de cada cor (vermelho, verde e azul) é ajustado conforme o valor recebido pela comunicação serial: • Para a fita 1, o LedVermelho1 recebe incomingByte[0], o LedVerde1 recebe incomingByte[1] e o LedAzul1 recebe incomingByte[2], e assim por diante para as outras fitas. Resumo • Objetivo: Controlar 4 fitas de LED RGB (totalizando 12 pinos) com um Arduino. A cor de cada fita é controlada por 3 valores (RGB), e esses valores são recebidos via comunicação serial. • Como funciona: • A comunicação serial é configurada a 9600 bauds. • O Arduino espera que 12 bytes sejam recebidos via serial (representando os valores RGB para 4 fitas). • Cada conjunto de 3 bytes é enviado para os pinos correspondentes de cada fita de LED RGB, controlando a intensidade de cada cor (vermelho, verde e azul). Concluído com sucesso! • Acesse o próximo tópico abaixo para continuar com o processo. 📌 Adicionar Fita de LED RGB no Vixen Lights para controlar com Arduino Tópicos relacionados: 📌 Código Sequencial para Fitas de LED RGB com Arduino - 4 Canais RGB 📌 Esquema de Ligação de Fita de LED RGB no Arduino 📌 Esquema de Ligação de 4 Fitas de LED RGB no Arduino
0
0
7
Light Show Brasil
Espírito de Natal
Espírito de Natal
10 de jan. de 2025
In Controle 16 Relés no Vixen 3
Para baixar o software Vixen Lights 3 acesse o link abaixo: 📂 Vixen Lights 3 Nota: Se você ainda não possui o código, acesse o tópico abaixo para fazer o download e configurá-lo no Arduino. Após concluir essa etapa, retorne a este tópico para continuar o processo. Tópico mencionado acima: 📌 Configuração do Código para Controlar Módulo Relés de 16 Canais com Arduino no Vixen Lights Instruções para adicionar um novo controlador no Vixen Lights e configurar para comunicação com o Arduino: Passo 1: Abra o Vixen Lights: • Inicie o software Vixen Lights no seu computador. • Na página inicial do Vixen Lights, vá até o menu "Setup Display" (Configuração do Display). Passo 2: Adicionando o Controlador Genérico Serial (Arduino): • No menu de configuração do setup display, vá até a aba "Controllers" (Controladores). • No tipo de controlador, selecione "Generic Serial". • Clique no botão "‎‎ + " para adicionar o controlador. • Em "Controller Name" (Nome do Controlador), atribua um nome ao controlador, como por exemplo "Arduino", e clique em OK. • No campo "Controller Output Count" (Contagem de Saídas do Controlador), informe a quantidade de saídas que você está utilizando. No exemplo, utilizaremos 16 saídas, mas você pode ajustar conforme a quantidade de saídas que estiver utilizando. Passo 4: Configurar a Porta Serial e Velocidade da Comunicação Serial: • Após selecionar o controlador Generic Serial (Arduino), clique na engrenajem ⚙️ de configuração que estará na parte inferior na aba Selected Controller (Selecionar Controlador). • Irá abrir uma janela com o nome Generic Serial Configuration (Configuração Serial Genérica). Clique em Setup/Change Serial Port (Configurar/Alterar Porta Serial). • Na próxima janela, em Port Name (Nome da Porta) você selecione a porta serial correspondente ao seu Arduino (pode ser algo como COM3, COM4, ou a porta USB que o Arduino está usando). • Em Baud Rate (Taxa de Transmissão) configure a velocidade de comunicação serial para 115200. Esta é a velocidade que está configurada no seu código Arduino para a comunicação via serial. Serial.begin(115200); Passo 5: Salvar a Configuração: • Após definir a porta serial e a velocidade de comunicação clique em "OK" em todas as janelas para salvar a configuração do controlador. Passo 6: Verificar Conexão: • Após configurar o controlador, o Vixen Lights começará a enviar os dados para o Arduino através da comunicação serial. VID_20250108_213344.mp4 Conclusão Seguindo esses passos, você deve conseguir configurar o Arduino no Vixen Lights com sucesso. Tópicos relacionados: 📌 Ligação de Módulo Relé 8 Canais com Arduino e Fonte Externa 📌 Ligação de Módulo Relé 16 Canais com Arduino UNO/MEGA 📌 Configuração do Arduino no Vixen Lights para Controlar Módulo Relés - 8 Canais
Configuração do Arduino no Vixen Lights para Controlar Módulo Relés - 16 Canais content media
0
0
14
Light Show Brasil
Espírito de Natal
Espírito de Natal
10 de jan. de 2025
In Controle 8 Relés no Vixen 3
Passo a passo para configurar o código de comunicação com Arduino e Vixen Lights para controlar módulo de relés 8 canais. Nota: O passo a passo menciona 8 canais, mas você pode ajustar a quantidade de canais conforme a necessidade do seu projeto. Lembre-se de que cada modelo de Arduino possui um limite de pinos disponíveis para conexão com os módulos relés, portanto, verifique se a quantidade de canais desejada está dentro desse limite. Código abaixo: // Número de canais controlados pelo Vixen Lights (8 relés) #define NUM_CANAIS 8 // Pinos dos relés int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9}; // Buffer para armazenar os dados recebidos byte buffer[NUM_CANAIS]; void setup() { // Inicializa a comunicação serial com o Vixen Lights Serial.begin(115200); // Configura os pinos dos relés como saída for (int i = 0; i < NUM_CANAIS; i++) { pinMode(pinosReles[i], OUTPUT); digitalWrite(pinosReles[i], LOW); // Desliga os relés no início } } void loop() { // Verifica se há dados recebidos na porta serial if (Serial.available() >= NUM_CANAIS) { // Lê os dados enviados pelo Vixen Lights Serial.readBytes(buffer, NUM_CANAIS); // Atualiza o estado dos relés de acordo com os dados recebidos for (int i = 0; i < NUM_CANAIS; i++) { if (buffer[i] == 0) { digitalWrite(pinosReles[i], HIGH); // Liga o relé quando o valor for 0 } else { digitalWrite(pinosReles[i], LOW); // Desliga o relé quando o valor for diferente de 0 } } } } Download do código para 8 canais: 📂 Código Para Controle de Relés 8 Canais com Vixen Lights Passo 1: Definir o número de canais (relés) e pinos: #define NUM_CANAIS 8 • Define o número de canais a serem controlados. No caso, são 8 canais (relés). int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9}; • Cria um vetor de inteiros pinosReles[] que armazena os pinos do Arduino onde os 8 relés estão conectados. Os pinos vão de 2 a 9. byte buffer[NUM_CANAIS]; • Cria um vetor de bytes buffer[] que irá armazenar os dados recebidos da comunicação serial. O tamanho do vetor é igual ao número de canais (8). Passo 2: Função setup() - Configuração Inicial A função setup() é executada uma única vez ao iniciar o código e serve para configurar os parâmetros iniciais. Serial.begin(115200); • Inicia a comunicação serial a 115200 bps (bits por segundo). Isso é necessário para enviar e receber dados entre o Arduino e outro dispositivo (como um computador ou controlador de luzes). for (int i = 0; i < NUM_CANAIS; i++) { pinMode(pinosReles[i], OUTPUT); digitalWrite(pinosReles[i], LOW); // Desliga os relés no início } • O código dentro do laço for configura todos os pinos dos relés como saídas. Ele percorre o vetor pinosReles[] e para cada pino, chama a função pinMode() com o parâmetro OUTPUT (configurando o pino como saída). Em seguida, a função digitalWrite() é chamada para garantir que todos os relés comecem desligados (valor LOW). Passo 3: Função loop() - Processamento Contínuo A função loop() é chamada repetidamente, de forma contínua, e é onde o Arduino vai constantemente verificar e processar os dados recebidos. if (Serial.available() >= NUM_CANAIS) { • Verifica se há pelo menos 8 bytes de dados disponíveis na porta serial. Se houver dados suficientes, o código prossegue para a leitura dos dados. Serial.readBytes(buffer, NUM_CANAIS); • Lê os 8 bytes da porta serial e os armazena no vetor buffer[]. Cada byte do buffer irá representar o estado de um relé. Se o byte for 0, o relé será ligado, se for outro valor, o relé será desligado. for (int i = 0; i < NUM_CANAIS; i++) { if (buffer[i] == 0) { digitalWrite(pinosReles[i], HIGH); // Liga o relé quando o valor for 0 } else { digitalWrite(pinosReles[i], LOW); // Desliga o relé quando o valor for diferente de 0 } } 1. O laço for percorre todos os elementos do vetor buffer[] e, dependendo do valor de cada byte: • Se o valor for 0, o relé correspondente é ligado (digitalWrite(pinosReles[i], HIGH)). • Se o valor for diferente de 0, o relé é desligado (digitalWrite(pinosReles[i], LOW)). Resumo do Funcionamento do Código: 1. Configuração Inicial: • O Arduino é configurado para controlar 8 relés, conectados aos pinos especificados no vetor pinosReles[]. • A comunicação serial é iniciada para permitir a troca de dados com um dispositivo externo. 2. Verificação de Dados Serial: • A cada loop, o Arduino verifica se há dados disponíveis na porta serial. • Se houver 8 bytes ou mais, ele lê os dados e os armazena no buffer. 3. Controle dos Relés: • O Arduino percorre os dados no buffer e, para cada byte, decide se o relé correspondente deve ser ligado (valor 0) ou desligado (qualquer valor diferente de 0). 4. Loop Contínuo: • Esse processo é repetido continuamente no loop(), permitindo que o Arduino controle os relés com base nos dados recebidos via serial. Nota: As únicas linhas que você irá alterar nó código são: #define NUM_CANAIS 8 • Quantidade de relés conectado nas portas do Arduino. & int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9}; • Número das portas aonde os relés estão conectados. Concluído com sucesso! • Acesse o próximo tópico abaixo para continuar com o processo. 📌 Configuração do Arduino no Vixen Lights para Controlar 8 Módulos Relés Tópicos relacionados: 📌 Ligação de Módulo Relé 8 Canais com Arduino e Fonte Externa 📌Ligação de Módulo Relé 16 Canais com Arduino e Fonte Externa
0
0
32
Light Show Brasil
Espírito de Natal
Espírito de Natal
09 de jan. de 2025
In Código Teste Fita de LED RGB
Esse código controla quatro fitas de LED RGB utilizando o Arduino, alternando sequencialmente as cores de cada fita. Código abaixo: // Pinos RGB da Fita 1 const int fita1Vermelho = 2; const int fita1Verde = 3; const int fita1Azul = 4; // Pinos RGB da Fita 2 const int fita2Vermelho = 5; const int fita2Verde = 6; const int fita2Azul = 7; // Pinos RGB da Fita 3 const int fita3Vermelho = 8; const int fita3Verde = 9; const int fita3Azul = 10; // Pinos RGB da Fita 4 const int fita4Vermelho = 11; const int fita4Verde = 12; const int fita4Azul = 13; void setup() { // Configura os pinos como saída pinMode(fita1Vermelho, OUTPUT); pinMode(fita1Verde, OUTPUT); pinMode(fita1Azul, OUTPUT); pinMode(fita2Vermelho, OUTPUT); pinMode(fita2Verde, OUTPUT); pinMode(fita2Azul, OUTPUT); pinMode(fita3Vermelho, OUTPUT); pinMode(fita3Verde, OUTPUT); pinMode(fita3Azul, OUTPUT); pinMode(fita4Vermelho, OUTPUT); pinMode(fita4Verde, OUTPUT); pinMode(fita4Azul, OUTPUT); } void loop() { // Alterna entre diferentes cores em todas as fitas setColor(fita1Vermelho, fita1Verde, fita1Azul, 255, 0, 0); // Fita 1: Vermelho setColor(fita2Vermelho, fita2Verde, fita2Azul, 0, 255, 0); // Fita 2: Verde setColor(fita3Vermelho, fita3Verde, fita3Azul, 0, 0, 255); // Fita 3: Azul setColor(fita4Vermelho, fita4Verde, fita4Azul, 255, 255, 0); // Fita 4: Amarelo delay(1000); setColor(fita1Vermelho, fita1Verde, fita1Azul, 0, 255, 255); // Fita 1: Ciano setColor(fita2Vermelho, fita2Verde, fita2Azul, 255, 0, 255); // Fita 2: Magenta setColor(fita3Vermelho, fita3Verde, fita3Azul, 255, 255, 255); // Fita 3: Branco setColor(fita4Vermelho, fita4Verde, fita4Azul, 0, 0, 0); // Fita 4: Desligado delay(1000); } // Função para definir a cor de uma fita de LED RGB void setColor(int corVermelha, int corVerde, int corAzul, int vermelho, int verde, int azul) { analogWrite(corVermelha, vermelho); analogWrite(corVerde, verde); analogWrite(corAzul, azul); } Explicação do código: Este código para Arduino controla quatro tiras de LED RGB, permitindo que você alterne entre cores diferentes usando a função analogWrite(). A seguir, explicamos cada parte do código em detalhes: 1. Definição dos pinos das fitas RGB // Pinos RGB da Fita 1 const int fita1Vermelho = 2; const int fita1Verde = 3; const int fita1Azul = 4; // Pinos RGB da Fita 2 const int fita2Vermelho = 5; const int fita2Verde = 6; const int fita2Azul = 7; // Pinos RGB da Fita 3 const int fita3Vermelho = 8; const int fita3Verde = 9; const int fita3Azul = 10; // Pinos RGB da Fita 4 const int fita4Vermelho = 11; const int fita4Verde = 12; const int fita4Azul = 13; • São declaradas constantes (const int) que definem os pinos digitais do Arduino conectados aos canais R , G  e B  de cada fita RGB. • Cada fita possui três pinos: um para a cor vermelha, um para a verde e outro para a azul. 2. Configuração inicial dos pinos no setup() void setup() { // Configura os pinos como saída pinMode(fita1Vermelho, OUTPUT); pinMode(fita1Verde, OUTPUT); pinMode(fita1Azul, OUTPUT); pinMode(fita2Vermelho, OUTPUT); pinMode(fita2Verde, OUTPUT); pinMode(fita2Azul, OUTPUT); pinMode(fita3Vermelho, OUTPUT); pinMode(fita3Verde, OUTPUT); pinMode(fita3Azul, OUTPUT); pinMode(fita4Vermelho, OUTPUT); pinMode(fita4Verde, OUTPUT); pinMode(fita4Azul, OUTPUT); } • Na função setup(), todos os pinos digitais são configurados como saída utilizando a função pinMode(). • Isso permite que o Arduino envie sinais PWM (Pulse Width Modulation) para controlar a intensidade de cada cor das fitas RGB. 3. Loop principal do programa void loop() { // Alterna entre diferentes cores em todas as fitas setColor(fita1Vermelho, fita1Verde, fita1Azul, 255, 0, 0); // Fita 1: Vermelho setColor(fita2Vermelho, fita2Verde, fita2Azul, 0, 255, 0); // Fita 2: Verde setColor(fita3Vermelho, fita3Verde, fita3Azul, 0, 0, 255); // Fita 3: Azul setColor(fita4Vermelho, fita4Verde, fita4Azul, 255, 255, 0); // Fita 4: Amarelo delay(1000); setColor(fita1Vermelho, fita1Verde, fita1Azul, 0, 255, 255); // Fita 1: Ciano setColor(fita2Vermelho, fita2Verde, fita2Azul, 255, 0, 255); // Fita 2: Magenta setColor(fita3Vermelho, fita3Verde, fita3Azul, 255, 255, 255); // Fita 3: Branco setColor(fita4Vermelho, fita4Verde, fita4Azul, 0, 0, 0); // Fita 4: Desligado delay(1000); } • A função loop() é executada continuamente pelo Arduino. • Na primeira parte, são definidas cores diferentes para cada fita: • Fita 1: Vermelho (255, 0, 0) • Fita 2: Verde (0, 255, 0) • Fita 3: Azul (0, 0, 255) • Fita 4: Amarelo (255, 255, 0) • Após definir as cores, há um atraso de 1000 ms (1 segundo) utilizando a função delay(1000). • Na segunda parte, as cores das fitas mudam novamente: • Fita 1: Ciano (0, 255, 255) • Fita 2: Magenta (255, 0, 255) • Fita 3: Branco (255, 255, 255) • Fita 4: Desligado (0, 0, 0) • Outro atraso de 1 segundo ocorre antes de o processo se repetir. 4. Função void setColor() • A função setColor() recebe como parâmetros: • Os pinos correspondentes às cores vermelha, verde e azul de uma fita. • Os valores de intensidade para cada cor (vermelho, verde e azul) variando de 0 a 255. • A função analogWrite() gera um sinal PWM nos pinos, ajustando a intensidade de cada cor. • 255 representa intensidade máxima. • 0 representa a cor completamente apagada. Resumo do funcionamento 1. O código alterna as cores das fitas a cada segundo, utilizando a função setColor() para definir as cores de cada fita. 2. A função analogWrite() permite gerar variações de brilho em cada canal RGB, criando diferentes cores ao combinar as intensidades de vermelho, verde e azul. 3. O ciclo se repete indefinidamente, alternando as cores das fitas RGB em sequência. Tópicos relacionados: 📌 Esquema de Ligação de 4 Fitas de LED RGB 5050 com Arduino
0
0
14
Light Show Brasil
Espírito de Natal
Espírito de Natal
09 de jan. de 2025
In 4 Canais RGB com Arduino
Passo a passo para montagem do circuito de controle de 4 fitas RGB com Arduino Este circuito permite controlar 4 fitas RGB usando Arduino UNO ou MEGA e transistores TIP120. A seguir, explicaremos em detalhes como montar o circuito: Imagem com demonstração detalhada abaixo: Download do esquema em PDF abaixo: 📂 Esquema de Ligação de Fita de LED RGB 5050 no Arduino PDF Materiais necessários: • 1x Arduino UNO • 1x Fonte de alimentação 12V 5A • 4x Fitas de LED RGB 12V • 12x Transistores TIP122 • 12x Resistores de 1kΩ (1/4W) • 1x Protoboard • 1x Plugue de Tomada Macho • Varios Jumpers macho-macho Passo 1: Conectar a fonte de alimentação 12V 1. No lado de saída da fonte de 12V, conecte: • O terminal V+  ao barramento positivo (+) da protoboard. • O terminal V-  ao barramento de GND  da protoboard. • Conecte o pino GND do Arduino ao barramento de GND da protoboard. Passo 2: Conectar as fitas RGB à protoboard 1. Conecte os terminais positivos das fitas RGB ao terminal positivo (V+) da fonte de alimentação 12V. 2. Cada fita RGB possui três terminais para os canais de cor: R (vermelho), G (verde) e B (azul). 3. Conecte a base (pino do meio) de cada transistor ao terminal correspondente da fita LED RGB: • Fita 01: • Coletor do primeiro transistor → Terminal R (vermelho) da fita 01. • Coletor do segundo transistor → Terminal G (verde) da fita 01. • Coletor do terceiro transistor → Terminal B (azul) da fita 01. • Fita 02: • Coletor do quarto transistor → Terminal R (vermelho) da fita 02. • Coletor do quinto transistor → Terminal G (verde) da fita 02. • Coletor do sexto transistor → Terminal B (azul) da fita 02 • Fita 03: • Coletor do sétimo transistor → Terminal R (vermelho) da fita 03. • Coletor do oitavo transistor → Terminal G (verde) da fita 03. • Coletor do nono transistor → Terminal B (azul) da fita 03 • Fita 04: • Coletor do décimo transistor → Terminal R (vermelho) da fita 04. • Coletor do décimo primeiro transistor → Terminal G (verde) da fita 04. • Coletor do décimo segundo transistor → Terminal B (azul) da fita 04 Passo 3: Conectar os transistores TIP120 1. Insira os 12 transistores TIP120 na protoboard, sendo: • 3 transistores para cada fita RGB (1 para cada cor: R, G e B). 2. Conecte os emissores (pino da direita) de todos os transistores ao barramento de GND da protoboard. 3. Ligue a base de cada transistor (pino do meio) ao Arduino por meio de um resistor de 1kΩ , conforme a tabela de pinos: • Fita RGB 01: • Pino 2 (Vermelho), pino 3 (Verde) e pino 4 (Azul). • Fita RGB 02: • Pino 5 (Vermelho), pino 6 (Verde) e pino 7 (Azul). • Fita RGB 03: • Pino 8 (Vermelho), pino 9 (Verde) e pino 10 (Azul). • Fita RGB 04: • Pino 11 (Vermelho), pino 12 (Verde) e pino 13 (Azul). Passo 4: Verificar as conexões 1. Certifique-se de que todos os transistores estão corretamente posicionados, e que os pinos de base, emissor e coletor foram conectados corretamente. 2. Verifique a polaridade dos terminais das fitas RGB e da fonte de alimentação. Finalizado o processo de Montagem! Tópicos relacionados: 📌 Código Sequencial para Fitas de LED RGB com Arduino - 4 Canais RGB 📌 Configuração do Código para Controlar 4 Fitas de LED RGB com Arduino no Vixen Lights
Esquema de Ligação de 4 Fitas de LED RGB 5050 no Arduino content media
0
0
23
Light Show Brasil
Espírito de Natal
Espírito de Natal
09 de jan. de 2025
In Controle 16 Relés no Vixen 3
Passo a passo para configurar o código de comunicação com Arduino e Vixen Lights para controlar módulo de relés 16 canais. Nota: O passo a passo menciona 16 canais, mas você pode ajustar a quantidade de canais conforme a necessidade do seu projeto. Lembre-se de que cada modelo de Arduino possui um limite de pinos disponíveis para conexão com os módulos relés, portanto, verifique se a quantidade de canais desejada está dentro desse limite. Código abaixo: // Número de canais controlados pelo Vixen Lights (16 relés) #define NUM_CANAIS 16 // Pinos dos relés int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3}; // Buffer para armazenar os dados recebidos byte buffer[NUM_CANAIS]; void setup() { // Inicializa a comunicação serial com o Vixen Lights Serial.begin(115200); // Configura os pinos dos relés como saída for (int i = 0; i < NUM_CANAIS; i++) { pinMode(pinosReles[i], OUTPUT); digitalWrite(pinosReles[i], LOW); // Desliga os relés no início } } void loop() { // Verifica se há dados recebidos na porta serial if (Serial.available() >= NUM_CANAIS) { // Lê os dados enviados pelo Vixen Lights Serial.readBytes(buffer, NUM_CANAIS); // Atualiza o estado dos relés de acordo com os dados recebidos for (int i = 0; i < NUM_CANAIS; i++) { if (buffer[i] == 0) { digitalWrite(pinosReles[i], HIGH); // Liga o relé quando o valor for 0 } else { digitalWrite(pinosReles[i], LOW); // Desliga o relé quando o valor for diferente de 0 } } } } Download do código para 16 canais: 📂 Código Para Controle de Relés 16 Canais com Vixen Lights Passo 1: Definir o número de canais (relés) e pinos: #define NUM_CANAIS 16 • Define o número de canais a serem controlados. No caso, são 16 canais (relés). int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3}; • Cria um vetor de inteiros pinosReles[] que armazena os pinos do Arduino onde os 16 relés estão conectados. Os pinos vão de 2 a 13 e de A0 a A3. byte buffer[NUM_CANAIS]; • Cria um vetor de bytes buffer[] que irá armazenar os dados recebidos da comunicação serial. O tamanho do vetor é igual ao número de canais (16). Passo 2: Função setup() - Configuração Inicial A função setup() é executada uma única vez ao iniciar o código e serve para configurar os parâmetros iniciais. Serial.begin(115200); • Inicia a comunicação serial a 115200 bps (bits por segundo). Isso é necessário para enviar e receber dados entre o Arduino e outro dispositivo (como um computador ou controlador de luzes). for (int i = 0; i < NUM_CANAIS; i++) { pinMode(pinosReles[i], OUTPUT); digitalWrite(pinosReles[i], LOW); // Desliga os relés no início } • O código dentro do laço for configura todos os pinos dos relés como saídas. Ele percorre o vetor pinosReles[] e para cada pino, chama a função pinMode() com o parâmetro OUTPUT (configurando o pino como saída). Em seguida, a função digitalWrite() é chamada para garantir que todos os relés comecem desligados (valor LOW). Passo 3: Função loop() - Processamento Contínuo A função loop() é chamada repetidamente, de forma contínua, e é onde o Arduino vai constantemente verificar e processar os dados recebidos. if (Serial.available() >= NUM_CANAIS) { • Verifica se há pelo menos 16 bytes de dados disponíveis na porta serial. Se houver dados suficientes, o código prossegue para a leitura dos dados. Serial.readBytes(buffer, NUM_CANAIS); • Lê os 16 bytes da porta serial e os armazena no vetor buffer[]. Cada byte do buffer irá representar o estado de um relé. Se o byte for 0, o relé será ligado, se for outro valor, o relé será desligado. for (int i = 0; i < NUM_CANAIS; i++) { if (buffer[i] == 0) { digitalWrite(pinosReles[i], HIGH); // Liga o relé quando o valor for 0 } else { digitalWrite(pinosReles[i], LOW); // Desliga o relé quando o valor for diferente de 0 } } 1. O laço for percorre todos os elementos do vetor buffer[] e, dependendo do valor de cada byte: • Se o valor for 0, o relé correspondente é ligado (digitalWrite(pinosReles[i], HIGH)). • Se o valor for diferente de 0, o relé é desligado (digitalWrite(pinosReles[i], LOW)). Resumo do Funcionamento do Código: 1. Configuração Inicial: • O Arduino é configurado para controlar 16 relés, conectados aos pinos especificados no vetor pinosReles[]. • A comunicação serial é iniciada para permitir a troca de dados com um dispositivo externo. 2. Verificação de Dados Serial: • A cada loop, o Arduino verifica se há dados disponíveis na porta serial. • Se houver 16 bytes ou mais, ele lê os dados e os armazena no buffer. 3. Controle dos Relés: • O Arduino percorre os dados no buffer e, para cada byte, decide se o relé correspondente deve ser ligado (valor 0) ou desligado (qualquer valor diferente de 0). 4. Loop Contínuo: • Esse processo é repetido continuamente no loop(), permitindo que o Arduino controle os relés com base nos dados recebidos via serial. Nota: As únicas linhas que você irá alterar nó código são: #define NUM_CANAIS 16 • Quantidade de relés conectado nas portas do Arduino. & int pinosReles[NUM_CANAIS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3}; • Número das portas aonde os relés estão conectados. Concluído com sucesso! • Acesse o próximo tópico abaixo para continuar com o processo. 📌 Configuração do Arduino no Vixen Lights para Controlar 16 Módulos Relés Tópicos relacionados: 📌 Esquema de Ligação de Módulo Relés 16 Canais 5V com Arduino e Fonte Externa 📌 Esquema de Ligação de Módulo Relés 16 Canais 12V com Arduino e Fonte Externa
0
0
72
Light Show Brasil
Espírito de Natal
Espírito de Natal
09 de jan. de 2025
In Controle 8 Relés no Vixen 3
Para baixar o software Vixen Lights 3 acesse o link abaixo: 📂 Vixen Lights 3 Nota: Se você ainda não possui o código, acesse o tópico abaixo para fazer o download e configurá-lo no Arduino. Após concluir essa etapa, retorne a este tópico para continuar o processo. Tópico mencionado acima: 📌 Configuração do Código para Controlar Módulo Relés de 8 Canais com Arduino no Vixen Lights Instruções para adicionar um novo controlador no Vixen Lights e configurar para comunicação com o Arduino: Passo 1: Abra o Vixen Lights: • Inicie o software Vixen Lights no seu computador. • Na página inicial do Vixen Lights, vá até o menu "Setup Display" (Configuração do Display). Passo 2: Adicionando o Controlador Genérico Serial (Arduino): • No menu de configuração do setup display, vá até a aba "Controllers" (Controladores). • No tipo de controlador, selecione "Generic Serial". • Clique no botão "‎‎ + " para adicionar o controlador. • Em "Controller Name" (Nome do Controlador), atribua um nome ao controlador, como por exemplo "Arduino", e clique em OK. • No campo "Controller Output Count" (Contagem de Saídas do Controlador), informe a quantidade de saídas que você está utilizando. No exemplo, utilizaremos 8 saídas, mas você pode ajustar conforme a quantidade de saídas que estiver utilizando. Passo 4: Configurar a Porta Serial e Velocidade da Comunicação Serial: • Após selecionar o controlador Generic Serial (Arduino), clique na engrenajem ⚙️ de configuração que estará na parte inferior na aba Selected Controller (Selecionar Controlador). • Irá abrir uma janela com o nome Generic Serial Configuration (Configuração Serial Genérica). Clique em Setup/Change Serial Port (Configurar/Alterar Porta Serial). • Na próxima janela, em Port Name (Nome da Porta) você selecione a porta serial correspondente ao seu Arduino (pode ser algo como COM3, COM4, ou a porta USB que o Arduino está usando). • Em Baud Rate (Taxa de Transmissão) configure a velocidade de comunicação serial para 115200. Esta é a velocidade que está configurada no seu código Arduino para a comunicação via serial. Serial.begin(115200); Passo 5: Salvar a Configuração: • Após definir a porta serial e a velocidade de comunicação clique em "OK" em todas as janelas para salvar a configuração do controlador. Passo 6: Verificar Conexão: • Após configurar o controlador, o Vixen Lights começará a enviar os dados para o Arduino através da comunicação serial. VID_20250108_213344.mp4 Conclusão Seguindo esses passos, você deve conseguir configurar o Arduino no Vixen Lights com sucesso. Tópicos relacionados: 📌 Ligação de Módulo Relé 8 Canais com Arduino e Fonte Externa 📌 Ligação de Módulo Relé 16 Canais com Arduino UNO/MEGA 📌 Configuração do Arduino no Vixen Lights para Controlar Módulo Relés - 16 Canais
Configuração do Arduino no Vixen Lights para Controlar Módulo Relés - 8 Canais content media
0
0
33
Light Show Brasil
Espírito de Natal
Espírito de Natal
08 de jan. de 2025
In Módulo Relés 16 Canais 5V
Passo a passo de ligação do módulo relé de 16 canais 12V no Arduino: Nota: Antes de seguir o passo a passo, verifique se o seu módulo relé é de 12V ou 5V e certifique-se de que ele seja compatível com a tensão de operação para evitar danos ao módulo e aos controladores conectados. Para identificar a tensão de operação do seu módulo, consulte o tópico abaixo. Tópico mencionado acima: 📌 Diferenças entre os Módulos Relés 16 Canais de 12V e 5V Imagem com demonstração detalhada abaixo: Download do esquema em PDF abaixo: 📂 Esquema de Ligação Módulo Relés 16 Canais 12V com Arduino PDF Materiais necessários • 1x Arduino UNO (ou MEGA) • 1x Módulo Relés 16 canais 12V • 1x Fonte de alimentação 12V • 16x Lâmpadas a serem controladas • 2x Plugues de tomada macho • 1x Cabo USB para o Arduino • Alguns Fios de conexão (Jumpers) Passo 1: Conectar a fonte de alimentação ao módulo relé • Conecte a saída 12V da fonte ao borne VCC do módulo relé. • Conecte o GND da fonte ao borne GND do módulo relé. • Certifique-se de que a fonte de alimentação está conectada corretamente à rede elétrica (127V ou 220V, de acordo com sua rede). Nota: As fontes de alimentação geralmente são bivolt, ou seja, podem operar em 127V ou 220V automaticamente. No entanto, verifique se a fonte que você está utilizando é realmente bivolt. Caso contrário, se for uma fonte com seleção manual de tensão, ela deve possuir uma chave seletora na lateral da carcaça. Certifique-se de que a chave está ajustada corretamente de acordo com a tensão da rede elétrica local antes de ligar a fonte. Passo 2: Fazer a ligação entre o Arduino e o módulo relé • Utilize cabos (Jumpers) para conectar os pinos do Arduino aos pinos de entrada do módulo relé: • PIN 5V do Arduino → 5V do módulo relé • PIN 2 do Arduino → IN1 do módulo relé • PIN 3 do Arduino → IN2 do módulo relé • Continue conectando até o PIN 13 do Arduino , depois utilize os pinos analógicos: • A0 → IN11  ,  A1 → IN12  , A2 → IN13 , A3 → IN14 , A4 → IN15 e A5 → IN16. • PIN GND do Arduino → GND do módulo relé Passo 3: Conectar as lâmpadas ao módulo relé • Para cada canal de relé, faça a seguinte ligação: • Conecte o fio preto (fase) da rede elétrica ao pino COM (comum) do relé. • Conecte o fio vermelho ao pino NA  (normalmente aberto) do relé e ao terminal da lâmpada. • Conecte o fio azul (neutro)  diretamente ao outro terminal da lâmpada. Passo 4: Verificar as conexões • Certifique-se de que todas as conexões estão bem firmes e seguras. • Verifique se a fonte de alimentação está ajustada para a tensão correta da rede elétrica (127V ou 220V). • Após a verificação, conecte a fonte à tomada e o Arduino ao computador via cabo USB. Conclusão Seguindo esses passos, você terá um sistema de controle de lâmpadas usando um Arduino e um Módulo de Relés de 16 canais 12V Corretamente. Lembre-se: ao trabalhar com corrente alternada (AC), é fundamental tomar todas as precauções de segurança. Se precisar de mais detalhes ou ajuda com o código Arduino, vou deixar alguns tópicos relacionados aqui abaixo e caso não ache o que está procurando, sinta-se a vontade para abrir um novo tópico. Tópicos relacionados: 📌 Esquema de Ligação de Módulo Relés 16 Canais 5V com Arduino e Fonte Externa 📌 Esquema de Ligação de Módulo Relés 8 Canais com Arduino e Fonte Externa 📌 Configuração do Código para Controlar Módulo Relés de 16 Canais com Arduino no Vixen Lights
Esquema de Ligação de Módulo Relés 16 Canais 12V com Arduino e Fonte Externa content media
1
9
91
Light Show Brasil
Espírito de Natal
Espírito de Natal
14 de ago. de 2023
In Fita de LED RGB 5050
Passo a passo da ligação de fita LED RGB controlada por Arduino Este diagrama mostra como controlar uma fita de LED RGB usando um Arduino e transistores TIP120. A seguir, explicação abaixo: Materiais necessários • 1x Arduino UNO/Mega • 1x Fita de LED RGB 5050 • 1x Fonte de Alimentação 12V (utilize uma fonte com a amperagem adequada com a potência da sua fita) • 1x Protoboard • 3x Transistores TIP120 NPN • 3x Resistores de 1k ohms 1/4W Passo 1: Conectar a fonte de alimentação 1. Na saída da fonte de alimentação, conecte: • O terminal V+  ao terminal positivo (+) da fita LED RGB. • O terminal V-  ao barramento de GND na protoboard. • Conecte o pino GND  do Arduino ao barramento de GND  na protoboard. Passo 2: Conectar os transistores TIP120 1. Insira três transistores TIP120 na protoboard. 2. Para cada transistor: • Conecte a base do transistor (pino do meio) a um pino digital do Arduino através de um resistor de  220 ohms. • TIP120 1:  Base conectada ao pino 9  do Arduino (controla a cor vermelha). • TIP120 2:  Base conectada ao pino 10  do Arduino (controla a cor verde). • TIP120 3:  Base conectada ao pino 11  do Arduino (controla a cor azul). • Conecte o emissor (pino da direita) de cada transistor ao GND  da protoboard. • Conecte o coletor (pino da esquerda) de cada transistor ao terminal correspondente da fita LED RGB: • Coletor do primeiro transistor → Terminal R  (vermelho) da fita. • Coletor do segundo transistor → Terminal G (verde) da fita. • Coletor do terceiro transistor → Terminal B  (azul) da fita. Passo 4: Verificar as conexões 1. Certifique-se de que todas as conexões estão corretas e firmes. 2. Verifique a polaridade da fita LED RGB, da fonte de alimentação e dos transistores TIP120. Concluído! Seguindo os passos acima tudo irá funcionar corretamente. Tópicos relacionados: 📌 Ligação de 4 Fitas de LED RGB 5050 no Arduino Controle de LED RGB com Arduino no Vixen Lights 3 | Parte 1 Controle de LED RGB com Arduino no Vixen Lights 3 | Parte 2
Ligação Fita de LED RGB 5050 com Arduino content media
0
0
164
Light Show Brasil
Espírito de Natal
Espírito de Natal
31 de out. de 2021
In Vixen Lights 3
Como sincronizar luzes de natal no vixen lights 3.
0
0
65
Light Show Brasil
Espírito de Natal
Espírito de Natal
12 de jun. de 2020
In Boas Vindas
Sejam todos Bem Vindos ao Fórum Light Show Brasil, aqui compartilhamos experiências sobre Iluminação computadorizada aonde você vai aprender a criar o seu próprio projeto de Iluminação Computadorizada para o final de ano.
Iluminação Computadorizada content media
1
3
206
bottom of page