Pulse-Width Modulation (PWM)

Olá, nesse post iremos conhecer um pouco sobre PWM (Pulse-Width Modulation) ou em português Modulação por largura de pulso (MLP). O arduino tem a nos oferecer saidas analógicas pela qual podemos utilizar a técnica PWM.

Irei utilizar como exemplo o controle de motores de corrente contínua. Com esta técnica podemos controlar a velocidade dos motores, mantendo o torque ainda que em baixas velocidades o que garante partidas suaves mesmo quando há uma carga maior sobre os motores. Aspectos que caracterizam o controle PWM como ideal para aplicações em robótica.

Para entender o princípio do PWM vamos imaginar um circuito como o da figura 1. Neste, temos um interruptor que quando acionado faz com que o motor receba 6V e funcione com 100% de potência. Quando o interruptor não está precionado, o motor não recebe energia e simplesmente não funciona.

Vamos supor que consigamos pressionar e soltar o interruptor um grande número de vezes por segundo, de tal forma que metade do tempo ele fica ligado e metade desligado.  O resultado seria uma onda quadrada como o da figura 2.

No exemplo o tempo t1 corresponde ao tempo que o interruptor fica precionado e t2 o tempo que ele fica livre. Como neste caso t1 é igual a t2, durante a metade do tempo o motor recebe a tensão de 6V e na outra metade ele recebe 0V.  A tensão média, figura 3, aplicada ao motor é neste caso de 3V, ou seja, 50% da tensão da bateria.

É claro que não é possível usar um interruptor em um circuito com PWM, pois não conseguiríamos pressioná-lo na velocidade necessária. Porém o circuito eletrônico do MC 2.5 foi projetado para executar esta tarefa. De fato, o módulo de controle gera cerca de 200 pulsos por segundo.
Para diminuir a velocidade do motor, basta reduzir a largura dos pulsos, mantendo o motor menos tempo ligado, conforme figura 4, neste exemplo o ciclo ativo é de 30% por que o tempo ativo corresponde a 30% do período da onda.

No exemplo ilustrado pela figura 5, o ciclo ativo é de 80%  e o motor irá girar mais rápido que no exemplo anterior.No exemplo ilustrado pela figura 5, o ciclo ativo é de 80%  e o motor irá girar mais rápido que no exemplo anterior.

No LEGAL podemos controlar o ciclo ativo através do comando potência, por exemplo:

potência M1 8

Este comando faz com que o PWM que controla o motor M1 funcione com um ciclo ativo de 80%. O comando potência está melhor explicado em XXXX.

No Arduíno:

Para utilizarmos o PWM no Arduíno, podemos fazer uso do método analogWrite, o qual tem um valor de entrada que vai de 0-255, desse jeito se utilizarmos analogWrite(127), será entendido que queremos 50% dos nossos 5V que o Arduino fornece.

Para melhor entendimento a figura a baixo faz uma demonstração de como podemos utilizar o PWM no Arduíno através do método analogWrite:

Até a próxima!

M. Vitali

 

Fontes consultadas:

http://pt.wikipedia.org/wiki/Modula%C3%A7%C3%A3o_por_largura_de_pulso

http://arduino.cc/it/Tutorial/PWM

 

Sensor de Cor [Materiais+Codigo]

Postei anteriormente como podemos fazer um Sensor de Cor usando um simples LDR e alguns LEDs.

Porém não havia postado o código que devemos gravar no Arduino e os materiais usados.

Então aqui está para quem quer montar um

• 3 Transistores NPN (BC337, BC338, BC547, BC548, etc…)
• 1 Resistor 330Ohm
• 1 Resistor 2,2kOhm
• 3 LEDs RGB de 5mm
• 1 LDR (Photoresistor)

Aqui está o esquema de como deve ser montado a placa (no caso fiz usando uma protoboard, pois é mais simples no programa que uso):

E o código usado no Arduino:

#define PIN_R 13
#define PIN_G 11
#define PIN_B 12
#define PIN_SENSOR 5

int SensorValue=0;

void setup()
{
	Serial.begin(9600);

	pinMode(PIN_R, OUTPUT);
	digitalWrite(PIN_R, LOW);

	pinMode(PIN_G, OUTPUT);
	digitalWrite(PIN_G, LOW);

	pinMode(PIN_B, OUTPUT);
	digitalWrite(PIN_B, LOW);
}

