![Arreglos
int serie1 [ 5];
int serie2[] = {3,5,6,12,23};
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i=0; i<5; i++)
Serial.println("Posicion " + String(i)+": "
+String(serie2[i]));
}](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-34-320.jpg)
![Arreglos encuentra el error
int serie1 [ 5];
int serie2[] = {3,5,6,12,23};
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i=0; i<99; i++)
Serial.println("Posicion " + String(i)+": "
+String(serie2[i]));
}
Por último, mencionar que podemos manejar arrays de
varias dimensiones:
Int Tablero[ 8, 8 ] ;
Imaginad que Tablero representa las posiciones de una
partida de ajedrez y cada valor que contiene esa posición
corresponde a una pieza que se encuentra en esa casilla](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-35-320.jpg)
![Varios arreglos
Dividir el arreglo por aquellos
elementos menores que el.
bool Primo(int x)
{
int index = 0 ;
while ( P[index] < x)
{ if ( x % P[index++] == 0)
return(false);
}
return(true);
}](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-36-320.jpg)
![Arreglo dos
int Div[32] ;
int Divisores(int x)
{
int index = 0 ; //Apunta a la
posicion del array P[]
int pos = 0 ; //Para apuntar al
array de divisores Div[]
while ( P[index] < x)
{
int k = P[index++] ;
if ( x % k == 0)
Div[pos++]= k ; //Guardamos el
divisor en en el array Div[].
} // para uso posterior
return(pos); //Devolvemos el
numero de divisores encontrado
}](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-37-320.jpg)
![EL PROGRAMA PRINCIPAL
int P[] =
{ 2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53,
59, 61, 67, 71, 73, 79, 83, 89,
97, 101, 103, 107, 109, 113, 127, 131,
137, 139, 149, 151, 157, 163, 167, 173,
179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263,
269, 271, 277, 281, 283, 293, 307, 311,
313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409,
419, 421, 431, 433, 439, 443, 449, 457,
461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569,
571, 577, 587, 593, 599, 601, 607, 613,
617, 619, 631, 641, 643, 647, 653, 659,
661, 673, 677, 683, 691, 701, 709, 719,
727, 733, 739, 743, 751, 757, 761, 769,
773, 787, 797, 809, 811, 821, 823, 827,
829, 839, 853, 857, 859, 863, 877, 881,
883, 887, 907, 911, 919, 929, 937, 941,
947, 953, 967, 971, 977, 983, 991, 997,
1009, 1013, 1019, 1021
} ;
int Div[32] ;
void setup()
{ Serial.begin(9600);
}
void loop()
{
if (Serial.available())
{ String s = GetLine();
int i = s.toInt() ; //Como
esperamos un numero, convertimos el
texto a numero
](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-39-320.jpg)
![EL PROGRAMA PRINCIPAL
if ( Primo(i))
Serial.println(String(i) + " Es primo.");
else
{
Serial.println(String(i) + " No es primo.");
Serial.println("Sus divisores son: ");
int j = Divisores(i); //Recogemos el
numero de divisores encontrados
for (int n =0 ; n<j ; n++)
Serial.print(String(Div[n]) + ",t");
Serial.println(" ");
}
}
}
String GetLine()
{ String S = "" ;
if (Serial.available())
{
char c = Serial.read(); ;
while ( c != 'n')
{ S = S + c ;
delay(25) ;
c = Serial.read();
}
return(S) ;
}
}](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-40-320.jpg)
![EL PROGRAMA PRINCIPAL
bool Primo(int x)
{
int index = 0 ;
while ( P[index] < x)
{ if ( x % P[index++] == 0)
return(false);
}
return(true);
}
int Divisores(int x)
{ int index = 0 ; //Apunta a la
posicion del array P[]
int pos = 0 ; //Para apuntar al
array de divisores Div[]
while ( P[index] < x)
{ int k = P[index++] ;
if ( x % k == 0)
Div[pos++]= k ; //Guardamos el
divisor en un array de divisores.
} // para uso posterior
return(pos); //Devolvemos el
numero de divisores encontrado
}](https://image.slidesharecdn.com/arduinobasico-230825014950-8bbbe479/85/Arduino-Basico-pptx-41-320.jpg)
Arduino Basico.pptx
- 2. Descripción del Curso Escriba un breve resumen del curso Ubicación Charlas teóricas: Lun-Mié-Vie a las 00:00 a. m. Laboratorios: Mar-Jue a las 00:00 a. m. Requisitos previos: Créditos:
- 3. Primer programa parpadeo (digitalWrite) void setup(){ pinMode(3, OUTPUT ); } void loop() { digitalWrite(3, HIGH); delay(1000); digitalWrite(3,LOW); delay(1000); }
- 4. Introduccion al for int i = 0 ; // se declara la variable for ( i = 11 ; i < 14 ; i++) // se da la el valor y la condicion i es la variable i < 14 la condicion i++ requisicion de incrementar la variable en 1.
- 5. Introduccion al for void setup() { int i = 0 ; for ( i = 11 ; i < 14 ; i++) pinMode( i , OUTPUT) ; } void loop() { int i = 0 ; for ( i = 11 ; i < 14 ; i++) { digitalWrite( i , HIGH) ; delay (500) ; digitalWrite( i , LOW); delay (500) ; } }
- 6. Entradas y salidas Entradas todo lo que se recibe del mundo exterior Botones Sensores Se declara pinMode(7, INPUT); Se controla digitalRead(7, == 1) Ejercisio: dos leds parpadeando a diferente tiempos Un semaforo Tres leds en secuencia continua Salidas son todo lo que afecta al mundo exterior Luces Motores Alarmas Se declara pinMode(3, OUTPUT); Se controla digitalWrite(7, HIGH o LOW); delay)(milisegundos) le dara un tiempo antes de pasar a la siguiente etapa
- 7. DigitalRead (valores digitales) Cuidarse del valor flotante Este se Evita al colocar la Resistencia en la senal de entrada Para esto declarer la entrada como pullup No usar acentos o ñ por que alteran los programas. int LED = 10; int boton = 6; void setup() { pinMode( LED, OUTPUT); pinMode( boton, INPUT); } void loop() { int valor = digitalRead(boton); digitalWrite (LED, valor); }
- 8. DigitalRead (negación) Para hacer esto se realiza de dos formas con el símbolo “!” o escribiendo la variable con un “-” int LED = 10; int boton = 6; void setup() { pinMode( LED, OUTPUT); pinMode( boton, INPUT); } void loop() { int valor = digitalRead(boton); digitalWrite (LED, !valor); }
- 9. Boleano y equivalente int LED = 10; int boton = 6; void setup() { pinMode( LED, OUTPUT); pinMode( boton, INPUT); } void loop() { digitalWrite (LED, ! digitalRead( LED)); delay(1000); } int LED = 10; int boton = 6; void setup() { pinMode( LED, OUTPUT); pinMode( boton, INPUT); } void loop() { bool valor = digitalRead(boton); delay(1000); digitalWrite (LED, valor); delay(1000); }
- 10. Instruciones de c++ If En este capítulo vamos a presentar unas instrucciones nuevas de C++, que nos permitan tomar decisiones para hacer una cosa u otra. La instrucción if es muy sencilla de usar, basta con pasarle entre paréntesis una variable o condición que se evalúe a true o false. Si el resultado es true se hace el bloque que viene a continuación y en caso contrario se ejecuta el bloque que hay detrás del else si existe. Si no existe la clausula del esle, entonces el bloque que sigue al if, se ejecuta o no, en función de la condición y luego sigue con la secuencia de instrucciones a continuación. if ( condición) { instrucción 1 ; instrucción 2 ; ................ } else { instruccion20 ; instruccion21 ; .............. }
- 11. Operadores relacionales Igual que: == Distinto de: != Mayor que: > Mayor o igual: >= Menor que: < Menor o igual: <= If ( boton1 && boton2) Que ambos botones estén sin pulsar If ( !( boton1 && boton2)) Que ambos estén pulsados. If( boton1 || boton2 ) Que al menos uno este pulsado, o ambos.
- 12. ENCLAVAMIENTO Y IF int estado = 0; void setup() { pinMode(8, INPUT); pinMode(4, OUTPUT); } void loop() { estado = digitalRead(8); if(estado == HIGH) { digitalWrite(4, HIGH); } else { digitalWrite(4, LOW); } }//led prende cuando le aplano al boton int estado = 0; int salida = 0; void setup() { pinMode(8, INPUT); pinMode(4, OUTPUT); } void loop() { estado = digitalRead(8); if(estado == HIGH) { salida = 1 - salida; } if(salida == 1) { digitalWrite(4, HIGH); } else { digitalWrite(4, LOW); } }// a veces funciona y a veces no por la velocidad de lectura
- 13. ENCLAVAMIENTO Y IF int estado = 0; int salida = 0; int estadoAnterior = 0; void setup() { pinMode(8, INPUT); pinMode(4, OUTPUT); } void loop() { estado = digitalRead(8); If((estado == HIGH) && (estadoAnterior == LOW)) { salida = 1 - salida; } estadoAnterior = estado; if(salida == 1) { digitalWrite(4, HIGH); } else { digitalWrite(4, LOW); } }
- 14. ENCLAVAMIENTO Y IF int estado = 0; int salida = 0; int estadoAnterior = 0; void setup() { pinMode(8, INPUT); pinMode(4, OUTPUT); } void loop() { estado = digitalRead(8); If((estado == HIGH) && (estadoAnterior == LOW)) { salida = 1 - salida; delay(20); } estadoAnterior = estado; if(salida == 1) { digitalWrite(4, HIGH); } else { digitalWrite(4, LOW); } }
- 15. Condicion And dos botones void setup() { pinMode(13,INPUT_PULLUP); pinMode(12,INPUT_PULLUP); pinMode(2,OUTPUT); } void loop() { if(digitalRead(13)==HIGH && digitalRead(12)==HIGH){ digitalWrite(2,HIGH); delay(100); } else{ digitalWrite(2,LOW); } }
- 16. Hacer el mismo programa con variables int boton=0; int boton1=0; void setup() { pinMode(13,INPUT_PULLUP); pinMode(12,INPUT_PULLUP); pinMode(2,OUTPUT); } void loop() { boton=digitalRead(13); boton1=digitalRead(12); if(boton==HIGH && boton1==HIGH){ digitalWrite(2,HIGH); delay(100); } else{ digitalWrite(2,LOW); } }
- 17. Condicion OR dos botones void setup() { pinMode(13,INPUT_PULLUP); pinMode(12,INPUT_PULLUP); pinMode(2,OUTPUT); } void loop() { if(digitalRead(13)==HIGH || digitalRead(12)==HIGH){ digitalWrite(2,HIGH); delay(100); } else{ digitalWrite(2,LOW); }
- 18. Puerto serial Serial.begin(velocidad); Código común para codificar los mensajes originalmente ASCII actualmente Unicode Que incluye mas simbología de esta manera puedes traducir varios idiomas entre si vamos a utilizar el código ASCII El otro problema que se puede presentar es la velocidad ya que si se maneja velocidades diferentes habrá un error de comunicación, la cual se maneja en bits por seundo La velocidad es una valor entre 300 y 115.200 bits por segundo. Y suele ser costumbre establecerla en 9600 (el valor por defecto) pero no hay ninguna razón para ello y esta no es una velocidad especialmente alta. void setup() { Serial.begin(9600) ; // Inicializa el Puerto seria 9600 bits por segundo } void loop() { int i = 54 ; Serial.println( i ); }
- 19. Operaciones Serial.println(“”); Adición: + Resta: – Multiplicación: * División entera: / Cociente sin decimales (puesto que operamos con enteros Resto: % Devuelve el resto de una división. int i = 4 * 2 resultado = 8 int i = 4 * 2 / 3 resultado = 2 Porque desprecia los decimales al ser entero int i = 14 % 3 resultado = 2 El resto de 14 entre 3 Int i = 2 + 8 / 2 resultado = 6 Calcula primero la división. Int i = (2+8) / 2 resultado = 5 El paréntesis fuerza a que se realice primero la suma void setup() { Serial.begin(9600) ; // Inicializa el Puerto serie } void loop() { int i = 27 ; //El número en cuestión if ( i % 2 == 0) Serial.println("Es par.") ; else Serial.println("Es impar"); }
- 20. String void setup() { Serial.begin(9600) ; // Inicializa el Puerto serie } void loop() { Serial.print("Buenos ") ; Serial.print("Dias ") ; Serial.println("a todos.") ; } void loop() { int resultado = 25 ; String s = “ El resultado es: ” ; // Nótese que la S de string es mayúscula. Serial.print( s) ; Serial.println( resultado); }
- 21. String void loop() { int resultado = 25 ; String s = “ El resultado es: ” ; // Nótese que la S de string es mayúscula. Serial.print( s) ; Serial.println( resultado); } void loop() { String a = "hola " ; String b = "a todos." ; Serial.println( a + b); }
- 22. String void loop() { int resultado = 25 ; String s = "El resultado es: " ; Serial.println( s + String( resultado )); }
- 23. Recibiendo comunicación al Ar void setup() { Serial.begin(9600) ; // Inicializa el Puerto serie } void loop() { if (Serial.available() > 0) { int x = Serial.parseInt(); Serial.println ( x) ; } } void setup() { Serial.begin(9600); } void loop () { char c = ' ' ; String mensaje ="" ; if (Serial.available()) //Comprobamos si hay algo esperando { while( c != 'n') //Si lo hay, lo leemos hasta el intro { mensaje = mensaje + c ; // Añadimos lo leído al mensaje c = Serial.read(); //Leer 1 carácter delay(25); } Serial.println( mensaje); //Al salir imprimir el mensaje mensaje = "" ; //Bórralo para la próxima vez } }
- 24. While y if while ( condición) { ……… } Diferencia if ("condicion") { grupo cierto de instrucciones; } while("condicion") { grupo cierto de instrucciones; instruccion(es) para salir del ciclo; };
- 25. Apagar led con el teclado int input; // Variable donde se almacenará el dato introducido por teclado int led=13; // Variable donde se guardará el número de pin al que hemos conectado nuestro led void setup(){ Serial.begin(9600); // Se inicia la comunicación serial pinMode(led, OUTPUT); // Se configura el pin como salida } void loop(){ } if(Serial.available()>0){ // Si existen datos de entrada en la comunicacion serial hacer lo siguiente input=Serial.read(); // Guardamos el dato introducido if(input=='1'){ // Si el dato es igual a 1 digitalWrite(led, HIGH); // Encendemos el led Serial.println("Led Encendido" ); delay(1000); } else{ // De lo contrario digitalWrite(led, LOW); // Apagamos le led Serial.println("Led Apagado“); } }
- 26. Serial plotter con una variable void setup() { Serial.begin(9600); } void loop() { int valor; valor = random(0,100); Serial.println(valor); delay(250); }
- 27. Serial plotter con dos variables void setup() { Serial.begin(9600); } void loop() { int valor1; int valor2; valor1 = random(0,100); valor2 = random(0,100); Serial.print(valor1); Serial.print(","); Serial.println(valor2); delay(250); }
- 28. FUNCIONES Y ENTEROS Programa base bool Primo( int x) // int x representa el parámetro que pasaremos a esta función { Aquí va lo que tiene que hacer ………… return( bool); } Base para un numero primo 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) ; }
- 29. void setup() { Serial.begin(9600); int x = 427 ; // El número a probar bool p = Primo(x); if (p ) Serial.print( String(x) + " Es primo.") ; else Serial.print( String(x) + " No es primo." ) ; } void loop() { } 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) ; }
- 30. bool control = true ; int maximo=1024; 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++) { bool p = Primo(x); if (p ) Serial.println( x) ; } } 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. return(false) ; } return (true) ; }
- 31. EL TIPO ENTERO TIPO DESCRIPCIÓN VALOR int Entero con signo, 16 bits entre -32,768 y 32,767 unsigned int Entero sin signo, 16 bits 216 – 1 ; de 0 hasta 65.535 long Entero con signo, 32 bits 232 – 1 ,Desde -2.147.483,648 hasta 2.147.483.647 unsigned long Entero sin signo, 32 bits Desde 232 – 1 ; 0 a 4.294.967.295 byte Entero sin signo, 8 bits 2 a la 8 de 0 hasta 255
- 32. Overflow De hecho C++ tiene la fea costumbre de esperar que nosotros llevemos el cuidado de no pasarnos metiendo un valor que no cabe en una variable. Cuando esto ocurre se le llama desbordamiento (overflow) y C++ ignora olímpicamente el asunto, dando lugar a problemas difíciles de detectar si uno no anda con tiento.
- 33. MÁS SOBRE LAS FUNCIONES EN C++ Cuando se declara una función se debe especificar que parámetro va a devolver. Así: Instrucción Significa int Funcion1() Indica que va a devolver un entero String Funcion2() Indica que va a devolver un String. unsigned long Funcion3() Indica que va a devolver un long sin signo void Funcion4() No va a devolver valores en absoluto Lo que sí está permitido es pasar varios argumentos a una función: int Funcion5 ( int x , String s , long y) Aquí declaramos que vamos a pasar a Funcion5, tres argumentos en el orden definido, un entero un String y por ultimo un long.
- 34. Arreglos int serie1 [ 5]; int serie2[] = {3,5,6,12,23}; void setup() { Serial.begin(9600); } void loop() { for (int i=0; i<5; i++) Serial.println("Posicion " + String(i)+": " +String(serie2[i])); }
- 35. Arreglos encuentra el error int serie1 [ 5]; int serie2[] = {3,5,6,12,23}; void setup() { Serial.begin(9600); } void loop() { for (int i=0; i<99; i++) Serial.println("Posicion " + String(i)+": " +String(serie2[i])); } Por último, mencionar que podemos manejar arrays de varias dimensiones: Int Tablero[ 8, 8 ] ; Imaginad que Tablero representa las posiciones de una partida de ajedrez y cada valor que contiene esa posición corresponde a una pieza que se encuentra en esa casilla
- 36. Varios arreglos Dividir el arreglo por aquellos elementos menores que el. bool Primo(int x) { int index = 0 ; while ( P[index] < x) { if ( x % P[index++] == 0) return(false); } return(true); }
- 37. Arreglo dos int Div[32] ; int Divisores(int x) { int index = 0 ; //Apunta a la posicion del array P[] int pos = 0 ; //Para apuntar al array de divisores Div[] while ( P[index] < x) { int k = P[index++] ; if ( x % k == 0) Div[pos++]= k ; //Guardamos el divisor en en el array Div[]. } // para uso posterior return(pos); //Devolvemos el numero de divisores encontrado }
- 38. Array tres vamos a escribir una función de uso general que nos permita recoger una cadena de texto de la puerta serie sin que salga hasta que reciba un String que vamos a hacer finalice en intro. De hecho ya vimos este programa, aunque no como función en la sesión Comunicación con el exterior Definimos Getline() de tipo String, porque queremos que nos devuelva un texto. Comprobamos que hay algo disponible en la puerta serie, y en caso afirmativo construimos un String S añadiéndole cada uno de los caracteres que leemos del puerto serie, hasta que encontremos un intro. String GetLine() { String S = "" ; if (Serial.available()) { char c = Serial.read(); ; while ( c != 'n') //Hasta que el character sea intro { S = S + c ; delay(25) ; c = Serial.read(); } return(S) ; } }
- 39. EL PROGRAMA PRINCIPAL int P[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021 } ; int Div[32] ; void setup() { Serial.begin(9600); } void loop() { if (Serial.available()) { String s = GetLine(); int i = s.toInt() ; //Como esperamos un numero, convertimos el texto a numero
- 40. EL PROGRAMA PRINCIPAL if ( Primo(i)) Serial.println(String(i) + " Es primo."); else { Serial.println(String(i) + " No es primo."); Serial.println("Sus divisores son: "); int j = Divisores(i); //Recogemos el numero de divisores encontrados for (int n =0 ; n<j ; n++) Serial.print(String(Div[n]) + ",t"); Serial.println(" "); } } } String GetLine() { String S = "" ; if (Serial.available()) { char c = Serial.read(); ; while ( c != 'n') { S = S + c ; delay(25) ; c = Serial.read(); } return(S) ; } }
- 41. EL PROGRAMA PRINCIPAL bool Primo(int x) { int index = 0 ; while ( P[index] < x) { if ( x % P[index++] == 0) return(false); } return(true); } int Divisores(int x) { int index = 0 ; //Apunta a la posicion del array P[] int pos = 0 ; //Para apuntar al array de divisores Div[] while ( P[index] < x) { int k = P[index++] ; if ( x % k == 0) Div[pos++]= k ; //Guardamos el divisor en un array de divisores. } // para uso posterior return(pos); //Devolvemos el numero de divisores encontrado }
- 42. PWM Los pines Cuasi analogicos Todas las señales que hemos manejado hasta ahora con nuestro Arduino , de entrada o de salida, comparten una característica común: Son digitales, es decir que pueden tomar un valor HIGH o LOW pero no valores intermedios. Si representamos una el valor de una señal digital a lo largo del tiempo veríamos algo así: serie de bits En la vida muchas cosas son así, apruebas o suspendes, enciendes la luz o la apagas, pero muchas otras son variables mensurables continuas y pueden tomar cualquier valor que imaginemos, como el ángulo del reloj o la temperatura, que aun dentro de valores finitos pueden tomar tantos valores intermedios como podamos imaginar,
- 43. PWM Los pines Cuasi analogicos En la vida muchas cosas son así, apruebas o suspendes, enciendes la luz o la apagas, pero muchas otras son variables mensurables continuas y pueden tomar cualquier valor que imaginemos, como el ángulo del reloj o la temperatura, que aun dentro de valores finitos pueden tomar tantos valores intermedios como podamos imaginar, A esta clase de variables las llamamos analógicas y una representación por contraposición a lo digital, sería algo como esto: Analogico No es raro que queramos controlar algo del mundo exterior con una señal analógica de forma que el comportamiento del sistema siga esa señal. Podemos por ejemplo querer variar la luminosidad de un diodo LED y no simplemente apagarlo o encenderlo En esta sesión aprenderemos a enviar señales analógicas a los pines de salida de Arduino.
- 44. PWM A este truco se le llama PWM, siglas de Pulse Width Modulation, o modulación de ancho de pulsos. La idea básica es poner salidas digitales que varían de forma muy rápida de modo que el valor eficaz de la señal de salida sea equivalente a una señal analógica de menor voltaje. Lo sorprendente es que el truco funciona.
- 45. PMW No todos los pines digitales de Arduino aceptan poner valores PWM en la salida. Solamente aquellos que tienen un símbolo ~ delante del número. Fijaros en la numeración de los pines de la imagen:
- 46. Brillo de led void setup() { pinMode( 9, OUTPUT) ; } void loop() { analogWrite (9, 255) ; }
- 47. Brillo de led void loop (){ for (brillo = 0;brillo <256;brillo++){ analogWrite (led, brillo); delay(10); } for (brillo = 255;brillo >=0;brillo--){ analogWrite (led, brillo); delay(10); } } void setup() { pinMode( 9, OUTPUT) ; } void loop() { for ( int i= 0 ; i<255 ; i++) { analogWrite (9, i) ; delay( 10); } }
- 48. PMW void setup() // Prog 10_2 { pinMode( 9, OUTPUT) ; } void loop() { for ( int i= -255 ; i<255 ; i++) { analogWrite (9, abs(i)) ; delay( 10); } } Aquí aprovecho ( por pura vagancia) para hacer el ciclo de subir y bajar el brillo del LED con un único bucle. La función abs(num), devuelve el valor absoluto o sin signo de un número num, y por eso mientras que i viaja de -255 a 255, abs(i) va de 255 a 0 y vuelta a subir a 255. ¿Que os parece el truco?
- 49. Led RGB La pata mas larga es el comun ya sea anodo o catodo facilita el uso de varios leds en uno solo hay tres colores. Prueba de led void setup() { for (int i =9 ; i<12 ; i++) pinMode(i, OUTPUT); } void Color(int R, int G, int B) { analogWrite(9 , R) ; // Red - Rojo analogWrite(10, G) ; // Green - Verde analogWrite(11, B) ; // Blue - Azul } void loop() { Color(255 ,0 ,0) ; delay(500); Color(0,255 ,0) ; delay(500); Color(0 ,0 ,255) ; delay(500); Color(0,0,0); delay(1000); }
- 50. Vamos a paint void setup() { // put your setup code here, to run once: for (int i =9 ; i<12 ; i++) pinMode(i, OUTPUT); } void Color(int R, int G, int B) { analogWrite(9 , R) ; // Red - Rojo analogWrite(10, G) ; // Green - Verde analogWrite(11, B) ; // Blue - Azul } void loop() { Color(0 ,174 ,174) ; delay(1000); }
- 51. Funcion Random void setup() { for (int i =9 ; i<12 ; i++) pinMode(i, OUTPUT); } void loop() { Color(random(255), random(255), random(255)) ; delay(500); } void Color(int R, int G, int B) { analogWrite(9 , R) ; // Rojo analogWrite(10, G) ; // Green - Verde analogWrite(11, B) ; // Blue - Azul }
- 54. SEÑALES ANALOGICAS Parece buen momento para destacar que los convertidores ADC leen valores de tensión y no resistencia, por lo tanto, lo que vamos a leer es la caída de tensión en el potenciómetro a medida que giramos el ajuste. La primera curiosidad es que no necesitamos declarar en el setup() que vamos a usar una puerta analógica. Y la segunda es que para tomar una muestra (leer) del pin A5, usaremos la instrucción: int Val = analogRead(A5) ; Los convertidores de Arduino UNO y Mega son de 10 bits de resolución por lo que nos devolverá valores entre 0 y 210 = 1.024 para tensiones entre 0 y 5V. En cambio el Arduino DUE dispone de convertidores de 12 bits por lo que el valor de sus lecturas estará entre 0 y 1012 o sea 4.096, es decir tiene mejor resolución(pero sólo puede leer hasta 3,3V). Asegúrate de no usar sensores que puedan dar más de 5V máximo (con Arduino UNO y Mega), ya que dañarías el chip principal de Arduino.
- 55. SEÑALES ANALOGICAS void setup() { Serial.begin(9600); // Iniciamos la puerta serie } void loop() { int Lectura = analogRead(A5) ; Serial.println( Lectura); delay(200) ; } NOTA: Los pines analógicos no es necesario declararlos por que en automatico ya lo hace el arduino.
- 56. SEÑALES ANALOGICAS Al no estar el A5 conectado a ninguna referencia válida, está flotando y los valores que captura son muestra de esa incoherencia. En realidad lo que está haciendo tu Duino es captar ruido aleatorio de radiofrecuencia e intentar darle sentido, pero lo tiene mal, como puedes ver. No obstante en condiciones normales los valores que leerá seran relativamente bajos.¿Quieres que las oscilaciones crezcan en valor?. Fácil. Ponle una antena. Vale un simple cable de protoboard conectado desde el A5 a nada (O si agarras el otro extremo entre los dedos, tu mismo haras de antena). Acabas de construir el receptor de Radio frecuencia mas inutil del mundo
- 57. SEÑALES ANALOGICAS const int led = 3; const int pot= 5; int brillo; void setup() { pinMode(led,OUTPUT); } void loop() { brillo = analogRead(pot) / 4; analogWrite(led,brillo); } Por que se divide entre 4 el pot???
- 58. SEÑALES ANALOGICAS const int ledrojo = 3; const int ledverde= 5; const int ledAzul= 6; const int potrojo= 0; const int potverde= 1; const int potAzul= 2; int rojo; int verde; int azul; void setup() { pinMode(ledrojo,OUTPUT); pinMode(ledverde,OUTPUT); pinMode(ledAzul,OUTPUT); } void loop() { rojo = analogRead(potrojo) / 4; verde = analogRead(potverde) / 4; azul = analogRead(potAzul) / 4;//0-1023 analogWrite(ledrojo,rojo); analogWrite(ledverde,verde); analogWrite(ledAzul,azul); }
- 59. SEÑALES ANALOGICAS const int ledrojo = 3; const int ledverde= 5; const int ledAzul= 6; const int potrojo= 0; const int potverde= 1; const int potAzul= 2; int rojo; int verde; int azul; void setup() { Serial.begin(9600); pinMode(ledrojo,OUTPUT); pinMode(ledverde,OUTPUT); pinMode(ledAzul,OUTPUT); } void loop() { rojo = analogRead(potrojo) / 4; verde = analogRead(potverde) / 4; azul = analogRead(potAzul) / 4;//0-1023 analogWrite(ledrojo,rojo); analogWrite(ledverde,verde); analogWrite(ledAzul,azul); Serial.print(" Rojo "); Serial.print(rojo); Serial.print(","); Serial.print(" Verde "); Serial.print(verde); Serial.print(","); Serial.print(" Azul "); Serial.print(azul); Serial.print(","); }//Delay y println para ajustar