programas de arduino con rgb

Programa, que lee los datos del potenciómetro mediante el puerto serie (sin usar un LED) y lo muestra en el equipo.// http://www.fibidi.com/?p=321 // void setup() { Serial.begin(9600); // initialize serial communication at 9600 bits per second} void loop() { int sensorValue = analogRead(A0); // read the input on analog pin 0 Serial.println(sensorValue); // print out the value you read delay(1); // delay in between reads for stability} // http://www.fibidi.com/?p=321 //

Programa, que lee los datos del potenciómetro (en el rango de 0 a 1.023), los ajusta a la gama de puertos PWM (0-255) y controla el brillo de la luz LED.

// http://www.fibidi.com/?p=321 // int led = 6; int i; void setup() { Serial.begin(9600); pinMode(led, OUTPUT);} void loop() { int sensorValue = analogRead(A0); i = map(sensorValue, 0, 1023, 0, 255); Serial.println(i); analogWrite(led, i); delay(1); } // http://www.fibidi.com/?p=321 //

Programa, en el que cada uno de los colores (rojo, verde, azul) está soportado por un potenciómetro separada. Cada uno de los valores de los colores se configuran de forma independiente. Esto le permite obtener más de 16,5 millones de combinaciones de colores.

// http://www.fibidi.com/?p=321 //int red = 6; int green = 5; int blue = 3; int i,j,k; void setup() { Serial.begin(9600); pinMode(red, OUTPUT); pinMode(green, OUTPUT); pinMode(blue, OUTPUT);} void loop() { int sensorred = analogRead(A0); i = map(sensorred, 0, 1023, 0, 255); Serial.print(i); Serial.print(" "); analogWrite(red, i); int sensorgreen = analogRead(A1); j = map(sensorgreen, 0, 1023, 0, 255); Serial.print(j); Serial.print(" "); analogWrite(green, j); int sensorblue = analogRead(A2); k = map(sensorblue, 0, 1023, 0, 255); Serial.print(k); Serial.print(" "); analogWrite(blue, k); delay(1); Serial.println();}

Fritzing = spiffy

Yo estaba teniendo un montón de problemas para visualizar lo que tengo que hacer para conseguir algunas de las cosas que quiero crear todo improvisado correctamente en un circuito , por no hablar de saber qué partes de lo que necesito. Encontré este sitio impresionante , Fritzing.org que realmente ayuda ! Puede descargar el programa, el cual le permite hacer diseños que buscan Super Slick visualmente ( o como un esquema , si eso es más fácil para usted !) . Así que al menos ahora puedo hacer circuitos de aspecto profesional para demostrar que ustedes , y espero que alguien me puede decir si van a hacer teh asplode robut o no! Para conseguir la caída de ella , hice un esquema para un pequeño circuito que me puse a jugar con un LED RGB .

Esquema después de la protuberancia !

Sketch Muestra Arduino

Este bosquejo pulsa los canales RGB en un LED a un ritmo diferente . Botón 1 : te permite alternar los canales dentro y fuera , y el Botón 2 cambia la intensidad máxima permitida.

Para hacer esto es necesario :

Arduino Uno

Una placa

1 RGB LED

10 cables

Cinco 330 ohm resistencias

Dos pulsadores

El diseño de su tablero como esto ( gracias Fritzing ) !

Aquí está el código para el pequeño circuito.

/*This lets you mess with an RGB LED and Two buttons.It is curently set up so that the brightness fluctuatesCycles through the colors of a RGB LED

Based on RGB_LED_Color_Fade_Cycle.pdeWritten for SparkFun Arduino Inventor's Kit CIRC-RGB

*//* VERBOSE? Prints to serial monitor */const boolean VERBOSE = true;// LED leads connected to PWM pinsconst int RED_LED_PIN = 3;const int GREEN_LED_PIN = 5;const int BLUE_LED_PIN = 6;/* Button pins */const int BTN_1_PIN = 8;const int BTN_2_PIN = 9;