void loop()
{
	digitalWrite(PIN_R, HIGH);
	delay(100);
	Serial.print(analogRead(PIN_SENSOR));
	Serial.print(" ");
	digitalWrite(PIN_R, LOW);

	digitalWrite(PIN_G, HIGH);
	delay(100);
	Serial.print(analogRead(PIN_SENSOR));
	Serial.print(" ");
	digitalWrite(PIN_G, LOW);

	digitalWrite(PIN_B, HIGH);
	delay(100);
	Serial.print(analogRead(PIN_SENSOR));
	Serial.print(" ");
	digitalWrite(PIN_B, LOW);

	Serial.print("\n");

	delay (1000);
}

[]‘s

Sensor de Cor

Eu estava precisando saber as cores de determinados objetos, mas como fazer isso?

Pesquisei na internet, achei alguns componentes que fazem essa leitura, mas são caros, difíceis de encontrar e são encontrados em sites gringos, ou seja o frete é caro demais para um componente de 1 ou 2 gramas e demorado para chegar.

Nessas condições fui obrigado a fuçar e pesquisar a respeito de gambiarras rs, cheguei a seguinte conclusão,
de usar um photoresistor (LDR) para descobrir a cor, para esse projeto eu usei o Arduino Duemilinove pois estava com ele parado e é bem fácil e prático de trabalhar com ele.

Veremos agora um pouco da física, do que é necessário saber para entendermos o funcionamento de um Sensor de Cor:

Todos sabemos que a luz branca é a união das cores primárias:

Cores primárias para quem não se lembra é o famoso RGB (Vermelho(Red), Verde(Green), Azul(Blue)).

O que acontece é, quando a luz chega em um objeto azul por exemplo, será refletido apenas a luz azul:

No caso de um objeto vermelho, será refletido apenas a cor vermelha, e assim sucessivamente, para podermos saber que cor é o objeto, usaremos as cores básicas para iluminar o objeto e captarmos os dados do nosso photoresistor (LDR). Para iluminar o objeto usei o LED RGB, que possui uma alta intensidade luminosa, chegando a quase 8000 mcd.

Nosso LED RGB:

Até aqui tudo certo, mas temos um problema, se você testar cada cor do LED com o LDR, verá que uma cor possue um brilho maior que a outra, e como podemos resolver isso? Vamos usar uma cartolina branca (de preferencia) colocarmos ela a uma determinada distancia do LDR, lembrando que essa distancia deve ser +/- igual a que os objetos ficaram do Sensor. E guardaremos os dados de cada cor do LED, mas por que isso?

A cartolina sendo branca retorna todas as cores, sendo assim quando o LED vermelho por exemplo acender ele retorna todo o vermelho, e teremos +/- o valor ideal captado pelo sensor, usaremos esses valores da calibração para normalizarmos os valores que receberemos dos objetos coloridos.

Vamos ver um exemplo de como faremos essa normalização:

Colocamos a nossa cartolina branca na frente do sensor e guardamos os valores obtidos, por exemplo:

Vermelho:  942.0f         -      Verde: 955.0f        -       Azul: 916.0f

(Aqui podemos ver com a cartolina branca que o verde possui um brilho maior que o azul e vermelho, e o vermelho maior que o azul, isso não pode acontecer, temos que igualar esses “brilhos” rs)

Agora colocaremos uma cartolina azul na frente do sensor e obtemos o valor (lido pelo LDR):

Vermelho:  1004.0f         -      Verde: 994.0f        -       Azul: 934.0f

Agora usaremos nossos valores da calibração com os valores lidos e calcularemos o valor correto da cor do objeto, usando a seguinte fórmula:

Math.round(255.0f*(1024.0f-(float)CorLida[i])/(1024.0f-(float)CorCalibracao[i]))

(O Math.roud é uma função que arredonda o valor, está em Java)

Se jogarmos nossos valores na fórmula iremos obter:

Vermelho:  62.0f         -      Verde: 111.0f        -       Azul: 213.0f

Agora podemos ver que está correto, o azul está com o valor maior que todos e se procuramos em uma tabela de cores (pode ser na do paint) obteremos uma cor azul.

(Foi usado o editor de cores do paint)

É isso galera, espero que tenham gostado, qualquer duvida só postar aqui que irei tira-las

Fica algumas fotos e o video!

[]‘s