Social Icons

4.11) Controlando Led RGB com Arduino e Processing



Vamos a um exemplo de uso da Arduino onde controlo um Led RGB de quatro terminais através da porta serial.
Para enviar as cores através da serial usaremos processing.
Para combinar as cores de um Led RGB é necessário variar a tensão em cada terminal, e para isso a Arduino conta com 6 pinos PWM (Pulse Width Modulation, Modulação por largura de pulso), somente 3 são necessários, pois o quarto terminal deve ser conectado a GND (terra).

No exemplo conectamos os pinos da seguinte forma:
  • Terminal Vermelho no pino 9 (utilizando resistência de 150 Ohm)
  • Terminal Azul no pino 10        (utilizando resistência de 90 Ohm)
  • Terminal Verde no pino 11     (utilizando resistência de 90 Ohm)
  • Terminal terra no pino GND
Obs.: Como não tinha em mãos os resistores liguei os terminais diretamente aos pinos da arduino, mas é importante ressaltar que isso pode danificar o seu led e com certeza reduzir o seu tempo de vida útil.

RGB Led - Arduino + Processing from Bruno Soares on Vimeo.


Espesificação do Led usado:
  • Diâmetro: 5mm.
  • Bulbo: transparente.
  • Intensidade Luminosa: 8000 mcd.
  • Tensão: vermelho = 1.9 ~ 2.4v; verde e azul = 3.2 ~ 3.6v.
  • Corrente: 20mA.
  • Ângulo: 20 ~ 25º.
  • 5mm rgb led color especification
Vamos ao código utilizado na arduino:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/**
 * Controller LED RGB
 */

#define START_COLOR_CHAR '^'
#define END_COLOR_CHAR '$'
#define COLOR_SIZE 8
#define PIN_RED 9
#define PIN_GREEN 11
#define PIN_BLUE 10

char serialMessage[COLOR_SIZE];
unsigned int readChar;
unsigned int count;
unsigned long color;
unsigned int r;
unsigned int g;
unsigned int b;
boolean readingSerial;

void setup() {
  Serial.begin(9600);
  readingSerial = false;
}

void loop() {

  if (Serial.available() > 0 && !readingSerial) {
    if (Serial.read() == START_COLOR_CHAR) {
      serialReadColor();
    }
  }
}

void serialReadColor() {
  readingSerial = true;
  count = 0;
 
  iniReading:
  if (Serial.available() > 0) {
    readChar = Serial.read();
    if (readChar == END_COLOR_CHAR || count == COLOR_SIZE) {
      goto endReading;
    } else {
      serialMessage[count++] = readChar;
      goto iniReading;
    }
  }
  goto iniReading;
 
  endReading:
  readingSerial = false;
  serialMessage[count] = '\0';
 
  setColor(serialMessage);
}

void setColor(char* value)
{
  // Convert Char* to Long
  color = atol(value);
 
  // Extract RGB
  r = color >> 16 & 0xFF;
  g = color >>  8 & 0xFF;
  b = color >>  0 & 0xFF;
 
  // Send values to analog pins
  analogWrite(PIN_RED, r);
  analogWrite(PIN_GREEN, g);
  analogWrite(PIN_BLUE, b);
}


Linha 25) Iniciamos a conexão com a porta serial na velocidade 9600.
Linha 30) Verifica se existe mensagem na porta serial.
Linha 32) Chama o método serialReadColor para iniciar a leitura da serial.
Linha 57) Envia o texto lido entre os caracteres ^ e $ para o método setColor.
Linha 63) Converte o valor obtido para Long.
Linha 66 à 68) Extrai a quantidade de Red, Green e Blue da cor.
Linha 71 à 73) Envia a tensão para os pinos correspondêntes a cada cor.


Conclusão: A Arduino está programada para receber a cor em formato numérico entre dois caracteres que identificam o inicio e o fim da cor (^ para o inicio e $ para o fim). Sendo assim se enviarmos ^16711680$ o LED ficaria vermelho, pois o número 16711680 é o correspondente á 0xFF0000 (hexadecimal).

Agora o código do Processing:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * Controller LED RGB
 */

import processing.serial.*;

Serial port;

void setup() {
  size(100, 150);
  noStroke();
 
  // Background
  colorMode(HSB, 100);
  for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
      stroke(i, j, 100);
      point(i, j);
    }
  }
 
  // Select port
  println(Serial.list());
  port = new Serial(this, Serial.list()[1], 9600);
}

void draw() {
  // Only to enable the method mouseDragged
}

void mouseClicked() {
  processColor();
}

void mouseDragged() {
  processColor();
}

void processColor() {
  color c = get(mouseX, mouseY);
  noStroke();
  fill(c);
  rect(0, 100, 100, 50);
  sendColorToSerial(c);
}

void sendColorToSerial(color colour) {
  // Get HEX
  String hexColor = hex(colour, 6);
 
  // Convert HEC to Number
  long numColor = unhex(hexColor);
 
  // Send color number to serial port
  port.write("^" + numColor + "$");
}

A responsabilidade do Processing é se comunicar com a Arduino via porta serial e enviar as cores, pois com o processing podemos criar um aplicativo onde fica facíl selecionar a cor desejada.
Na linha 50 (método sendColorToSerial), o processing processa o objeto Color, obtendo o seu Hexa, transformando em um número do tipo long, concatenando esse número com os caracteres ^ e $, e finalmente enviando este dado formatado para a porta serial para a Arduino fazer o que está a sua responsabilidade.

Futuramente irei fazer um post somente sobre Processing e suas aplicações específicas e gerais...


geek Responsável :
Sobre: , , , , , , , ,

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)