Programa, que lee los datos del potencimetro 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); at 9600 bits per second } // initialize serial communication

void loop() { int sensorValue = analogRead(A0); analog pin 0 Serial.println(sensorValue); you read delay(1); reads for stability } // http://www.fibidi.com/?p=321

// read the input on // print out the value // delay in between

//

Programa, que lee los datos del potencimetro (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 potencimetro separada. Cada uno de los valores de los colores se configuran de forma independiente. Esto le permite obtener ms de 16,5 millones de combinaciones de colores.

// int int int int

http://www.fibidi.com/?p=321 red = 6; green = 5; blue = 3; 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.<span class="iy8p1qb696i7" id="iy8p1qb696i7_4">print</span>(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 montn 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 diseos que buscan Super Slick visualmente ( o como un esquema , si eso es ms fcil 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 cada de ella , hice un esquema para un pequeo circuito que me puse a jugar con un LED RGB . Esquema despus de la protuberancia ! Sketch Muestra Arduino Este bosquejo pulsa los canales RGB en un LED a un ritmo diferente . Botn 1 : te permite alternar los canales dentro y fuera , y el Botn 2 cambia la intensidad mxima permitida. Para hacer esto es necesario : Arduino Uno Una placa 1 RGB LED 10 cables Cinco 330 ohm resistencias Dos pulsadores El diseo de su tablero como esto ( gracias Fritzing ) ! Aqu est el cdigo para el pequeo circuito.

/* This lets you mess with an RGB LED and Two buttons. It is curently set up so that the brightness fluctuates

Cycles through the colors of a RGB LED Based on RGB_LED_Color_Fade_Cycle.pde Written for SparkFun Arduino Inventor's Kit CIRC-RGB */ /* VERBOSE? Prints to serial monitor */ const boolean VERBOSE = true; // LED leads connected to PWM pins const 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 brightness const int MIN_INTENSITY = 5; //Minimum Brightness // Used to store the current intensity level of the individual LEDs int 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 = on int redState = 1; int greenState = 1; int blueState = 1; //The bounced the master intensity between MIN_ and MAX_INTENSITY int dir = -1; //This variables represents time - +1 each tick. Used for Trig. int t = 0; // Length of time we spend showing each color const 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 BUTTONS void 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 colors Only 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 INTENSITY Changed 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 prctica vamos a trabajar con un led RGB, mediante el cual vamos a explicar las entradas digitales. Adems, jugaremos con l en programacin, 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 hubiramos metido tres leds en una misma cpsula, 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 ctodo comn, o bien, 3 ctodos para cada color y un nodo comn, usaremos los primeros. Combinando los tres colores (adiccin), 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 prctica. De momento nos conformaremos con los tres colores primarios y sus combinaciones.

Vamos a programar la siguiente sucesin: 1. 2. 3. Rojo Verde Azul x5 (R+V=Amarillo) (R+A=Magenta) (V+A=Can) x5 (R+V+A=Blanco)

/* Led RGB Realiza una sucesin de color mediante un led RGB. */ int ledRojo = 9; //Declaro pin para ctodo del rojo int ledVerde = 10; //Declaro pin para ctodo <span class="g9vju6nv4p" id="g9vju6nv4p_6">del verde</span> int ledAzul = 11; //Declaro pin para ctodo del azul void setup() { pinMode(ledRojo, OUTPUT); //Configuro el pin 9 como salida pinMode(ledVerde, OUTPUT); //Configuro el pin 10 como salida pinMode(ledAzul, OUTPUT); //Configuro el pin 11 como salida } void loop() { for(int i=0;i<6;i++){ //Bucle de 5 repeticiones digitalWrite(ledRojo, HIGH); //Enciendo led rojo delay(200); //Espero 200ms digitalWrite(ledRojo, LOW); //Apago led rojo digitalWrite(ledVerde, HIGH); //Enciendo led verde delay(200); //Espero 200ms digitalWrite(ledVerde, LOW); //Apago led verde digitalWrite(ledAzul, HIGH); //Enciendo <span class="g9vju6nv4p" id="g9vju6nv4p_2">led azul</span> delay(200); //Espero 200ms digitalWrite(ledAzul, LOW); //Apago led azul } for(int i=0;i<6;i++){ //Bucle de 5 repeticiones digitalWrite(ledRojo, HIGH); //Enciendo led rojo digitalWrite(ledVerde, HIGH); //Enciendo led verde delay(200); //Espero 200ms digitalWrite(ledRojo, LOW); //Apago led rojo digitalWrite(ledVerde, LOW); //Apago led verde digitalWrite(ledRojo, HIGH); //Enciendo led rojo digitalWrite(ledAzul, HIGH); //Enciendo led azul delay(200); //Espero 200ms digitalWrite(ledRojo, LOW); //Apago led rojo digitalWrite(ledAzul, LOW); //Apago led azul digitalWrite(ledVerde, HIGH); //Enciendo led verde digitalWrite(ledAzul, HIGH); //Enciendo led azul delay(200); //Espero 200ms

digitalWrite(ledVerde, LOW); digitalWrite(ledAzul, LOW); } digitalWrite(ledRojo, HIGH); digitalWrite(ledVerde, HIGH); digitalWrite(ledAzul, HIGH); delay(3000); digitalWrite(ledRojo, LOW); digitalWrite(ledVerde, LOW); digitalWrite(ledAzul, LOW); }