/* Thresholds for intensity of LED */

const int MAX_INTENSITY = 255; //Full brightnessconst int MIN_INTENSITY = 5; //Minimum Brightness

// Used to store the current intensity level of the individual LEDsint redIntensity = 0;int greenIntensity = 0;int blueIntensity = 0;// All of those levels are controlled by this one. See the loop code.int intensity = 255;//Channel on/off state - 0 = off, 1 = onint redState = 1;int greenState = 1;int blueState = 1;//The bounced the master intensity between MIN_ and MAX_INTENSITYint dir = -1;//This variables represents time - +1 each tick. Used for Trig.int t = 0;

// Length of time we spend showing each colorconst int DISPLAY_TIME = 50; // In milliseconds

/* States to toggle thru RGB on/off */int states[6][3] = {{0,0,1},{0,1,0},{0,1,1},{1,0,0},{1,0,1},{1,1,1}};int currState = 5; //Set to the one above, all colors on.int numStates =6;

//Used to cause the button to make an action once each time it is pressed.boolean btn1_DOWN = false;//SETUP THE BUTTONSvoid setup() {Serial.begin(9600);pinMode(BTN_1_PIN, INPUT);pinMode(BTN_2_PIN, INPUT);}

void loop() {int btn1 = digitalRead(BTN_1_PIN);int btn2 = digitalRead(BTN_2_PIN);

/*Change active colorsOnly do this once each time the button is pressed and released*/if(btn1 == LOW) {btn1_DOWN = true;

} else if(btn1 == HIGH){

if(btn1_DOWN == true) {

btn1_DOWN = false;

currState++;

if (currState == numStates) {currState = 0;}

redState = states[currState][0];greenState = states[currState][1];blueState = states[currState][2];

if (VERBOSE) {Serial.print("::: redState ");Serial.print(redState);Serial.print(" greenState ");Serial.print(greenState);Serial.print(" blueState ");Serial.print(blueState);Serial.println();}}}/*CHANGE INTENSITYChanged continuously while button is pressed.*/if(btn2 == LOW) {if (dir == -1) {intensity-=5;if(intensity <= MIN_INTENSITY) {intensity = MIN_INTENSITY;dir = 1;}} else {intensity+=5;if(intensity >= MAX_INTENSITY) {intensity = MAX_INTENSITY;dir = -1;}}if (VERBOSE) {Serial.print(" INTENSITY::");Serial.print(intensity);Serial.println();}}//Use trig functions to make the channels pulse at different rates.redIntensity = abs(int(intensity * sin(t*0.01)));

greenIntensity = abs(int(intensity * cos(t*0.02)));blueIntensity = abs(int(intensity * sin(t*0.03)));analogWrite(RED_LED_PIN, redIntensity * redState);analogWrite(GREEN_LED_PIN, greenIntensity * greenState);analogWrite(BLUE_LED_PIN, blueIntensity * blueState);

delay(DISPLAY_TIME);t++;

}

.

Led RGB I

En esta nueva práctica vamos a trabajar con un led RGB, mediante el cual vamos a explicar las entradas

digitales. Además, jugaremos con él en programación, introduciendo las estructuras de control if y for

Existen dos tipos de led RGB: los de dos patas que llevan integrado un circuito de control y los

de cuatro patas. Nosotros trabajaremos con los últimos.

Estos led RGB son, en realidad, como si hubiéramos metido tres leds en una misma cápsula, uno rojo (red),

otro verde (green) y otro azul (blue). Poseen 4 patillas, pudiendo tener 3 ánodos para los tres colores (rojo,

azul y verde) y un cátodo común, o bien, 3 cátodos para cada color y un ánodo común, usaremos los

primeros. Combinando los tres colores (adicción), en sus diferentes luminosidades, podemos obtener una

gran gama de colores. Para variar la luminosidad hay que jugar con la intensidad, pero eso lo veremos en la

