Controlando LED RGB com Raspberry Pi

Não abandonei o meu querido amigo RPi. Aliás, de tanto gostar, até arrumei uns amigos pra ele.

Mesmo tendo apenas um pino PWM (à partir da versão 0.5.2 do RPi.GPIO isso passa a ser um mito) dá pra controlar as cores de um LED RGB usando o RPi com facilidade. O processo é basicamente o mesmo de qualquer lógica para acender LEDs comuns: cátodo no negativo, ânodo no positivo e corrente passando por eles. Como não temos pinos PWM disponíveis para controlar cada cor, então podemos optar pelas cores primárias e secundárias, gerando assim 7 cores, dispensando o uso do PWM.

Para implementar isso teremos que considerar como as cores serão obtidas: cada pino pode assumir o estado ligado e desligado. Dessa maneira, com 3 pinos representando as três cores primárias, dá pra conseguir o seguinte:

R	G	B	Cor
1	0	0	Vermelho
1	1	0	Amarelo
1	1	1	Branco
0	1	1	Ciano
0	0	1	Azul
1	0	1	Magenta
0	1	0	Verde

Agora é só criar uma coleção (array) com esses valores:

cores = [[1,0,0],[1,1,0],[1,1,1],[0,1,1],[0,0,1],[1,0,1],[0,1,0]]

Onde 1 vai servir de True e 0 vai servir de False. Note que estou usando LEDs com ânodo comum, ou seja: essa tabela, pra mim, deverá ser invertida para que as cores correspondam exatamente ao que será lido na coleção.

Para o laço de repetição, posso decidir se quero que as cores se apresente aleatoriamente ou uma depois da outra. Vou fazer das duas maneiras, criando um código, ao pressionar ENTER, o programa termine, porém, antes, percorra toda a coleção e exiba suas cores na ordem em que foram catalogadas. Adicionalmente, sempre que o programa iniciar, as cores serão percorridas também. Vamos ao código:

#Bibliotecas utilizadas:
#RPi.GPIO: para manipular os pinos
#time: fornece controle do tempo
#random: gera números aleatórios
#sys: captura comunicação do sistema
#select:

import RPi.GPIO as io, time, random, sys, select

io.setmode(io.BCM) #use io.BOARD para se orientar pelo número do pino

R = 24 #Cor vermelha no GPIO24
G = 23 #Cor verde no GPIO23
B = 22 #Cor azul no GPOI22

#Tabela de cores
anodo = [[0,1,1],[0,0,1],[0,0,0],[1,0,0],[1,1,0],[0,1,0],[1,0,1]]
catodo = [[1,0,0],[1,1,0],[1,1,1],[0,1,1],[0,0,1],[1,0,1],[0,1,0]]
cores = anodo

#Configura os pinos para enviar dados (a voltagem) quando ativado
io.setup(R, io.OUT)
io.setup(G, io.OUT)
io.setup(B, io.OUT)

#Altera as voltagens dos pinos para alterar a cor exibida pelo LED
def toColor(r, g, b, t):
  io.output(R, r)
  io.output(G, g)
  io.output(B, b)
  time.sleep(t) #aguarda tempo = t
  
#Percorre as cores de 0 até 6
def toScale():
for i in range(0,6):
toColor(cores[i][0], cores[i][1], cores[i][2], 0.125)

#Roda o programa até que ENTER seja pressionado
toScale()
roda = True
while roda:
  cor = random.randint(0, 6)
  toColor(cores[cor][0], cores[cor][1], cores[cor][2], 1)
  
  if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
    roda = False
    toScale()
print("Até")
io.cleanup()

Pronto, nenhum mistério. Os comentários no código explicam o que cada seção faz, aí fica fácil entender e, também, modificar, para ficar mais próximo daquilo que você quer.

O Circuito

Os componentes usados são:
- 1 LED RGB
- 3 resistores de aproximadamente 300ohms (270, 330...)
- Raspberry Pi

Os resistores serão conectados aos pinos correspondentes e, na outra ponta, as pernas do LED relativas a cor, conforme o código-fonte. O ânodo será conectado ao pino de 3.3v caso seu LED seja do tipo cátodo comum. Se for do tipo ânodo comum, ligue essa perna em algum terra.