//Apago led verde //Apago led azul //Enciendo led rojo //Enciendo led verde //Enciendo led azul //Espero 3seg //Apago led rojo //Apago led verde //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 nmero determinado de veces. Este tipo de bucle posee tres partes: for (iniciacin; condicin; incremento){}. La iniciacin 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 condicin, 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 aadir 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 (lgico) = HIGH

0V 0 (lgico) = LOW

Es decir, si estamos aplicando una tensin 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 tensin a una entrada, es posible que la llegue ruido y no lo interprete como 0 (low). Para ello se aade 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 RGB Controla cada color del led RGB con un pulsador. */ //Variables estticas int ledRojo = 9; //Declaro int ledVerde = 10; //Declaro int ledAzul = 11; //Declaro int pulsador1 = 5; //Declaro int pulsador2 = 6; //Declaro int pulsador3 = 7; //Declaro //Variables dinmicas int estado1; //Inicializo la int estado2; //Inicializo la int estado3; //Inicializo la pin pin pin pin pin pin para para para para para para ctodo del rojo ctodo del verde ctodo del azul el pulsador1 el pulsador2 el pulsador3

variable de estado1 variable de estado2 variable de estado3

void setup() { pinMode(ledRojo, OUTPUT); //Configuro el pin 9 como <span class="g9vju6nv4p" id="g9vju6nv4p_12">salida</span> pinMode(ledVerde, OUTPUT); //Configuro el pin 10 como salida pinMode(ledAzul, OUTPUT); //Configuro el pin 11 como salida pinMode(pulsador1, INPUT); //Configuro el pin 5 como entrada pinMode(pulsador2, INPUT); //Configuro el pin 6 como entrada pinMode(pulsador3, INPUT); //Configuro el pin 7 como entrada } void loop() estado1 = almacena estado2 = almacena estado3 = almacena { digitalRead(pulsador1); //Lee el estado del pin5 y lo digitalRead(pulsador2); //Lee el estado del pin6 y lo digitalRead(pulsador3); //Lee el estado del pin7 y lo //Si el pulsador1 est pulsado //Enciende led rojo //Si no est pulsado //Apaga led rojo //Si el pulsador2 est pulsado //Enciende led verde

if(estado1 == HIGH){ digitalWrite(ledRojo, HIGH); } else{ digitalWrite(ledRojo, LOW); } if(estado2 == HIGH){ digitalWrite(ledVerde, HIGH);

} else{ digitalWrite(ledVerde, LOW); } if(estado3 == HIGH){ digitalWrite(ledAzul, HIGH); } else{ digitalWrite(ledAzul, LOW); } }

//Si no est pulsado //Apaga led verde //Si el pulsador3 est pulsado //Enciende led azul //Si no est pulsado //Apaga led azul

La primera novedad que nos encontramos son las variables dinmicas. 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 estn declaradas fuera de los mdulos (setup y loop) van a ser variables globales y las vamos a poder usar en cualquier mdulo. La segunda novedad es la configuracin 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(condicin){}else{}. Si se cumple la condicin que est entre parntesis se ejecutar un bloque, si no se cumple, se ejecutar otro. En nuestro caso, la condicin era comprobar si el estado del pulsador, que habamos 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 prctica!

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 potencimetro 3 resistencias de 220 1 resistencia de 10K Nos vamos a centrar en dos partes que son la conexin del led y la interconexion de los pulsadores. Para la conexin 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 conexin 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/gpl3.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 Rojo const int boton2 = 3; //Se declara el pulsador para el Verde const int boton3 = 4; //Se declara el pulsador para el Azul const int ledR = 9; //Declaramos la pata Roja del led const int ledG = 10; //Declaramos la pata Verde del led const int ledB = 11; //Declaramos la pata Azul del led int R=0; //Iniciamos la variable Rojo a 0 int G=0; //Iniciamos la variable Rojo a 0 int B=0; //Iniciamos la variable Rojo a 0

void setup() { pinMode(boton1, INPUT); pinMode(boton2, INPUT); pinMode(boton3, INPUT); pinMode(ledR, OUTPUT); pinMode(ledG, OUTPUT); pinMode(ledB, OUTPUT); lcd.begin(16, 2); }

//Iniciamos //Iniciamos //Iniciamos //Iniciamos //Iniciamos //Iniciamos //Iniciamos

pin como entrada pin como entrada pin como entrada pin como salida pin como salida pin como salida el tamao:

void loop() { if(digitalRead(boton1)==HIGH){ R=R+10; if (R>255){R=0;} //reinicio de } if(digitalRead(boton2)==HIGH){ G=G+10; if (G>255){G=0;} //reinicio de } if(digitalRead(boton3)==HIGH){ B=B+10; if (B>255){B=0;} //reinicio de } analogWrite(ledR,R); analogWrite(ledG,G); analogWrite(ledB,B); lcd.clear(); lcd.setCursor(0, 0); lcd.print("R->"); lcd.print(R); lcd.print(" G->"); lcd.print(G); lcd.setCursor(0, 1); lcd.print("B->"); lcd.print(B); delay(250); }

//aade +10 a Rojo la variable //aade +10 a Rojo la variable //aade +10 a Rojo la variable

//Escritura en el pin ledR //Escritura en el pin ledG //Escritura en el pin ledB // Borramos el LCD // Situamos el cursos en la primera linea // Escribimos el texto // Escribimos el valor de R // Escribimos el texto // Escribimos el valor de G // Situamos el cursor en la segunda linea // Escribimos el texto // Escribimos el valor de B

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