Ejemplos de cdigo

Salida digital

En este ejemplo el LED conectado al pin 13 parpadea cada segundo.

int ledPin = 13; // LED que se encuentra en el pin 13

void setup(){

pinMode(ledPin, OUTPUT); // El p1n 13 ser una salida digital

void loop(){

digitalWrite(ledPin, HIGH); // Enciende el LED

delay(1000); // Pausa de 1 segundo

digitalWrite(ledPin, LOW); // Apaga el LED

delay(1000); // Pausa de 1 segundo

Salida digital II

En este ejemplo el LED conectado al pin 13 parpadea en un intervalo de tiempo variable que depende del
nmero de veces que se ejecuta el programa (funcin loop)

int ledPin = 13; // LED que se encuentra en el pin 13

int n = 0; //Entero que contar el paso por la funcin loop

void setup(){

pinMode(ledPin, OUTPUT); // El p1n 13 ser una salida digital

void loop(){

digitalWrite(ledPin, HIGH); // Enciende el LED

 delay(1000); // Pausa de 1 segundo

digitalWrite(ledPin, LOW); // Apaga el LED

n++; //Incrementamos n

delay(delayVal(n)); //Pausa de un tiempo variable

//Funcin que devuelve un valor tipo entero segn el parmetro pasado

int delayVal(int f){

return f*100;

Entrada digital

Este ejemplo lee el valor de un interruptor conectado en el pin 2. Cuando el interruptor est cerrado en el pin
de entrada habr un estado alto (HIGH) y se encender el LED.

int ledPin = 13; // Pin de salida para el LED

int inPin = 2; // Pin de entrada (donde est conectado el interruptor)

void setup() {

pinMode(ledPin, OUTPUT);

pinMode(inPin, INPUT);

void loop() {

if (digitalRead(inPin) == HIGH){ // Si se activa interruptor

digitalWrite(ledPin, HIGH); // Enciende el LED

delay(1000); // Pause de 1 segundo

digitalWrite(ledPin, LOW); // Apaga el LED

 delay(1000); // Pausa de 1 segundo

Salida PWM

Modulacin por ancho de pulso (PWM) puede emplearse, por ejemplo, para establecer el brillo de un led o
controlar un servomotor. En el siguiente ejemplo se va aumentando y decrementando el brillo del pin 9
mediante PWM.

int ledPin = 9; // Pin controlado por PWM

void setup(){}

void loop() {

for (int i=0; i<=255; i++){

analogWrite(ledPin, i); // Establece el brillo a i

delay(100); // Pausa de 100 ms

for (int i=255; i>=0; i--) {

analogWrite(ledPin, i);

delay(100);

Entrada a partir de un potencimetro

En el siguiente cdigo se emplea arduino para controlar la frecuencia de parpadeo de un LED.

int potPin = 0; // Pin de entrada para el potencimetro

int ledPin = 13; // Pin de salida para el LED

void setup() {

pinMode(ledPin, OUTPUT); // Declara el pin del LED como de salida

void loop() {

digitalWrite(ledPin, HIGH); // Enciende el LED

delay(analogRead(potPin)); // Lee el valor del potencimetro

digitalWrite(ledPin, LOW); // Apaga el LED

delay(analogRead(potPin));

Pgina de contenidos Pgina anterior

El codigo del programa es el siguiente:

//Luz de vela

int ledPin = 9; // selecciona el puerto PWM

int val = 0;

// define y pone a cero la variable "brillo"

int delayval = 0; // define el intervalo de cambio de valor de salida

void setup() {

randomSeed(0);

// inicializa el generador de nmeros aleatorios

pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9

void loop() {

val = random(100,255);

// genera un nmero aleatorio entre 100 y 255 que asigna a la variable val

analogWrite(ledPin, val); // enva ese valor a la salida pin 9

delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo asigna a la variable de
temporizacin

delay(delayval);

// espera un tiempo delayval medido en milisegundos

//Luz de vela

int ledPin = 9; // selecciona el puerto PWM

int val = 0;

// define y pone a cero la variable "brillo"

int delayval = 0; // define el intervalo de cambio de valor de salida

void setup() {

randomSeed(0);

// inicializa el generador de nmeros aleatorios

pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9

void loop() {

val = random(100,255);

// genera un nmero aleatorio entre 100 y 255 que asigna a la variable val

analogWrite(ledPin, val); // enva ese valor a la salida pin 9

delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo asigna a la variable de

temporizacin

delay(delayval);

// espera un tiempo delayval medido en milisegundos

}
//y ultrasonico de larga distancia

#define Pecho 6

#define Ptrig 7

long duracion, distancia;

void setup() {

Serial.begin (9600); // inicializa el puerto seria a 9600 baudios

pinMode(Pecho, INPUT); // define el pin 6 como entrada (echo)

pinMode(Ptrig, OUTPUT); // define el pin 7 como salida (triger)

pinMode(22, 1); // Define el pin 13 como salida

void loop() {

digitalWrite(Ptrig, LOW);

delayMicroseconds(2);

digitalWrite(Ptrig, HIGH); // genera el pulso de triger por 10ms

delayMicroseconds(10);

digitalWrite(Ptrig, LOW);

duracion = pulseIn(Pecho, HIGH);

distancia = (duracion/2) / 29; // calcula la distancia en centimetros

if (distancia >= 500 || distancia <= 0){ // si la distancia es mayor a 500cm o menor a 0cm

Serial.println("---"); // no mide nada

else {

Serial.print(distancia); // envia el valor de la distancia por el puerto serial

 Serial.println("cm"); // le coloca a la distancia los centimetros "cm"

digitalWrite(22, 0); // en bajo el pin 13

if (distancia <= 50 && distancia >= 1){

digitalWrite(22, 1); // en alto el pin 13 si la distancia es menor a 10cm

Serial.println("Alarma......."); // envia la palabra Alarma por el puerto serial

delay(400); // espera 400ms para que se logre ver la distancia en la consola

El codigo del programa es el siguiente:

//Estrella fugaz

int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 };

int controlLed = 13;

// LED de control

int waitNextLed = 100; // Tiempo antes de encender el siguiente LED

// Nmero de LEDs que permanecen encendidos antes de empezar a apagarlos para

//formar la cola

int tailLength = 4;

// Nmero de LEDs conectados (que es tambin el tamao del array)

int lineSize = 11;

void setup()

// Configuracin de los PIN-es como salida digital

int i;

pinMode (controlLed, OUTPUT);

for (i=0; i< lineSize; i++)

{
pinMode(pinArray[i], OUTPUT);

void loop()

int i;

// Se establece la longitud de la cola en un contador

int tailCounter = tailLength;

// Se enciende el LED de control para indicar el inicio del loop

digitalWrite(controlLed, HIGH);

for (i=0; i<lineSize; i++)

digitalWrite(pinArray[i],HIGH); // Se encienden consecutivamente los LED

// Esta variable de tiempo controla la velocidad a la que se mueve la estrella

delay(waitNextLed);

if (tailCounter == 0)

// Se apagan los LEDs en funcin de la longitud de la cola.

digitalWrite(pinArray[i-tailLength],LOW);

else

if (tailCounter > 0)

tailCounter--;

for (i=(lineSize-tailLength); i<lineSize; i++)

digitalWrite(pinArray[i],LOW);

// Se apagan los LED

// Esta variable de tiempo controla la velocidad a la que se mueve la estrella

delay(waitNextLed);
}

/*

Atenuacin

Este tutorial muestra como atenuar el brillo de un LED usando la funcin analogWrite().

*/

int led = 9;

int brillo = 0;

int variacion_brillo = 5;

// la rutina de setup corre una vez o cuando se presiona reset

void setup() {

// declara el pin9 como pin de salida

pinMode(led, OUTPUT);

// la rutina loop corre constantemente

void loop() {

// configura el brillo del pin 9

analogWrite(led, brillo);

// cambia el brillo para el siguiente ciclo

brillo = brillo + variacion_brillo;

if (brillo == 0 || brillo == 255) {

variacion_brillo = -variacion_brillo;

}
// espera por 30 milisegundos para ver el efecto de la atenuacin

delay(30);

/*************/

/* SEMAFORO */

/*************/

/*** Fernando Martinez Mendoza ***/

//** Definiciones **//

int rojo=2; //definimos el valor del pin para el led rojo

int amarillo=4; //definimos el valor del pin para el led amarillo

int verde=7; //definimos el valor del pin para el led verde

//** Programa **//

void setup() {

pinMode(verde,OUTPUT); //declaramos el pin verde como salida

pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida

pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida

void loop() {

digitalWrite(verde,HIGH); //encendemos el led rojo

delay(2000); //esperamos 2 segundos

digitalWrite(verde,LOW); //apagamos el led rojo

delay(500); //esperamos medio segundo

digitalWrite(amarillo,HIGH); //encendemos el led amarillo

delay(2000); //esperamos 2 segundos

digitalWrite(amarillo,LOW); //apagamos el led amarillo

delay(500); //esperamos medio segundo

digitalWrite(rojo,HIGH); //encendemos el led verde

delay(2000); //esperamos 2 segundos

digitalWrite(rojo,LOW); //apagamos el led verde

delay(500); //esperamos medio segundo

/* Parpadeo sin delay()

Enciende y apaga un LED conectado a un pin digital sin utilizar la funcin delay(). Esto significa que otro
cdigo se puede ejecutar al mismo tiempo sin ser interrumpido por el cdigo que controla el parpadeo del
LED

Circuito: Un LED conectado entre el pin 13 y el pin GND.

Nota: en muchos Arduinos hay un LED en la placa conectado al pin 13, por lo que no sera necesario un LED
externo para este ejemplo.

Creado en 2005 por David A. Mellis, modificado el 8/2/2010 por Paul Stoffregen.

Este ejemplo es de dominio pblico*/

// las constantes no cambian. Las usamos aqu para establecer los nmeros de los pines.

int ledPin = 13; // el nmero del pin conectado al LED

// variables que cambiarn de valor.

int ledState = LOW; // ledState se usar para establecer el estado del LED

long previousMillis = 0; // almacenar la ltima vez que el estado del LED

//se actualiz

// la siguiente variable es del tipo long por que el tiempo medido en

// milisegundos supera rpidamente al nmero que puede ser almacenado en una

// variable del tipo int

long interval = 1000; // intervalo del parpadeo (en milisegundos)

void setup()

// establece el pin digital como salida:

pinMode(ledPin, OUTPUT);

void loop()

// Aqu es donde pondramos el cdigo que debe ejecutarse durante todo el

// tiempo.

// Se comprobar si es el momento de parpadear el LED, esto es, si la

// diferencia entre el tiempo transcurrido y el tiempo en que parpade

// por ltima vez el LED es mayor que el intervalo que establecimos en

// la declaracin de variables.

unsigned long currentMillis = millis(); // Se toma el tiempo actual

// se comprueba si el tiempo actual menos el tiempo en que el LED cambi

// de estado por ltima vez es mayor que el intervalo.

if (currentMillis - previousMillis > interval){

// Si se cumple la condicin se guarda el nuevo tiempo

// en el que el LED cambia de estado

previousMillis = currentMillis;

// Y ahora cambiamos de estado el LED, si est encendido a

// apagado o viceversa.

if (ledState == LOW)
ledState = HIGH;

else

ledState = LOW;

// Hacemos que el contenido de la variable llegue al LED

digitalWrite(ledPin, ledState);

/ * El coche fantstico 1

* --------------

* Bsicamente una extensin de Blink_LED.

* (cleft) 2005 K3, Universidad de Malmo

* @author: David Cuartielles

* @hardware: David Cuartielles, Aaron Hallborg

* modificado por: aprendiendoarduino

*/

int pin2 = 2 ;

int pin3 = 3 ;

int pin4 = 4 ;

int pin5 = 5 ;

int pin6 = 6 ;

temporizador int = 100 ;

void setup () {

De serie. begin ( 9600 );

 pinMode (pin2, OUTPUT);

pinMode (pin3, OUTPUT);

pinMode (pin4, OUTPUT);

pinMode (pin5, OUTPUT);

pinMode (pin6, OUTPUT);

void loop () {

// temporizador = analgicoRead (A0); // El valor leido por analgico ledo es el temporizador

digitalWrite (pin2, HIGH);

De serie. println ( " Enciendo primer led " );

retardo (temporizador);

digitalWrite (pin2, LOW);

retardo (temporizador);

digitalWrite (pin3, ALTO);

De serie. println ( " Enciendo segundo led " );

retardo (temporizador);

digitalWrite (pin3, LOW);

retardo (temporizador);

digitalWrite (pin4, ALTO);

De serie. println ( " Enciendo tercer led " );

retardo (temporizador);

digitalWrite (pin4, LOW);

retardo (temporizador);

digitalWrite (pin5, ALTO);

 De serie. println ( " Enciendo cuarto led " );

retardo (temporizador);

digitalWrite (pin5, LOW);

retardo (temporizador);

digitalWrite (pin6, HIGH);

De serie. println ( " Enciendo quinto led " );

retardo (temporizador);

digitalWrite (pin6, LOW);

retardo (temporizador);

digitalWrite (pin5, ALTO);

De serie. println ( " Enciendo cuarto led " );

retardo (temporizador);

digitalWrite (pin5, LOW);

retardo (temporizador);

digitalWrite (pin4, ALTO);

De serie. println ( " Enciendo tercer led " );

retardo (temporizador);

digitalWrite (pin4, LOW);

retardo (temporizador);

digitalWrite (pin3, ALTO);

De serie. println ( " Enciendo segundo led " );

retardo (temporizador);

digitalWrite (pin3, LOW);

retardo (temporizador);

}
/*

Parpadeo sin Retardo

Activa y desactiva un diodo emisor de luz (LED) conectado a un pin digital,

sin utilizar la funcin delay (). Esto significa que otro cdigo puede ejecutarse al

mismo tiempo sin ser interrumpido por el cdigo de LED.

El circuito:

- Utilice el LED integrado. - Nota: La mayora de los Arduinos tienen un LED integrado que puede controlar.

En el UNO, el MEGA

y el ZERO est unido al perno digital 13, en MKR1000 en el perno 6. LED_BUILTIN

se fija al perno del LED correcto independientemente de qu tablero se utiliza.

Si desea saber a qu pin se conecta el LED de a bordo en su

modelo Arduino, consulte las especificaciones tcnicas de su tarjeta en:

https://www.arduino.cc/en/Main/Products

creado en 2005

por David A. Mellis

modificado el 8 de febrero de 2010

por Paul Stoffregen

modificado el 11 de noviembre de 2013

por Scott Fitzgerald

modificado el 9 de enero de 2017

por Arturo Guadalupi

Este ejemplo de cdigo est en el dominio pblico.

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

*/
// las constantes no cambiarn. Se utiliza aqu para establecer un nmero pin:

const int ledPin = LED_BUILTIN ; // el nmero del LED pin

// Las variables cambiarn:

int ledState = LOW ; // ledState utilizado para configurar el LED

// Generalmente, debe usar "unsigned long" para variables que contienen tiempo

// El valor se convertir rpidamente en demasiado grande para un int para almacenar

unsigned long previousMillis = 0 ; // se guardar la ltima vez que se actualiz el LED

// las constantes no cambiarn:

const long interval = 1000 ; // intervalo en el que parpadea (milisegundos)

void setup ( ) {

// establece el pin digital como salida:

pinMode ( ledPin , OUTPUT ) ;

void loop ( ) {

// aqu es donde se pondra el cdigo que debe estar funcionando todo el tiempo. // compruebe si es hora
de parpadear el LED;

es decir, si la diferencia

// entre la hora actual y la ltima vez que parpadea el LED es mayor que

// el intervalo en el que desea parpadear el LED. largo

sin signoMillis = millis ( ) ; if ( currentMillis - previousMillis > = interval ) { // guardar la ltima vez que
parpadee el LED previousMillis = currentMillis ; // si el LED est apagado encindalo y viceversa: if (
 ledState == LOW ) {

ledState = ALTO ;

} else {

ledState = LOW ;

// establece el LED con el ledState de la variable:

digitalWrite ( ledPin , ledState ) ;

const int Led = LED_BUILTIN;

int EstadoDelLed=LOW;

unsigned long TiempoUltimoCambio=0;

const long Intervalo = 1000;

void setup()

pinMode(Led, OUTPUT);

void loop()
{

unsigned long TiempoAhora = millis();

if (TiempoAhora TiempoUltimoCambio >= Intervalo)

TiempoUltimoCambio = TiempoAhora;

If ( EstadoLed = LOW)

EstadoLed=HIGH;

Else

EstadoLed=LOW;

digitalWrite(Led, EstadoLed);

}
}

/*

* Led parpadeante sin utilizar delay()

* y con diferente intervalo de encendido y apagado

* Basado en "BlinkWithoutDelay" (http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay)

* Permite que otro cdigo pueda ser ejecutado al mismo tiempo sin ser interrumpido

* por el cdigo que hace parpadear el led. Permite adems seleccionar un intervalo

* de encendido diferente al de apagado.

* Abril 05, 2009

* Bogot

* Alejandro Tamayo // www.thepopshop.org // laimagendelmundo@yahoo.ca

* Como funciona:

* Verifica si est dentro de un nuevo periodo de encendido y apagado (On + Off)

* y si lo est (flag = true) verifica si ha pasado el tiempo de encendio y apaga el led,

* de lo contrario lo mantiene encendido.

*/

int ledPin = 13;

boolean flag = true;

long previousMillis = 0;
long On = 50; // tiempo que dura encendido, en milisegundos

long Off = 1000; // tiempo que dura apagado, en milisegundos

void setup(){

pinMode(ledPin, OUTPUT);

void loop(){

// aqu es donde puede colocarse otro cdigo que necesita ser ejecutado continuamente

if (millis() < (previousMillis + On + Off)){

flag = true;

else {

flag = false;

previousMillis = millis();

if (flag == true){

if (millis() > (previousMillis + On)){

digitalWrite(ledPin, LOW);

else{

digitalWrite(ledPin, HIGH);

}
/ * Parpadeo sin retraso

Enciende y apaga un diodo emisor de luz (LED) conectado a un

pin, sin utilizar la funcin delay (). Esto significa que otro cdigo

puede funcionar al mismo tiempo sin ser interrumpido por el cdigo del LED.

El circuito:

* LED conectado desde el pin 13 a tierra.

* Nota: en la mayora de los Arduinos, ya hay un LED en el tablero

que se adjunta a la clavija 13, por lo que no se necesita hardware para este ejemplo.

creado en 2005

por David A. Mellis

modificado el 8 de febrero de 2010

de Paul Stoffregen

Este cdigo de ejemplo est en el dominio pblico.

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

*/

# include " Timer.h "

# include < MsTimer2.h >

Temporizador t;

// las constantes no cambiarn. Se utiliza aqu para

// establecer nmeros de pin:

const int ledPin = 13 ; // el nmero del pin del LED

const int ledPin2 = 10 ;

const int buttonPin = 9 ;

boolean buttonState;

// Las variables cambiarn:

int ledState = LOW; // ledState utilizado para configurar el LED

largo anteriorMillis = 0 ; // se actualizar el LED de ltima hora

// las variables de seguimiento son largas porque el tiempo, medido en milisegundos,

// se convertir rpidamente en un nmero mayor que el que se puede almacenar en un int.

intervalo largo = 1000 ; // intervalo en el que parpadea (milisegundos)

int count = 0 ;

void setup () {

De serie. begin ( 9600 );

// establece el pin digital como salida:

pinMode (ledPin, OUTPUT);

pinMode (ledPin2, OUTPUT);

pinMode (buttonPin, INPUT_PULLUP);

MsTimer2 :: set ( 5000 , blinkLed2); // http://playground.arduino.cc/Main/MsTimer2

MsTimer2 :: start ();

t cada ( 3000 , printCount);

buttonState = digitalRead (buttonPin);

void loop ()

// aqu es donde se pondra el cdigo que debe estar funcionando todo el tiempo.
 // compruebe si es hora de parpadear el LED; es decir, si el

// diferencia entre la hora actual y la ltima vez que parpadeaste

// el LED es ms grande que el intervalo al que desea

// parpadea el LED.

t update ();

largo sin signoMillis = millis ();

if (buttonState! = digitalRead (buttonPin)) {

cuenta ++;

buttonState =! buttonState;

if (currentMillis - previousMillis> intervalo) {

// guardar la ltima vez que parpade el LED

previousMillis = currentMillis;

// si el LED est apagado, encindalo y viceversa:

if (ledState == LOW)

ledState = ALTO;

ms

ledState = LOW;

// ajusta el LED con el ledState de la variable:

digitalWrite (ledPin, ledState);

void printCount () {

De serie. imprimir ( " El contado " );

De serie. impresin (cuenta);

 De serie. println ( " pulsaciones de boton " );

void blinkLed2 () {

static boolean ledState = LOW;

digitalWrite (ledPin2, ledState);

ledState =! ledState;