Haz "clic" en los enlaces para visualizar el vídeo de su funcionamiento.
INTERMITENCIA LED.
void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13, HIGH);
delay(200);
digitalWrite(13, LOW);
delay(200);
}
INTERMITENCIA ALTERNATIVA DE DOS LEDS.
int led1=4;
int led2=5;
void setup(){
pinMode(led1, OUTPUT);
pinMode(led2,OUTPUT);
}
void loop(){
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
delay(200);
digitalWrite(led1, LOW);
digitalWrite(led2, HIHG);
delay(200);
}
int LED=4;
int beep=5;
void setup(){
pinMode(LED, OUTPUT);
pinMode(beep,OUTPUT);
}
void loop(){
digitalWrite(LED, HIGH);
digitalWrite(beep, HIGH);
delay(1000);
digitalWrite(LED, LOW);
digitalWrite(beep, LOW);
delay(1000);
}
CONTROL DE LA INTENSIDAD DE BRILLO DE UN LED.
int LED=9;
int brightness=0;
int fadesteps=5;
void setup(){
pinMode(LED, OUTPUT);
}
void loop(){
analogWrite(LED, brightness);
brightness = brightness + fadesteps;
delay(25);
if (brightness == 0 || brightness == 255) {
fadesteps = - fadesteps ;
}
}
CONTROL DE UN LED MEDIANTE UN PULSADOR.
int LEDblue=6;
int pushbutton=7;
int buttonstate=0;
void setup(){
pinMode(LEDblue, OUTPUT);
pinMode(pushbutton, INPUT);
}
void loop(){
buttonstate =digitalRead(pushbutton);
if (pushbutton == HIGH){
digitalWrite(LEDblue, HIGH);
delay (5000);
digitalWrite(LEDblue, LOW);
}
else{
digitalWrite(LEDblue, LOW);
}
}
CONTROL DE TRES LEDS CON DOS PULSADORES.
int pulsadorderecho = 0;
int pulsadorizquierdo = 0;
void setup(){
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(7,INPUT);
pinMode(8,INPUT);
Serial.begin(9600);
}
void loop(){
pulsadorderecho = digitalRead(7);
pulsadorizquierdo = digitalRead(8);
if (pulsadorderecho == HIGH) {
digitalWrite(2, HIGH);
}
else {
digitalWrite(2, LOW);
}
if (pulsadorizquierdo == HIGH) {
digitalWrite(4, HIGH);
}
else {
digitalWrite(4, LOW);
}
if (pulsadorderecho == HIGH && pulsadorizquierdo == HIGH) {
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
delay(250);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);
delay(250);
}
else {
digitalWrite(3, LOW);
}
}
LED PULSANTE CON DESVANECIMIENTO.
int ledPin = 3;
void setup(){
pinMode(ledPin,OUTPUT);
}
void loop (){
for (int x=0; x<180; x++){
float sinVal = sin(x*3.1412/180);
int ledVal = int(sinVal*255);
analogWrite(ledPin, ledVal);
delay(50);
}
}
SECUENCIA DE UN SEMÁFORO.
const int redLedPin = 2; // pin del led
const int orangeLedPin = 3; // pin del led
const int greenLedPin = 4; // pin del led
void setup() {
// configuramos los tres pines de salida
pinMode(redLedPin, OUTPUT);
pinMode(orangeLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);
}
void loop() {
//ciclo en rojo
digitalWrite(orangeLedPin, LOW); //apagamos el naranja
digitalWrite(redLedPin, HIGH); //encendemos el rojo
delay(9000);//está en rojo 9s
//ciclo en verde
digitalWrite(redLedPin, LOW); //apagamos el rojo
digitalWrite(greenLedPin, HIGH); //encendemos el verde
delay(8000);//está en dverde 8s
//ciclo en naranja
digitalWrite(greenLedPin, LOW); //apagamos el verde
digitalWrite(orangeLedPin, HIGH); //encendemos el naranja
delay(1000); //está en naranja 1s
}
CONTROL DE SEMÁFORO CON PULSADOR.
const int redLedPin = 2; // pin del led
const int orangeLedPin = 3; // pin del led
const int greenLedPin = 4; // pin del led
const int buttonPin = 5; // pin del botón
int lightStatus =0; //led que se debe encender en cada momento
void setup() {
// configuramos los tres pines de salida
pinMode(redLedPin, OUTPUT);
pinMode(orangeLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);
//Configuramos el botón de entrada
pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH); // se activa la resistencia de pull-up
}
void loop() {
if (!digitalRead(buttonPin)){ // si se pulsa
lightStatus = 1; //se fuerza a verde
}
//dependiendo de la luz que se debe mostrar tiene distintos parámetros la llamada
switch (lightStatus){
case 0: //red
showLight(redLedPin,3000);
break;
case 1: // green
showLight(greenLedPin,2000);
break;
case 2: // orange
showLight(orangeLedPin,1000);
break;
}
}
/**
* Enciende el led que se le indique.
* Los parámetros son el led a encender y el tiempo que debe estar encendido
*/
void showLight(int ledPin, int maxTime){
static int lastPin = 0; //último led encendido
static unsigned long startTime =0; //tiempo desde que se encendió el led
/* Si el led actualmente encendido no concuerda con el que se debe encender
* entonces apagar el led encendido, encender el nuevo y poner el contador de tiempo a 0 */
if (ledPin != lastPin){
startTime = millis();
digitalWrite(lastPin, LOW);
lastPin = ledPin;
digitalWrite(ledPin, HIGH);
delay(1);
}
unsigned long elapsedTime = millis()-startTime; //tiempo pasado desde que se encendió el led
if ((elapsedTime)> maxTime ){ // si es mayor que lo esperado, pasar al siguiente ciclo de led
lightStatus++;
if (lightStatus > 2) lightStatus =0; // sólo hay 3 led, comenzamos de nuevo por el 0
}
}
CONTADOR BINARIO DE 4 BITS.
const byte ledPin[] = {2,3,4,5}; //Leds a utilizar
int count=0; //contador
unsigned long changeTime; //contador de tiempo
void setup() {
for (int x=0; x<10; x++) {
pinMode(ledPin[x], OUTPUT); //los preparamos para salida
}
}
void loop() {
if ((millis() - changeTime) > 1000) { //si ha pasado 1000 milisegundos contar uno mas
count ++;
setNumber(); //ponemos el numero en los leds
changeTime = millis(); //inicia el condador de tiempo a 0
}
}
void setNumber (){
if (count>15) count = 0; //volver a empezar si es mayor de 4 bits
for (int i = 0; i<4;i++){ //para cada bit mira si tiene que encender el led correspondiente
digitalWrite(ledPin[i], (count >> i) & 1);
}
}
SIMULACIÓN LEDS RGB.
float RGBfrom[3]; //valores iniciales
float RGBto[3]; //valores destino
float increment[3]; // incrementos
// pines de salida pwm
int redPin = 3;
int greenPin = 5;
int bluePin = 6;
void setup(){
pinMode(redPin, OUTPUT);
pinMode(redPin, OUTPUT);
pinMode(redPin, OUTPUT);
pinMode(A0, INPUT);
randomSeed(analogRead(A0)); //inicializa el random
//comienzo en 0
RGBfrom[0] = 0;
RGBfrom[1] = 0;
RGBfrom[2] = 0;
//valores destino aleatorios
RGBto[0] = random(256);
RGBto[1] = random(256);
RGBto[2] = random(256);
}
void loop(){
//cálculo de incrementos a sumar en cada iteracción
for (int x=0; x<3; x++) {
increment[x] = (RGBfrom[x] - RGBto[x]) / 256;
}
//realizamos las salidas para los cálculos
setOutput();
//se han alcanzado los valores destino
//generamos nuevos valores destino
for (int x=0; x<3; x++) {
RGBto[x] = random(256);
}
}
/***
* Escribe en la salida el valor actual de cada led
* y ajusta el nuevo valor según el incremento calculado
***/
void setOutput(){
//256 iteraciones para llegar al valor destino
for (int x=0; x<256; x++) {
analogWrite (redPin, int(RGBfrom[0]));
analogWrite (greenPin, int(RGBfrom[1]));
analogWrite (bluePin, int(RGBfrom[2]));
delay(10); //ajustable según deseo
//se ajusta el valor desde según el incremento correspondiente
//a cada valor
for (int x=0; x<3; x++) {
RGBfrom[x] -= increment[x];
}
}
}
CONTROL BÁSICO DE UN LED RGB.
int pinRojo = 9;
int pinVerde = 10;
int pinAzul = 11;
void setup()
{
pinMode(pinRojo, OUTPUT);
pinMode(pinVerde, OUTPUT);
pinMode(pinAzul, OUTPUT);
}
void loop()
{
setColor(0, 255, 255); // rojo
delay(500);
setColor(255, 0, 255); // verde
delay(500);
setColor(255, 255, 0); // azul
delay(500);
setColor(0, 0 , 255); // amarillo
delay(500);
setColor(0, 255, 0); // morado
delay(500);
setColor(255, 0, 150); // aqua
delay(500);
setColor(0, 0, 0); //blanco
delay(500);
}
void setColor(int red, int green, int blue)
{
analogWrite(pinRojo, red);
analogWrite(pinVerde, green);
analogWrite(pinAzul, blue);
}
CONTROL DE UN LED RGB CON POTENCIÓMETRO.
int pinRojo = 9;
int pinVerde = 10;
int pinAzul = 11;
int contador =0;
void setup(){
pinMode(pinRojo, OUTPUT);
pinMode(pinVerde, OUTPUT);
pinMode(pinAzul, OUTPUT);
}
void loop(){
int valor=analogRead(A0);
valor=map(valor,0,1023,1,10);
if(contador==0){
for(int r=255; r>0 ; r--){
setColor(r, 255,255);
delay(valor);
}
contador++;
}
else if(contador==1){
for(int g=255; g>0 ; g--){
setColor(255, g,255);
delay(valor);
}
contador++;
}
else{
for(int b=255; b>0 ; b--){
setColor(255, 255,b);
delay(valor);
}
contador=0;
}
}
void setColor( int red, int green, int blue){
analogWrite(pinRojo, red);
analogWrite(pinVerde, green);
analogWrite(pinAzul, blue);
}