O LED do Arduino pisca suavemente. Controle de brilho do LED usando potenciômetro
Como nascem os programas
Este será um artigo um pouco inusitado, nele tentarei não apenas mostrar um código pronto que faz alguma coisa, mas mostrarei como nasce um dispositivo e o firmware para ele. Veremos a lógica do programa e como construir essa lógica.
Hoje vamos resolver o seguinte problema: são 2 LEDs, eles precisam estar conectados ao Arduino e deve ser realizada a possibilidade de ajustar o brilho de sua iluminação.
Vamos começar!
Em primeiro lugar, precisamos pensar em como será a aparência do nosso dispositivo e o que precisaremos para implementá-lo. Precisamos de algo para ajustar o brilho dos LEDs e ver em que modo os LEDs estão operando no momento. escudo que discutimos no último artigo é ótimo.
Agora só falta conectar os LEDs, o chamado Bradboard é ótimo para isso, é uma coisa de plástico (não sei mais como chamar) na qual você pode conectar fios do Arduino e outros sem soldar componentes eletrônicos, o que é muito conveniente quando você não sabe exatamente como será a aparência dispositivo acabado ou o circuito só é necessário para algumas partidas. Os chineses rebitam um grande número de suas variedades, eu pessoalmente uso esta:
Para ficar mais fácil de entender como funciona por dentro, vou anexar um diagrama das conexões internas: 
Conectando LEDs aArduíno
Muitos dirão agora: o que há de tão difícil em conectar um LED, é uma lâmpada! E eles vão se enganar, um LED está longe de ser uma simples lâmpada, mas sim um dispositivo de iluminação semicondutor. Que não é alimentado por tensão como uma lâmpada normal, mas por corrente, e se a corrente ultrapassar os valores permitidos, o LED começará a degradar, seu brilho diminuirá, o que se tornará perceptível depois de algum tempo, dependendo da potência de a corrente sendo perfurada, ou até mesmo queimar instantaneamente.
Como evitar danos ao LED devido à alta corrente? Tudo é muito simples: é necessário utilizar um resistor limitador de corrente, que deve ser calculado para cada LED dependendo de suas características. O cálculo de resistores para um LED é assunto para um artigo à parte, e hoje não iremos nos aprofundar neste tópico, pois muito provavelmente você não conhece as características do LED que encontrou em algum lugar. Nesse caso, utilizo uma pequena regra: se o LED não estiver brilhante, alimentei-o através de um resistor com resistência de 220 a 400 ohms, dependendo do resistor que estiver disponível. A principal coisa a lembrar é que mais é melhor do que menos. Com mais resistência do que o LED exige, ele simplesmente queimará com menos intensidade do que o normal.
Agora precisamos decidir como ajustar o brilho do LED, para isso você pode usar resistores variáveis, o que a princípio eliminará o ajuste interativo e por isso não usaremos este método neste artigo. Usaremos PWM implementado na placa Arduino.
O que é PWM
PWM ( modulação por largura de pulso) é uma mudança no ciclo de trabalho do sinal durante um determinado período de tempo. O sinal de calço tem a seguinte forma comparado a um sinal constante:
Nesta foto, 100% do ciclo de trabalho é a ausência do PWM propriamente dito, o sinal permanece inalterado, como se a saída estivesse simplesmente conectada a 5 volts.
Ciclo de trabalho de 0% é a ausência de qualquer sinal, como se o fio não estivesse conectado em lugar nenhum.
Os demais modos de operação são uma troca rápida de modos de operação, o que faz com que o LED pisque em alta velocidade invisível ao olho humano (100 vezes por segundo), o que faz com que ele acenda com brilho insuficiente. O Arduino, dependendo da versão do chip utilizado, possui quantidades diferentes Saídas PWM, na placa estão marcadas com o sinal ~ do artigo anterior sabemos que são 6 saídas 3, 5, 6, 9, 10 e 11, usaremos os pinos 10 e 11.
Vamos finalmente conectar os LEDs à placa. Colocamos nosso escudo LCD no Arduino e montamos o seguinte circuito para o qual precisamos de um brainboard, 2 LEDs, 2 resistores de 250 ohms e 3-4 fios macho-macho. O diagrama ficará assim:
E não se esqueça que o LED tem polaridade, a perna longa ou torta do LED (como no diagrama) é um sinal de mais que é conectado através de um resistor.
É aqui que provavelmente terminarei a primeira parte do artigo; na segunda parte trabalharemos na elaboração da lógica do trabalho e na escrita do código do programa. Tudo de bom!
Um potenciômetro é resistor variável, que muda sua resistência quando você gira o botão.
O que é necessário para o projeto:
- Arduino UNO ou qualquer outro analógico
- Conselho de desenvolvimento
- Potenciômetro
- LIDERADO
- Resistor 220 Ohm
Diagrama de conexão em uma placa de ensaio.
Para ajustar o brilho do LED, conectamos-o a um conector que suporta PWM, no nosso caso é o pino digital 3. Conectamos os conectores VCC e GND do potenciômetro aos trilhos de alimentação e aterramento da placa de ensaio. Conector A0 ao pino analógico A0.
Depois de montar o circuito com sucesso, baixe este esboço:
#define LED 3 #define POT A0 void setup() ( pinMode(LED, OUTPUT); // configurando o pino para modo de saída pinMode(POT, INPUT); // configurando o pino para modo de entrada ) void loop() ( / / declara variáveis inteiras int turn, brilho //lê a tensão do potenciômetro em turn, seus valores //variarão de 0 a 1023 turn = analogRead(POT); /dividido por 4. Tomará valores de 0 a 255 brilho = turn / 4 //liga o LED com brilho igual ao valor de brilho analogWrite(LED, brilho);
Agora vamos tentar escrever código para o mesmo circuito, mas em SI puro no ambiente AtmelStudio 7. Ficará assim.
#incluir Agora vamos tentar entender esses dois exemplos. O fato é que o ambiente Arduino foi projetado para um início rápido para iniciantes. Se você precisar piscar um LED ou clicar em um relé, isso pode ser feito em questão de minutos. O ambiente Arduino é totalmente isolado do hardware do microcontrolador e portanto tudo nele é realizado por meio de funções escritas pelos desenvolvedores deste software. Essas funções e seus componentes internos estão ocultos nas profundezas do programa. O usuário médio só pode chamar as funções necessárias para configurar os componentes de hardware do MK. Parece que isso torna a programação muito mais fácil. Em princípio, isso é verdade. Portanto, o ambiente e as placas Arduino são muito populares entre os entusiastas iniciantes do projeto MK. Porém, também existem desvantagens, por exemplo, quem programa Arduino não pode programar microcontroladores que não sejam suportados pelo Arduino IDE. Por exemplo, parece impossível programar qualquer modelo do microcontrolador Attiny AVR. E outros modelos Atmega que não acompanham as placas Arduino também ficam de fora. Em princípio, se os projetos não forem particularmente complexos, então você pode se dar ao luxo, então o ambiente Arduino é suficiente. Se você precisar de algo grande e complexo, então, é claro, regras puras de SI. Mas então você terá que entender os registros MK, como funcionam certos nós MK. Você precisa ler a documentação, estudar e entender o próprio SI. Porém, se você já tem experiência em escrever esboços no ambiente Arduino, com o tempo também será possível entender o SI. Agora vamos tentar olhar o código SI e entender que não é tão assustador. Por exemplo, a linha #incluir DDRC = 0< Essas linhas configuram os pinos da placa Arduino que precisamos como entrada ou saída. PC0 isso é o mesmo que A0 na placa esse pino deve ser configurado como entrada, pois nele está conectado um potenciômetro. E o valor ADC será lido neste pino. Cadastre-se ADMUX E ADCSRA Configuramos o próprio nó ADC no modo que precisamos. Em particular, nós o configuramos para que o ADC leia automaticamente e constantemente o valor da saída A0 e armazene esse valor em um registrador ADCH. O MK possui temporizadores de hardware, estes também são nós que possibilitam trabalhar com pinos PWM, por exemplo, o pino PWM ~3 ao qual o LED está conectado pertence ao interno Temporizador2. Atmega 328 tem mais Temporizador0 E Temporizador1. Então, usando registros TCCR2A E TCCR2B, vamos definir nosso Timer2 para o modo FAST_PWM, isso nos dá a oportunidade de trabalhar com o pino ~3 da placa Arduino. Pois bem, no loop principal do programa transferimos imediatamente o valor do ADC para o nosso Temporizador2. Isso é feito em uma linha OCR2B=ADCH. A única questão é como fazer upload do código escrito em SI para nosso Arduino no AtmelStudio? Isso pode ser feito diretamente no ambiente AtmelStudio. É verdade que antes disso você precisa ler e salvar o bootloader da placa Arduino com o mesmo programador. Caso contrário, a placa Arduino não poderá funcionar com o ambiente Arduino. A qualquer momento, você pode usar o programador para retornar o bootloader ao seu lugar. Neste experimento, adicionamos uma porção de brilho ao LED com um botão e diminuímos com o outro.
A função analogWrite() é utilizada para atenuar o LED e acendê-lo gradativamente. AnalogWrite utiliza modulação por largura de pulso (PWM), que permite que o pino digital ligue/desligue em alta velocidade, gerando um efeito de amortecimento. Conecte o ânodo (perna positiva mais longa) do LED ao pino digital 9 da placa Arduino por meio de um resistor de 220 ohms. Conecte o cátodo (perna mais curta e com carga negativa) ao terra. Após declarar o pino 9 como ledPin, o corpo da função setup() não precisa ser preenchido. A função analogWrite() que você usará no loop principal requer dois argumentos: um para especificar o pino no qual gravar e outro para exibir o valor PWM que está sendo gravado. Para acender e desligar gradativamente o LED, aumente gradativamente o valor do PWM de 0 a 255 e depois volte para 0 para completar o ciclo. No esboço abaixo, o valor PWM é usado para uma variável chamada brilho. Cada vez que o loop é concluído, ele incrementa o valor da variável. Se o brilho atingir seu valor limite (0 ou 255), fadeAmount altera seu valor para negativo. Em outras palavras, se fadeAmount for 5, seu valor muda para -5. Na próxima iteração do loop, isso faz com que a variável de brilho mude. analogWrite() permite que o valor PWM mude rapidamente, de modo que o atraso no final do esboço controle a taxa de decaimento. Tente alterar o valor do atraso e veja o desempenho do programa. Este exemplo mostra como fornecer atenuação no pino 9 usando a função analogWrite(). led interno = 9; //pino ao qual o LED está conectado brilho interno = 0; //Brilho do LED int fadeAmount = 5; // quanto aumentar o brilho do LED // a função setup é executada uma vez após a reinicialização da placa: //declara o pino 9 como saída: pinMode(led, SAÍDA); //loop se repete indefinidamente: // define o brilho do pino 9: analogWrite(led, brilho); // altera o brilho na próxima iteração usando um loop: brilho = brilho + fadeAmount; // altera o valor de atenuação para um valor semelhante com sinal oposto nos valores limite: if (brilho == 0 || brilho == 255) ( fadeAmount = -fadeAmount ; // atraso de 30 para rastrear o efeito fade Agora vamos dar uma olhada no LED multicolorido, que costuma ser chamado de forma abreviada: LED RGB. RGB é uma abreviatura que significa: Vermelho - vermelho, Verde - verde, Azul - azul. Ou seja, três LEDs separados são colocados dentro deste dispositivo. Dependendo do tipo, um LED RGB pode ter um cátodo comum ou um ânodo comum.
conecta o arquivo de cabeçalho no qual nosso MK desejado é selecionado. O ambiente AtmelStudio 7 faz isso automaticamente ao criar um novo projeto.LISTA DE PEÇAS PARA O EXPERIMENTO
- 1 placa Arduino Uno;
- 1 protoboard sem solda;
- 2 botões de relógio;
- 1 resistor com valor nominal de 220 Ohms;
- 1 LED;
- 7 fios macho-macho.
DIAGRAMA DE CIRCUITO
DIAGRAMA NA TABELA DE PÃO
OBSERVE
ESBOÇO
baixar esboço para Arduino IDE
#define PLUS_BUTTON_PIN 2 #define MINUS_BUTTON_PIN 3 #define LED_PIN 9 brilho interno = 100; booleano plusUp = verdadeiro; booleano minusUp = true; void setup() ( pinMode(LED_PIN, OUTPUT); pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP); pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP); ) void loop() ( analogWrite(LED_PIN, brilho); // responde aos cliques usando a função que escrevemos plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35); minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35); // Função própria com 3 parâmetros: o número do pino com o botão // (buttonPin), o estado antes da verificação (wasUp) e gradação // de brilho ao clicar no botão (delta). A função retorna // (retorno em inglês) de volta ao novo estado atual do botão boolean handleClick(int buttonPin, boolean wasUp, int delta) ( boolean isUp = digitalRead(buttonPin); if (wasUp && !isUp) ( delay(10 ); isUp = digitalRead(buttonPin); // se houve um clique, altere o brilho de 0 para 255 if (!isUp) brilho = constrain(brightness + delta, 0, 255 ) return isUp; para o código do chamador)
EXPLICAÇÕES PARA O CÓDIGO
PERGUNTAS PARA TESTAR-SE
TAREFAS PARA SOLUÇÃO INDEPENDENTE
O que você precisará para o projeto
Diagrama de conexão de LED para Arduino
Diagrama de circuito de um LED conectado ao Arduino
Opção de escudo com LED para Arduino
Descrição do programa para Arduino
Esboço para Arduino IDE
1. Misturando cores
Por que um LED RGB é melhor que três convencionais? É tudo uma questão de capacidade da nossa visão de misturar luz de diferentes fontes colocadas próximas umas das outras. Por exemplo, se colocarmos LEDs azuis e vermelhos próximos um do outro, então, a uma distância de vários metros, seu brilho se fundirá e o olho verá um ponto roxo. E se adicionarmos também o verde, o ponto nos parecerá branco. É exatamente assim que funcionam os monitores de computador, televisões e telas externas. A matriz da TV consiste em pontos individuais de cores diferentes. Se você pegar uma lupa e olhar através dela para o monitor ligado, poderá ver facilmente esses pontos. Mas em uma tela externa, os pontos não são colocados muito densamente, para que possam ser distinguidos a olho nu. Mas a uma distância de várias dezenas de metros estes pontos são indistinguíveis. Acontece que quanto mais próximos os pontos multicoloridos estão uns dos outros, menor distância o olho precisa para misturar essas cores. Daí a conclusão: ao contrário de três LEDs separados, a mistura de cores de um LED RGB já é perceptível a uma distância de 30-70 cm. A propósito, um LED RGB com lente fosca tem um desempenho ainda melhor. 2. Conectando um LED RGB ao Arduino
Como o LED multicolorido consiste em três LEDs regulares, iremos conectá-los separadamente. Cada LED está conectado ao seu próprio pino e possui seu próprio resistor separado. Neste tutorial estamos usando um LED RGB com cátodo comum, portanto haverá apenas um fio para terra. Diagrama esquemático
Aparência do layout
3. Programa para controlar um LED RGB
Vamos criar um programa simples que iluminará cada uma das três cores por vez.<3; i++)
pinMode(rgbPins[i], OUTPUT);
}
void loop() {
digitalWrite(rgbPins, LOW);
digitalWrite(rgbPins, HIGH);
delay(500);
digitalWrite(rgbPins, LOW);
digitalWrite(rgbPins, HIGH);
delay(500);
digitalWrite(rgbPins, LOW);
digitalWrite(rgbPins, HIGH);
delay(500);
}
const byte rPin = 3; const byte gPin = 5; const byte bPin = 6; void setup() ( pinMode(rPin, OUTPUT); pinMode(gPin, OUTPUT); pinMode(bPin, OUTPUT); ) void loop() ( // desliga o azul, liga o vermelho digitalWrite(bPin, LOW); digitalWrite( rPin, HIGH); // desliga o vermelho, liga o verde digitalWrite(rPin, LOW); , HIGH); delay(500 ) Carregue o programa no Arduino e observe o resultado. Seu navegador não suporta a tag de vídeo. Vamos otimizar um pouco o programa: em vez das variáveis rPin, gPin e bPin, usaremos um array. Isso nos ajudará nas próximas tarefas.
const byte rgbPins = (3,5,6); void setup() ( for(byte i=0; i
azul<3; i++)
pinMode(rgbPins[i], OUTPUT);
}
void loop() {
// перебираем все шесть цветов
for(int i=0; i<6; i++){
// перебираем три компоненты каждого из шести цветов
for(int k=0; k<3; k++){
digitalWrite(rgbPins[k], rainbow[i][k]);
}
delay(1000);
}
}
В результате работы программы получается:
Your browser does not support the video tag.
azul + vermelho = roxo
Omitimos a cor laranja por simplicidade. Então, acabaram sendo seis cores do arco-íris 🙂 const byte rgbPins = (3,5,6); const byte arco-íris = ( (1,0,0), // vermelho (1,1,0), // amarelo (0,1,0), // verde (0,1,1), // azul ( 0,0,1), // azul (1,0,1), // roxo ); void setup() ( for(byte i=0; i analógicoWrite 5. Mudança suave de cor<3; i++){
pinMode(rgbPins[i], OUTPUT);
}
// начальное состояние - горит красный цвет
analogWrite(rgbPins, 255);
analogWrite(rgbPins, 0);
analogWrite(rgbPins, 0);
}
void loop() {
// гасим красный, параллельно разжигаем зеленый
for(int i=255; i>Não foi à toa que conectamos o LED RGB aos pinos 3, 5 e 6. Como você sabe, esses pinos permitem gerar um sinal PWM de diferentes ciclos de trabalho. Em outras palavras, não podemos apenas ligar ou desligar o LED, mas controlar o nível de tensão nele. Isso é feito usando a função . Vamos fazer com que nosso LED faça a transição entre as cores do arco-íris não de forma abrupta, mas suave.