siguiente práctica. De momento nos conformaremos con los tres colores primarios y sus combinaciones.

Vamos a programar la siguiente sucesión:

1. Rojo – Verde – Azul x5

2. (R+V=Amarillo) – (R+A=Magenta) – (V+A=Cían) x5

3. (R+V+A=Blanco)

/*Led RGBRealiza una sucesión de color mediante un led RGB.*/ int ledRojo = 9; //Declaro pin para cátodo del rojoint ledVerde = 10; //Declaro pin para cátodo del verdeint ledAzul = 11; //Declaro pin para cátodo del azul void setup() {pinMode(ledRojo, OUTPUT); //Configuro el pin 9 como salidapinMode(ledVerde, OUTPUT); //Configuro el pin 10 como salidapinMode(ledAzul, OUTPUT); //Configuro el pin 11 como salida} void loop() {for(int i=0;i<6;i++){ //Bucle de 5 repeticionesdigitalWrite(ledRojo, HIGH); //Enciendo led rojodelay(200); //Espero 200msdigitalWrite(ledRojo, LOW); //Apago led rojodigitalWrite(ledVerde, HIGH); //Enciendo led verdedelay(200); //Espero 200msdigitalWrite(ledVerde, LOW); //Apago led verdedigitalWrite(ledAzul, HIGH); //Enciendo led azuldelay(200); //Espero 200msdigitalWrite(ledAzul, LOW); //Apago led azul}for(int i=0;i<6;i++){ //Bucle de 5 repeticionesdigitalWrite(ledRojo, HIGH); //Enciendo led rojodigitalWrite(ledVerde, HIGH); //Enciendo led verdedelay(200); //Espero 200msdigitalWrite(ledRojo, LOW); //Apago led rojodigitalWrite(ledVerde, LOW); //Apago led verdedigitalWrite(ledRojo, HIGH); //Enciendo led rojodigitalWrite(ledAzul, HIGH); //Enciendo led azuldelay(200); //Espero 200msdigitalWrite(ledRojo, LOW); //Apago led rojodigitalWrite(ledAzul, LOW); //Apago led azuldigitalWrite(ledVerde, HIGH); //Enciendo led verdedigitalWrite(ledAzul, HIGH); //Enciendo led azuldelay(200); //Espero 200ms

digitalWrite(ledVerde, LOW); //Apago led verdedigitalWrite(ledAzul, LOW); //Apago led azul}digitalWrite(ledRojo, HIGH); //Enciendo led rojodigitalWrite(ledVerde, HIGH); //Enciendo led verdedigitalWrite(ledAzul, HIGH); //Enciendo led azuldelay(3000); //Espero 3segdigitalWrite(ledRojo, LOW); //Apago led rojodigitalWrite(ledVerde, LOW); //Apago led verdedigitalWrite(ledAzul, LOW); //Apago led azul}

Lo único nuevo que hay en este programa son los bucles for. Se usan para repetir un conjunto de sentencias

encerradas entre llaves un número determinado de veces.

Este tipo de bucle posee tres partes: for (iniciación; condición; incremento){…}. La iniciación solo se ejecuta la

primera vez, y es donde se declara el valor de la variable que va ha hacer de contador. Antes de ejecutar el

bloque, revisa si se cumple la condición, si se cumple, lo ejecuta, si no, no. Y cada vez que se ejecuta

el bloque, incrementa un valor determinado (incremento) a la variable contador.

Ahora vamos a realizar la siguiente variante:

Con este nuevo montaje vamos a introducir las entradas digitales y un concepto asociado a ellas, las

resistencias Pull-Down. Para ello vamos a añadir tres pulsadores al montaje anterior, cada uno de ellos va a

encender un color cuando se pulse.

Los pines del 1 al 13 se pueden configurar como entradas (INPUT) o como salidas (OUTPUT) con pinMode.

