EL CODIGO Y LA SINTÁXIS DEL ARDUINO
CONTROL DE TIEMPO
delay(ms)
delay(1000); // espera 1 segundo
millis()
valor = millis(); // valor recoge el número de milisegundos
Nota: Este número se desbordará (si no se resetea de nuevo a cero), después de aproximadamente 9 horas.
MATEMÁTICAS
min(x, y)
valor = min(valor, 100); // asigna a valor el más pequeños de los dos números especificados.
Si 'valor' es menor que 100 valor recogerá su propio valor si ´valor´ es mayor que 100 valor pasara a valer 100.
max(x, y)
valor = max(valor, 100); // asigna a valor el mayor de los dos números 'valor' y 100.
De esta manera nos aseguramos de que valor será como mínimo 100.
ALEATORIOS
randomSeed(seed)
randomSeed(valor); // hace que valor sea la semilla del random
Debido a que Arduino es incapaz de crear un verdadero número aleatorio, randomSeed le permite colocar una variable, constante, u otra función de control dentro de la función random, lo que permite generar números aleatorios "al azar". Hay una variedad de semillas,o funciones, que pueden ser utilizados en esta función, incluido millis() o incluso analogRead () que permite leer ruido eléctrico a través de un pin analógico.
random(max), random(min, max)
valor = random(100, 200);
// asigna a la variable 'valor' un numero aleatorio comprendido entre 100-200
Nota: Use esta función después de usar el randomSeed().
ACTIVIDADES:
1.- Crea un programa que encienda y apague aleatoriamente cuatro leds
int led;
void setup() {
Serial.begin(9600);
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
pinMode(10,OUTPUT);
}
void loop()
{
digitalWrite(10,HIGH);
digitalWrite(11,HIGH);
digitalWrite(12,HIGH);
digitalWrite(13,HIGH);
delay(2000);
led=random(10,14);
digitalWrite(led,LOW);
Serial.println(led);
delay(2000);
}
2.-El siguiente ejemplo genera un valor aleatorio entre 0-255 y lo envía a una salida analógica PWM :
int randNumber; // variable que almacena el valor aleatorio
int led = 11; // define led como 11 que es modulable pwm
void setup() {} // no es necesario configurar nada
void loop()
{
randomSeed(millis()); // genera una semilla para aleatorio a partir de la función millis()
randNumber = random(255); // genera número aleatorio entre 0-255
analogWrite(led, randNumber); // envía a la salida led de tipo PWM el valor
delay(500); // espera 0,5 seg.
}
COMUNICACIÓN SERIE
Arduino posee como principal característica la habilidad de comunicarse con nuestra computadora a través del puerto serie. Esto se conoce como COMUNICACIÓN SERIAL. Debido a que el uso de este puerto ha quedado un poco en desuso a favor de la tecnología USB, Arduino cuenta con un convertidor de Serial a USB que permite a nuestra placa ser reconocida por nuestra computadora como un dispositivo conectado a un puerto COM aún cuando la conexión física sea mediante USB.
Arduino IDE nos proporciona una herramienta que nos permite enviar y visualizar los datos que se manejan a través del puerto Serie. Dicha herramienta se conoce como MONITOR SERIAL y se puede encontrar en el menú de herramientas, en la opción “Monitor Serial”. Es la forma más simple que existe para establecer la comunicación serial con Arduino.
Serial.begin(rate)
El valor típico de velocidad para comunicarse con el ordenador es 9600, aunque otras velocidades pueden ser soportadas.
void setup() {
Serial.begin(9600); // abre el Puerto serie configurando la velocidad en 9600 baudios
}
Nota: Cuando se utiliza la comunicación serie los pins digital 0 (RX) y 1 (TX) no puede utilizarse al mismo tiempo.
Serial.println(data)
Serial.println(analogValue); // envía el valor 'analogValue' al monitor serie
El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos al ordenador cada 1 segundo.
void setup() {
Serial.begin(9600); // configura el puerto serie a 9600bps
}
void loop() {
Serial.println(analogRead(0)); // envía valor analógico
delay(1000); // espera 1 segundo
}
Serial.println(data,
data type)
Vuelca o envía un número o una cadena de carateres, al puerto serie. Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que utilicemos para definir el formato de volcado de los números.Cuando usamos println le estamos diciendo al microcontrolador que tendrá que imprimir un caracter a través del puero serie. Hay otros métodos como Serial.print o Serial.write que nos sirven para imprimir o escribir en el puerto serie, sin embargo el método Serial.println agrega un salto de línea cada vez que se envía un dato, lo que es provechoso para nosotros en algunos casos, especialmente cuando utilizamos el monitor serial.
- parámetro DATA: el número o la cadena de caracteres a volcar o enviar.
- parámetro TYPE: determina el formato de salida de los valores numéricos (decimal, octal, binario, etc...): DEC, OCT, BIN, HEX, BYTE ,..
Serial.avaible()
int Serial.available()
// Obtiene un número entero con el número de bytes (caracteres) disponibles
// para leer o capturar desde el puerto serie
Ejemplo
int TECLA = 0; // almacena el dato serie
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) { // envía datos sólo si los recibe
TECLA = Serial.read(); // lee el byte de entrada lo vuelca a pantalla
Serial.print("Se ha recibido: ");
Serial.println(TECLA, DEC);
}
}
Serial.Read()
EJEMPLO CODIFICADO:
int VARIABLE = 255;
int VALOR = 0; // almacena el dato serie
void setup(){
Serial.begin(9600); // abre el Puerto serie configurando la velocidad en 9600 bps
while (!Serial) { //espera hasta que se conecte el puerto USB
;
}
}
void loop() {
if (Serial.available() > 0) { // sólo si se envía dato
VALOR = Serial.read(); //lee UN carácter ASCII(byte)desde del input serial
Serial.println("Se ha recibido: ");
Serial.write(VALOR); //muestra el carácter inalterabel con write
Serial.println(" ");
Serial.print("Caráter en DEC :");
Serial.println(VALOR,DEC); //imprime su correspondiente DEC
Serial.print("Caráter en DEC :");
Serial.println(VALOR); //en decimal, igual que antes por defecto.
Serial.print("Caráter en HEX :");
Serial.println(VALOR,HEX); //en decimal
Serial.print("Caráter en OCT :");
Serial.println(VALOR,OCT); //en octal
Serial.print("Caráter en BIN :");
Serial.println(VALOR,BIN);
Serial.println(" ");
Serial.println(" ");
delay(3000);
}
Serial.println("Y AHORA IMPRIMIMOS UNA VARIABLE DECLARADA PREVIAMENTE: ");
Serial.write(VARIABLE);
Serial.println(" ");
Serial.println("255"); //imprime una cadena de texto
Serial.println(VARIABLE,DEC);
Serial.println(VARIABLE); // imprime por defecto en DEC
Serial.println(VARIABLE, HEX);
Serial.println(VARIABLE, BIN);
Serial.println("_____");
delay(4000);
}
Abrimos el monitor serial y en la ventana de comandos escribimos 1 y le damos clic en enviar. Luego enviamos 2, 3, 4 y 5.
Nos aparecerá lo siguiente:
49
50
51
52
53
Se preguntarán, si he tecleado el 1 y me aparece el 49, con el 2 me aparece el 50, con el 3 el 51 y así sucesivamente… ¿que está sucediendo?
Simplemente es la forma como estamos imprimiendo los caracteres con el método Serial.println().
Cuando imprimíamos el ‘1’ en el ejemplo anterior, aparecía el 1 en el monitor serial. Ahora estamos imprimiendo un valor entero a través de la variable input.
Cuando se intenta imprimir un entero (1,2,3,4,5…), el método Serial.println() imprimirá dicho entero en formato ASCII.
El ASCII es muy utilizado en programación y telecomunicaciones. Existen tablas que permiten traducir caracteres de ASCII a valores alfanuméricos y viceversa.
En esta tabla se muestra los valores ASCII que representa cada caracter del alfabeto. A los números del 0 al 9 les corresponde los valores del 48 (0) al 57 (9).
Si se desea que los números que aparezcan en el monitor serial aparezcan tal y como lo introducimos por teclado, podemos agregar la línea
input=input-48;
Esta sentencia le quitará 48 a cualquier número ASCII, lo que hará que nos aparezcan números del 0 al 9.
Es cuestión de cada persona empezar a teclear valores en el monitor serial y ver cual es el resultado.
ACTIVIDAD:
1.-ENCENDER UN LED DESDE EL TECLADO
int TECLA=52; //valor ASCII inicial
int ESTADO=0;
void setup(){
pinMode(13, OUTPUT);
Serial.begin(9600);
}
void loop(){
if (Serial.available()>0){ //esto da algo de error
delay(100);
TECLA=Serial.read();
delay(2000);
if (TECLA==49){ //es decir, "1"
ESTADO=1;
Serial.write(TECLA);
Serial.println("_Encendido!! ");
delay(200);
}
else {
ESTADO=0;
//Serial.write(TECLA);
delay(200);
Serial.print(TECLA,DEC);
Serial.println("_Apagado!! ");
delay(200);
}
}
digitalWrite(13,ESTADO);
delay(200);
}
FUNCIONES
Una función es un bloque de código que tiene un nombre y un conjunto de estamentos que son ejecutados cuando se llama a la función.
Son funciones setup() y loop().
Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. Las funciones se declaran asociadas a un tipo de valor “type”. Este valor será el que devolverá la función, por ejemplo 'int' se utilizará cuando la función devuelva un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que significa “función vacía”.
Después de declarar el tipo de dato que devuelve la función se debe escribir el nombre de la función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben pasar a la función para que se ejecute.
type nombreFunción(parámetros)
{
estamentos;
}
En arduino la existen dos funciones principales setup() y loop(). La primera es de una sola secuencia y la segunda es de bucle de repetición. En ambas se establece en primer lugar el valor a retornar (void para vacío), el nombre del procedimiento/función con unos parámetros que pueden ir o no dentro del paréntesis como valores de entrada de esta función y entre llaves las instrucciones del procedimiento.
void setup()
{
pinmode(ledPin, OUTPUT);
}
delayVal( )
La función delayVal( ) devuelve un número entero, se utiliza para poner un valor de retraso en un programa que lee una variable analógica de un potenciómetro conectado a una entrada de Arduino.
Al principio se declara como una variable local, ´v´ recoge el valor leído del potenciómetro que estará comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el valor ´v´ y se retornaría al programa principal. Esta función cuando se ejecuta devuelve el valor de tipo entero ´v´.
int delayVal() {
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potenciómetro, pot debe ser declarado en el setup()
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}
VARIABLES
Las variables son como cajas que van a contener valores que pueden cambiar a lo largo del programa.
Las variables hay que declararlas al principio del programa para poder utilizarlas en cualquier momento.Podemos definir una variable al principio del programa sin tener que asignarle una valor concreto al principio y luego, a lo largo del programa se le asignará el valor.
Todas las variables tienen que declararse antes de que puedan ser utilizadas.
Para declarar una variable se comienza por definir su tipo como int (entero), long (largo), float (coma flotante), etc, asignándoles siempre un nombre, y, opcionalmente, un valor inicial.
Esto sólo debe hacerse una vez en un programa, pero el valor se puede cambiar en cualquier momento usando aritmética y reasignaciones diversas.
El siguiente ejemplo declara la variable entradaVariable como una variable de tipo entero “int”, y asignándole un valor inicial igual a cero. Esto se llama una asignación.
Es decir, int es el tipo de variable, entradaVariable es el nombre que nosotros damos a esta "caja" y 0 es el valor inicial que nosotros le asignamos a esta variable.
int entradaVariable = 0;
Una variable puede ser declarada:
- Al inicio del programa antes de la parte de configuración setup(). Estas variables son llamadas globales y son aquellas que pueden ser vistas y utilizadas por cualquier función y estamento de un programa.
- A nivel local dentro de las funciones. Son las variables locales que solo pueden ser usadas dentro de las funciones en las que se declaró.
- Dentro de un bloque, como para los bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se determinara el ámbito de aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella.
Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes partes del mismo programa que pueden contener valores diferentes (aunque no es recomendable usar el mismo nombre en un mismo programa para no crear confusión). La garantía de que sólo una función tiene acceso a sus variables dentro del programa simplifica y reduce el potencial de errores de programación.
El siguiente ejemplo muestra cómo declarar a unos tipos diferentes de variables y la visibilidad de cada variable:
int valor; // 'valor' se declara como global y podrá usarle en cualquier parte del programa
void setup()
{ // no es necesario configurar algo obligatoriamente
}
void loop()
{
for (int i=0; i<20;i++) // 'i' solo es visible dentro de este bucle
{
float f; // 'f' es visible solo dentro del bucle
}
}
EJERCICIO: Escribe el siguiente código y analiza su funcionamieto respecto a las variables declaradas.
int t=1000; //variable ´t´ declarada como global, antes del setup()
void setup() {
pinMode (13, OUTPUT);
}
void loop() {
digitalWrite(13,HIGH);
delay(t);
digitalWrite(13,LOW);
delay(t); //en cualquier parte del programa podremos variar el valor de t
}
TIPOS DE VARIABLES
byte unaVariable = 180;
// declara 'unaVariable' como tipo byte donde almacena un número de 1Byte (entre 0 y 255)
int unaVariable = 1500;
// declara 'unaVariable' como una variable de tipo entero. Almacena números enteros de 2Bytes (entre -32768 y 32768).
Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango -32,767 a 32,768. Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como consecuencia de una operación. Por ejemplo, si x = 32767 y una posterior declaración agrega 1 a x, x = x + 1 entonces el valor se x pasará a ser -32.768. (algo así como que el valor da la vuelta)
long unaVariable = 90000;
// declara 'unaVariable' como tipo long. Almacena números enteros de 4Bytes. El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647.
float unaVariable = 3.14;
// declara 'unaVariable' como tipo flotante. Almacena números decimales de 4Bytes.
El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los números de punto flotante tienen una mayor resolución que los de 32 bits, con un rango comprendido 3.4028235E +38 a +38-3.4028235E, Los números de punto flotante no son exactos, y pueden producir resultados extraños en las comparaciones. Los cálculos matemáticos de punto flotante son también mucho más lentos que los del tipo de números enteros, por lo que debe evitarse su uso si es posible.
char unaVariable = a;
// Declara unaVariable para poder almacenar 1 carácter. Ocupa 1Btye de memoria.
ARRAYS
int miArray[] = {valor0, valor1, valor2...};
//Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice.
El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0.
Un array tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado.
Ejemplos de arrays:
int miArray[5]; // declara un array de enteros de 6 posiciones
miArray[3] = 10; // asigna l valor 10 a la posición 4
x = miArray[3]; // x ahora es igual a 10 que está en la posición 3 del array.
Las matrices (arrays) se utilizan a menudo para estamentos de tipo bucle, en los que la variable de incremento del contador del bucle se utiliza como índice o puntero del array.
El siguiente ejemplo usa una matriz para: PARPADEO DE UN LED CON ARRAY.
Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la posición de índice 0 en la serie que hemos escrito dentro del array parpadeo[], en este caso 180, que se envía a la salida analógica tipo PWM configurada en el PIN10, se hace una pausa de 200 ms y a continuación se pasa al siguiente valor que asigna el índice “i”.
int ledPin = 10; // Salida analógica PWM para un LED en el PIN 10
byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array de 8 valores diferentes
void setup() {
pinMode(ledPin, OUTPUT); //configura la salida PIN 10
}
void loop() { // bucle del programa
for(int i=0; i<8; i++) { // crea un bucle tipo for utilizando la variable i de 0 a 7
analogWrite(ledPin, parpadeo[i]); // escribe en PIN10 el valor del array parpadeo[]
delay(200); // espera 200ms
}
}
CONSTANTES:
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en grupos. Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o una salida OUTPUT.
digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)
pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida,
CONSTANTES DE VERDADERO/FALSO
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se refieren al estado de las salidas digitales.
FALSE se asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200 son todos también se define como TRUE. (esto es importante tenerlo en cuanta)
if (b == TRUE);
{
ejecutar las instrucciones;
}
OPERADORES ARITMÉTICOS
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;
La operaciones se efectúa teniendo en cuanta el tipo de datos que hemos definido para los operandos (int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos Esto también significa que la operación puede sufrir un desbordamiento si el resultado es más grande que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos numéricos que ya hemos explicado anteriormente.
Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo integer, para el cálculo se utilizará el método de float es decir el método de coma flotante.
Elija el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los resultados sean lo precisos que usted desea. Para las operaciones que requieran decimales utilice variables tipo float, pero sea consciente de que las operaciones con este tipo de variables son más lentas a la hora de realizarse el computo..
Nota: Utilice el operador (int) myFloat para convertir un tipo de variable a otro sobre la marcha.
i = (int) 3,6; //establecerá i igual a 3.
OPERADORES DE COMPARACIÓN
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y //Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales del tipo if.. para testear si una condición es verdadera
ASIGNACIONES COMPUESTAS
x ++ // igual que x = x + 1, o incrementar x en + 1
x -- // igual que x = x - 1, o decrementar x en -1
x += y // igual que x = x + y, o incrementra x en +y
x -= y // igual que x = x - y, o decrementar x en -y
x *= y // igual que x = x * y, o multiplicar x por y
x /= y // igual que x = x / y, o dividir x por y
Las asignaciones compuestas combinan una operación aritmética con una variable asignada. Estas son comúnmente utilizadas en los bucles tal como se describe más adelante.Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo valor x y por lo tanto x es reasignada al nuevo valor
OPERADORES LÓGICOS: LOGICA BOOLEANA
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un VERDADERO o FALSO dependiendo del operador.
Existen tres operadores lógicos que a menudo se utilizan en estamentos de tipo if:
AND (&&)
OR (||)
NOT (!)
if (x > 0 && x < 5); // LOGICA AND, es cierto sólo si las dos expresiones son ciertas
if (x > 0 || y > 0); // LOGICA OR, es cierto si una cualquiera de las expresiones es cierta
if (!x > 0); // LOGICA NOT, es cierto solo si la expresión es falsa
CONDICIONALES
Las condicionales son muy utilizadas en programación. Indican una condición, que en caso de cumplirse se ejecutará una secuancia de instrucciones y en caso de que no otras distintas.
if (condición) {
//acciones en caso de que se cumpla la condición
}
COMPARADORES CONDICIONALES
== igual que (si sólo usamos un =, entonces estaríamos asignando un valor a la variable.
> menor
> mayor
<= menor o igual que
>= mayor o igual que
!= No igual que, o distinto que
i++ //de esta forma incrementamos en uno la variable i. Es igual que usar i=i+1
i-- //de esta forma decrementamos en uno la variable i. Es igual que usar i=i-1
EJEMPLO:
if (inputPin < 500) {
instruccionesA; // ejecuta las operaciones A
}
else if (inputPin >= 1000) {
instruccionesB; // ejecuta las operacione B
}
else {
instruccionesC; // ejecuta las operaciones C
}
Un estamento de tipo if prueba simplemente si la condición dentro del paréntesis es verdadera o falsa. Esta declaración puede ser cualquier declaración válida. En el anterior ejemplo, si cambiamos y ponemos (inputPin == HIGH). En este caso, el estamento if sólo chequearía si la entrada especificado esta en nivel alto (HIGH), o +5 v.
ACTIVIDADES:
1.- Realiza una condición donde se establenza una condición de un valor de potenciómentro mayor que un valor dado encienda un led y si no supera dicho valor no lo encienda.
BUCLES CON FOR
La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;)
for (inicialización; condición; expresión) {
ejecutaInstrucciones;
}
La inicialización de una variable local se produce una sola vez y la condición se testea cada vez que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.
El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es inferior a 20 y si es cierto i se incrementa en 1 y se vuelven a ejecutar las instrucciones que hay dentro de las llaves:
for (int i=0; i<20; i++) // declara i, prueba que es menor que 20, incrementa i en 1
{
digitalWrite(13, HIGH); // envía un 1 al pin 13
delay(250); // espera ¼ seg.
digitalWrite(13, LOW); // envía un 0 al pin 13
delay(250); // espera ¼ de seg.
}
ACTIVIDADES.
1.- Salida analógica del tipo PWM sobre un led en el PIN9 y su control por el bucle FOR.
La
Modulación de Impulsos en Frecuencia (PWM) es una forma de conseguir
una “falsa” salida analógica. Esto podría ser utilizado para modificar
el brillo de un LED o controlar un servo motor. El siguiente ejemplo
lentamente hace que el LED se ilumine y se apague haciendo uso de dos
bucles.
int ledPin = 9; // pin PWM para el LED
void setup(){} // no es necesario configurar nada
void loop() {
for (int i=0; i<=255; i++) { // el valor de i asciende
analogWrite(ledPin, i); // se escribe el valor de i en el PIN de salida del LED
delay(100); // pausa de 100ms
}
for (int i=255; i>=0; i--) { // el valor de i desciende
analogWrite(ledPin, i); // se escribe el valor de i
int ledPin = 9; // pin PWM para el LED
void setup(){} // no es necesario configurar nada
void loop() {
for (int i=0; i<=255; i++) { // el valor de i asciende
analogWrite(ledPin, i); // se escribe el valor de i en el PIN de salida del LED
delay(100); // pausa de 100ms
}
for (int i=255; i>=0; i--) { // el valor de i desciende
analogWrite(ledPin, i); // se escribe el valor de i
delay(100); // pasusa durante 100ms
}
}
}
}
2.- Queremos que nos imprima por pantalla del ordenador, a través del puerto serie. los números del 0 al 10 aumentando de uno en uno.
for (int a=0; a<=10; a++) {
Seria.println(a);
}
3.- Codifica un programa para que dos LEDS parpadeen alternativamente mientras esté pulsado un pulsador.
int leduno=5;
int leddos=6;
int pulsador=10;
void setup() {
pinMode (leduno, OUTPUT);
pinMode (ledos, OUTPUT);
pinMode (pulsador, INPUT);
}
void loop(){
while (dititalRead(pulsador==HIGH) {
digitalWrite (leduno, HIGT);
delay(500);
digitalWrite (leddos, HIGT);
digitalWrite (leduno, LOW);
delay(500);
digitalWrite (leddos, LOW);
digitalWrite (leduno, HIGH);
delay(500);
}
}
BUCLE CON WHILE
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también por el cambio de un valor en una entrada de un sensor
while (unaVariable ?? valor) {
ejecutarSentencias;
}
El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es verdad, ejecuta las declaraciones dentro de los corchetes y continuará ejecutando el bucle hasta que 'unaVariable' no sea inferior a 200.
While (unaVariable < 200) // testea si es menor que 200
{
instrucciones; // ejecuta las instrucciones entre llaves
unaVariable++; // incrementa la variable en 1
}
BUCLE CON DO...WHILE
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.
do
{
Instrucciones;
} while (unaVariable ?? valor);
El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milisegundos, y luego continua mientras que el valor de la 'x' sea inferior a 100:
do
{
x = leeSensor();
delay(50);
} while (x < 100);
USO DE LA INSTRUCCIÓN MÓDULO PARA AJUSTAR UN RANGO DE DATOS:
%(modulo)
sintáxis: resultado= dividendo % divisor
Ejemplo: Se puede usar esta expresión para mantener unos resultados del pinA0 dentro de un rango de datos (en este caso un array).
/* update one value in an array each time through a loop */sintáxis: resultado= dividendo % divisor
Ejemplo: Se puede usar esta expresión para mantener unos resultados del pinA0 dentro de un rango de datos (en este caso un array).
int values[10];
int i = 0;
void setup() {}
void loop(){
values[i] = analogRead(0);
i = (i + 1) % 10; // modulo operator rolls over variable
}
LISTADO SERIE NÚMEROS PRIMOS HASTA 1024.
CÓDIGO:
//NUMEROS PRIMOS hasta 1024. www.prometec.net
bool control = true ;
int maximo = 1024 ;
int contador = 1 ; //para monitorizar ocho columnas
void setup(){
Serial.begin(9600);
}
void loop() {
if ( control) { // Solo es para que no repita una y otra vez lo mismo
Serial.println( "Los numeros primos hasta el " + String( maximo)) ;
for ( int x = 2 ; x < maximo ; x++) {
if (Primo(x) )
if ( contador++ % 8 == 0) //monitorizamos ocho columnas
Serial.println( String(x)+"," ) ;
else
Serial.print( String(x) +","+ '\t') ;
}
}
control = false ;
}
bool Primo( int n){
for ( int i = 2 ; i <n ; i++) {
if ( n % i == 0) { // Si el resto es 0 entonces es divisible.
//Serial.println ( String(n) +" es divisible por: " + String(i)) ;
return(false) ;
}
}
return (true) ;
}
SALIDA DE CORRIENTE DE ALTO CONSUMO
A veces es necesario controlar cargas de más de los 40 mA que es capaz de suministrar la tarjeta Arduino. En este caso se hace uso de un transistor MOSFET que puede alimentar cargas de mayor consumo de corriente. El siguiente ejemplo muestra como el transistor MOSFET conmuta 5 veces cada segundo.
Nota: El esquema muestra un motor con un diodo de protección por ser una carga inductiva. En los casos que las cargas no sean inductivas no será necesario colocar el diodo.
int outPin = 5; // pin de salida para el MOSFET
void setup()
{
pinMode(outPin, OUTPUT); // pin5 como salida
}
void loop()
{
for (int i=0; i<=5; i++) // repetir bucle 5 veces
{
digitalWrite(outPin, HIGH); // activa el MOSFET
delay(250); // espera 1/4 segundo
digitalWrite(outPin, LOW); // desactiva el MOSFET
delay(250); // espera 1/4 segundo
}
delay(1000); // espera 1 segundo
}
}
delay(1000); // espera 1 segundo
}