Arduino interpreta las entradas de la siguiente manera:

+5V → 1 (lógico) = HIGH

0V → 0 (lógico) = LOW

Es decir, si estamos aplicando una tensión de +5V a una entrada, lo interpreta como 1 (high) y si la llega 0V

lo interpreta como 0 (low). Sin embargo, aunque dejemos de aplicar tensión a una entrada, es posible que la

llegue ruido y no lo interprete como 0 (low). Para ello se añade una resistencia entre la entrada y tierra (GND)

que absorbe los posibles ruidos, esta resistencia se llama Pull-Down.

Como se puede observar, hemos colocado tres resistencia pull-down de 10KΩ junto con los tres pulsadores.

Veamos como se leen las entradas digitales:

/*Led RGBControla cada color del led RGB con un pulsador.*/ //Variables estáticasint ledRojo = 9; //Declaro pin para cátodo del rojoint ledVerde = 10; //Declaro pin para cátodo del verdeint ledAzul = 11; //Declaro pin para cátodo del azulint pulsador1 = 5; //Declaro pin para el pulsador1int pulsador2 = 6; //Declaro pin para el pulsador2int pulsador3 = 7; //Declaro pin para el pulsador3//Variables dinámicasint estado1; //Inicializo la variable de estado1int estado2; //Inicializo la variable de estado2int estado3; //Inicializo la variable de estado3 void setup() {pinMode(ledRojo, OUTPUT); //Configuro el pin 9 como salidapinMode(ledVerde, OUTPUT); //Configuro el pin 10 como salidapinMode(ledAzul, OUTPUT); //Configuro el pin 11 como salidapinMode(pulsador1, INPUT); //Configuro el pin 5 como entradapinMode(pulsador2, INPUT); //Configuro el pin 6 como entradapinMode(pulsador3, INPUT); //Configuro el pin 7 como entrada} void loop() { estado1 = digitalRead(pulsador1); //Lee el estado del pin5 y lo almacena estado2 = digitalRead(pulsador2); //Lee el estado del pin6 y lo almacena estado3 = digitalRead(pulsador3); //Lee el estado del pin7 y lo almacena if(estado1 == HIGH){ //Si el pulsador1 está pulsado digitalWrite(ledRojo, HIGH); //Enciende led rojo } else{ //Si no está pulsado digitalWrite(ledRojo, LOW); //Apaga led rojo } if(estado2 == HIGH){ //Si el pulsador2 está pulsado digitalWrite(ledVerde, HIGH); //Enciende led verde

} else{ //Si no está pulsado digitalWrite(ledVerde, LOW); //Apaga led verde } if(estado3 == HIGH){ //Si el pulsador3 está pulsado digitalWrite(ledAzul, HIGH); //Enciende led azul } else{ //Si no está pulsado digitalWrite(ledAzul, LOW); //Apaga led azul }}

La primera novedad que nos encontramos son las variables dinámicas. En ellas vamos a almacenar el estado

de los pulsadores, es decir, HIGH o LOW. Es recomendable inicializar todas las variables que se vayan a

usar. Como están declaradas fuera de los módulos (setup y loop) van a ser variables globales y las vamos a

poder usar en cualquier módulo.

La segunda novedad es la configuración de un pin como entrada digital mediante pinMode(pin, INPUT). Para

leerla utilizamos digitalRead(pin) y en este caso hemos almacenado el resultado de la lectura en una variable

para su posterior uso.

Por último nos encontramos con la sentencia condicional if(condición){…}else{…}. Si se cumple la condición

que está entre paréntesis se ejecutará un bloque, si no se cumple, se ejecutará otro. En nuestro caso, la

condición era comprobar si el estado del pulsador, que habíamos almacenado en una variable, era HIGH, es

decir, estaba pulsado. Si es cierto, se enciende el led, si no, no.

Con esto terminamos la segunda práctica!

Practica 2 – LED RGB controlado con 3 pulsadores

http://www.guiskas.com/2010/07/practica-2-led-rgb-controlado-con-3-pulsadores/

Para esta practica voy a usar un poco de la practica anterior para poder ver los valores del LED por la pantalla LCD.

La idea fundamental es la de poder controlar el LED RGB con tres pulsadores, cada uno destinado al Rojo, Verde y Azul.

El material que hemos usado son :

1 placa de prototipado ( en mi caso dos) 1 Arduino 1 led RGB 3 pulsadores 1 potenciómetro 3 resistencias de 220Ω 1 resistencia de 10KΩ Nos vamos a centrar en dos partes que son la conexión del led y la

interconexion de los pulsadores. Para la conexión del led he usado este esquema: (NOTA: se que el esquema no es correcto pero ese tema lo tratare en otro

post) He conectado la resistencia a masa y luego cada pata de color a los pines

de conexión 9, 10 y 11 para R, G, y B respectivamente

Luego para controlar la intensidad de cada colo he puesto un interruptor paracada patilla:

/* * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You don't receive a copy of the GNU General Public License along with this * program. You can download it from:<http://www.gnu.org/licenses/gpl-3.0.html> . * If not, see <http://www.gnu.org/licenses/>. */

#include <LiquidCrystal.h>

LiquidCrystal lcd( 5, 6, 7, 8, 12, 13);const int boton1 = 2; //Se declara el pulsador para el Rojoconst int boton2 = 3; //Se declara el pulsador para el Verdeconst int boton3 = 4; //Se declara el pulsador para el Azulconst int ledR = 9; //Declaramos la pata Roja del ledconst int ledG = 10; //Declaramos la pata Verde del ledconst int ledB = 11; //Declaramos la pata Azul del ledint R=0; //Iniciamos la variable Rojo a 0int G=0; //Iniciamos la variable Rojo a 0int B=0; //Iniciamos la variable Rojo a 0

void setup() { pinMode(boton1, INPUT); //Iniciamos pin como entrada pinMode(boton2, INPUT); //Iniciamos pin como entrada pinMode(boton3, INPUT); //Iniciamos pin como entrada pinMode(ledR, OUTPUT); //Iniciamos pin como salida pinMode(ledG, OUTPUT); //Iniciamos pin como salida pinMode(ledB, OUTPUT); //Iniciamos pin como salida lcd.begin(16, 2); //Iniciamos el tamaño:

}

void loop() { if(digitalRead(boton1)==HIGH){ //añade +10 a Rojo R=R+10; if (R>255){R=0;} //reinicio de la variable } if(digitalRead(boton2)==HIGH){ //añade +10 a Rojo G=G+10; if (G>255){G=0;} //reinicio de la variable } if(digitalRead(boton3)==HIGH){ //añade +10 a Rojo B=B+10; if (B>255){B=0;} //reinicio de la variable }

analogWrite(ledR,R); //Escritura en el pin ledR analogWrite(ledG,G); //Escritura en el pin ledG analogWrite(ledB,B); //Escritura en el pin ledB lcd.clear(); // Borramos el LCD lcd.setCursor(0, 0); // Situamos el cursos en la primera linea lcd.print("R->"); // Escribimos el texto lcd.print(R); // Escribimos el valor de R lcd.print(" G->"); // Escribimos el texto lcd.print(G); // Escribimos el valor de G lcd.setCursor(0, 1); // Situamos el cursor en la segunda linea lcd.print("B->"); // Escribimos el texto lcd.print(B); // Escribimos el valor de B delay(250);}

BIBLIO

http://robocodes.guiskas.com/20 10/07/practica-2-led-rgb-controlado-con-3-pulsadores/

http://robocodes.guiskas.com/2010/07/practica-2-led-rgb-controlado-con-3-pulsadores/

programas de arduino con rgb

Documents

int led

led rgb

int sensorvalue

int sensorred

const int blue

const int green

const int btn

int ivoid setup