Archivos Mensuales: noviembre 2012

Control de un Servo

CONTROL DE FLUJO II

 for

La sentencia for se usa para repetir un número finito de veces un conjunto de sentencias. Se necesita una variable contadora, un valor inicial, un valor final y un incremento/decremento.

for(inicialización; condición; incremento/decremento)

{

conjunto de sentencias;

}

 Inicialización: Situación de partida de una variable local sucede una sola una vez.

Condición: Cada vez que pasa el bucle, la condición es comprobada, si es TRUE, el conjunto de sentencias se ejecutan, si es FALSE, el bucle termina.

Incremento/decremento: fija el valor a incrementar / decrementar.

for(int i=0; i<20; i++)

{

digitalWrite(13, HIGH);                    //activa el pin 13

delay(250);                                       //pausa por un 1/4 de segundo

digitalWrite(13, LOW);                    //desactiva el pin 13

delay(250);                                       //pausa por un 1/4 de segundo

}

 Inicialización i=0                   Condición i<20                      incremento +1

 

while

El sentencia while se usa para repetir infinitamente un conjunto de sentencias, hasta que la condición de dentro del paréntesis devuelva FALSE.

while(condición)

{

conjunto de sentencias;

}

 Condición: Cada vez que pasa el bucle, la condición es comprobada, si es TRUE, el conjunto de sentencias se ejecutan, si es FALSE, el bucle termina. Si la condición no es cambiada dentro del bucle, este se ejecutará infinitamente

while(intensidadLuz < 200)             //comprueba si es menor que 200

{

intensidadLuz = digitalRead(2);

}

do. . . while

En el bucle do. . . while la condición se testea al final del bucle, por lo que el siempre se ejecutará al menos una vez.

do

{

conjunto de sentencias;

}while(condición);

 Condición: Cada vez que pasa el bucle, la condición es comprobada, si es TRUE, da otra vuelta, si es FALSE, el bucle termina. Si la condición no es cambiada dentro del bucle, este se ejecutará infinitamente

do

{

intensidadLuz = digitalRead(2);

}while( intensidadLuz < 200);                     //comprueba si es menor que 200

LIBRERÍAS

Librerí­a Servo

Esta biblioteca permite a una placa Arduino controlar servo motores RC (hobby).

A partir de Arduino 0017, la biblioteca Servo admite hasta 12 servos en la mayorí­a de las placas. El uso de la librerí­a deshabilita la funcionalidad analogWrite() (PWM) en las patillas 9 y 10, exista o no un servo conectado en esos pines.

Hay que tener en cuenta que los servos consumen energí­a considerablemente, por lo que si tienes que utilizar más de un servo tendrías que alimentarlos mediante una fuente de alimentación externa (asegurase de conectar la tierra del Arduino y la de la fuente de alimentación externa).

 

Métodos

attach(int). Asocia la variable Servo a un pin

detach(). Desasocia la variable Servo de su pin. Si todas las variables Servo son desasociadas, entonces los pines 9 y 10 se pueden usar para salidas PWM con analogWrite().

write(int). Define el ángulo del servo en grados, de 0 a 180.

read(). Devuelve el valor del último write().

attached(). Devuelve 1 si el servo está asociado actualmente.

A pesar de estar conectado un servo, no recibirá ninguna señal de control hasta que usted envíe su primera posición con el método write () para evitar que se salte a un valor aleatorio.

Existe una versión nueva de la librería (SoftwareServo) que obliga a hacer el refresco de forma implícita: hay que llamar a una función refresh() cada 50ms para que el servo actualice su posición.

Barrido de un servo

Esquema Eléctrico:

Esquema Práctico:

Código del Programa:

Código fuente:

Servo.pde

Ficha del Proyecto:

Servor_Ficha_5

Vídeo resumen:

Anuncios

Sensor

CONTROL DE FLUJO I

if

Comprueban si la declaración es cierta y ejecutan todas las sentencias dentro de las llaves, si es falsa el programa ignora la sentencia.

if(declaración)

{

hacerAlgo;

}

if. . . else

Permite tomar decisiones del tipo si se cumple esta declaración realizo esto  y si no realizo esto otro.

if(declaración)

{

hagoEsto;

}

else

{

hagoEstoOtro;

}

if. . . else if. . . else

Permite tomar decisiones del tipo si se cumple la declaración1 realizo esto, si se cumple esta otra declaración2 realizo esto otro  y si no realizo esto otro2.

if(declaración1)

{

hagoEsto;

}

else if(declaración2)

{

hagoEstoOtro1

}

else

{

hagoEstoOtro2;

}

Nota: Cuidado con usar “=” en lugar de “==” dentro de la declaración de la sentencia del tipo if.

FUNCIONES DE PINES DE  E/S DIGITAL

En Arduino Duemilanove los pines de Entrada/Salida digitales son del 0 al 13. De estos, los pines 3, 5, 6, 9, 10, 11 pueden funciona como PWM (modulación por ancho de pulsos).

pinMode(pin, mode)

Se usa para configurar un pin específico para que se comporte como entrada o como salida, debe definirse en void setup().

pintMode(pin, OUTPUT)              //ajusta ‘pin’ como salida.

pinMode(pin, INPUT)                    //ajusta ‘pin’ como entrada

Los pines digitales de Arduino están ajustados a INPUT por defecto, por lo que no necesitan ser declarados explícitamente como entradas con pinMode().

Los pines configurados como INPUT se dice que están e un estado de alta impedancia.

Existen resistencias de pull-up de 20KOhm, integradas en el chip ATmega que pueden ser accedidas por software de la manera siguiente:

pinMode(pin, INPUT);

digitalWrite(pin, HIGH);

Con Arduino 1.0.1, es posible activar las resistencias pull-up internas con el modo INPUT_PULLUP. Además, el modo de ENTRADA explícitamente desactiva los pullups internos.

Los pines configurados como OUTPUT se dice que están en un estado de baja impedancia y pueden proporcionar 40 mA a otros dispositivos/circuitos.

digitalRead(pin)                             // Lee el valor desde un pin digital

digitalWrite(pin, valor)                 // Pone el pin alnivel lógico HIGH o LOW.

analogWrite(pin, valorPWM)         // Escribe un valor pseudos-analógico PWM.

Parámetros

 pin: el número del pin cuyo modo que desea ajustar.

modo:                  INPUT, OUTPUT.

valor:                   HIGH o LOW

valorPWM:           0 a 255

Cortocircuitos en los pines de Arduino o corriente excesiva pueden dañar o destruir el pin de salida, o dañar el chip ATmega. A menudo es una buena idea conectar un pin OUTPUT a un dispositivo externo en serie con una resistencia de 470Ohm o 1KOhm.

El pin digital 13 es más difícil de usar como entrada digital, porque tiene un LED y una resistencia soldada en la mayoría de las placas. Si activa su resistencia interior pull-up de 20K, tendremos alrededor de 1,7 V en lugar de los 5V esperados, porque el LED y la resistencia en serie, bajan la tensión, lo que significa que siempre retorna un nivel BAJO a la salida. Si debes usar el pin número 13 como entrada digital, usa una resistencia externa conectada a pulldown.

Si el pin de entrada digital no está conectado a nada, digitalRead () puede devolver HIGH o LOW (y esto puede cambiar al azar).

Los pines analógicos pueden ser usados como pines digitales con los números 14 (entrada analógica número 0) hasta 19 (entrada analógica número 5).

FUNCIONES DE PINES DE E/S ANALÓGICA

En Arduino Duemilanove los pines de Entrada/Salida analógicos son del 0 a 5

analogRead(pin)                            // Lee el valor del pin analógico.

La resolución de  lectura es de 10 bits (0 a 1023). Esto proporciona una resolución en la lectura con un rango de referencia de 5 voltios de (5 v / 1024 = 4.9 mV por unidad). El rango de entrada puede ser cambiado usando la función analogReference().

El conversor tarda aproximadamente 100 microsegundos (0.0001 segundos) en leer una entrada analógica por lo que se puede llevar una tasa de lectura máxima aproximada de 10.000 lecturas por segundo.

Si la entrada analógica que vamos a leer no está conectada a nada, el valor que devolverá la función analogRead() fluctuará aleatoriamente dependiendo de las interferencias que capte de otras entradas analógicas o del exterior

Los pines analógicos al contrario que los digitales, no necesitan ser declarados al principio como INPUT u OUTPUT.

analogReference(tipo)                 // Configura el voltaje de referencia.

Devolverá un valor de 1023 para aquella tensión de entrada que sea igual a la tensión de referencia.

tipo:

  • DEFAULT: Es el valor de referencia analógico que viene por defecto que es de 5 voltios en placas Arduino de y de 3.3 voltios en placas Arduino que funcionen con 3.3 voltios.
  • INTERNAL: Es una referencia de tensión interna de 1.1 voltios en el ATmega168 o ATmega328 y de 2.56 voltios en el ATmega8.
  • EXTERNAL: Se usará una tensión de referencia externa que tendrá que ser conectada al pin AREF.

La tensión aplicada en el pin AREF será la que haga que el conversor A/D de su máxima lectura (1023) cuando lea una tensión igual a la aplicada en ese pin. Si se aplica una tensión por debajo de esta a AREF será escalada proporcionalmente, así cuando se usa la tensión de referencia por defecto (DEFAULT) el valor que nos devuelve una tensión de 2.5V en una entrada analógica será 512.

FUNCIONES DE TIEMPO

delay(ms)                 // Realiza una pausa en milisegundos.

millis()                       // Devuelve el número de milisegundos desde que la placa Arduino empezó a ejecutar el programa actual como un valor long sin signo.

Este número se desbordará (resetear de nuevo a cero), después de aproximadamente 9 horas.

Ya estamos listos para realizar nuestro cuarto proyecto, se trata de como puedo controlar un dispositivo a través de un sensor

Sensor

Esquema Eléctrico:

Esquema Práctico:

Código del Programa:

Código fuente:

Sensor.pde

Otro ejemplo un poco más elaborado

Sensor_2.pde

Ficha del Proyecto:

Sensor_Ficha_4

Sensor_Ficha_4a

Vídeo resumen:

Otro vídeo

Temporizador

OPERADORES

Operadores Aritméticos

= (asignación). Guarda el valor de la derecha del símbolo “=” dentro de la variable a la izquierda del símbolo “=”.

No confunda el operador de asignación “=” con el operador de comparación “==”, que evalúa la igualdad de dos expresiones.

  tiempoLEDRojo= tiempoParada

+ (suma). Este operador devuelve la suma de los dos operandos.

  tiempoLEDRojo= tiempoLEDRojo + 1000  // la variable tiempoLEDRojo se incrementa en 1.000

– (resta). Este operador devuelve la diferencia de los dos operandos.

  tiempoLEDRojo= tiempoLEDRojo – 1000  // la variable tiempoLEDRojo se decrementa en 1.000

* (multiplicación). Este operador devuelve el producto de los dos operandos.

  tiempoLEDRojo= tiempoLEDRojo * 2  // la variable tiempoLEDRojo se duplica

/ (división). Este operador devuelve el cociente de los dos operandos.

  tiempoLEDRojo= tiempoLEDRojo / 3  // la variable tiempoLEDRojo se divide por tres

% (resto). Este operador devuelve  el resto de la división entre dos enteros

  tiempoLEDRojo= 10%3  // la variable tiempoLEDRojo toma el valor 1

La operaciones se efectúa teniendo en cuenta el tipo de datos que hemos definido para los operandos, por lo que la operación puede sufrir un desbordamiento si el resultado es más grande del que se puede almacenada en el tipo de datos.

Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los operandos, por ejemplo, si uno es de tipo float y el otro de tipo integer, para el cálculo se utilizará el tipo float.

Utilice los operadores de conversión para convertir un tipo de variable a otro.

  i = int (3,6)  // establecerá i igual a 3.

Operadores Comparativos

Compara una variable o constante con otra y específica si es cierta.

Estos operadores de comparación se utilizan con los controles de flujo del tipo “if”, “for”, “while”, etc…

No confunda el operador de asignación “=” con el operador de comparación “==”, que evalúa la igualdad de dos expresiones.

  x == y; //especifica si x es igual a y

  x != y; // especifica si x no es igual a y

  x < y; // especifica si x es menor que y

  x > y; // especifica si x es mayor que y

  x <= y; // especifica si x es menor o igual que y

  x >= y; // especifica si x es mayor o igual que y

Operadores Booleanos

Los operadores lógicos son normalmente una forma de comparar dos expresiones y devuelven TRUE o FALSE dependiendo del operador.

  && – AND lógico: if(x>0 && x<5) //verdadero sólo si las dos expresiones son ciertas.

  || – OR lógico: if(x>0 || y>0) //verdadero si al menos una expresión es cierta.

  ! – NOT lógico: if(!(x>0)) //verdadero sólo si la expresión es falsa

No confundir el operador AND booleano “&&”, con el operador AND para bits “&”, ni el operador OR booleano “||”, con el operador OR para bits “|”.

Operadores de Composición

Las asignaciones compuestas combinan una operación aritmética con la asignación a una variable.

  x++ ; // esto es lo mismo que x = x+1; incrementa una unidad

  x– ; // esto es lo mismo que x = x-1; decrementa una unidad

  x += y; // esto es lo mismo que x = x+y

  x -= y; // esto es lo mismo que x = x-y

  x *= y; // esto es lo mismo que x = x*y

  x /= y; // esto es lo mismo que x = x/y

  x &= y;// esto es lo mismo que x = x & y; AND lógico

  x |= y;// esto es lo mismo que x = x | y; OR lógico

No confundir el operador AND booleano “&&”, con el operador AND para bits “&”, ni el operador OR booleano “||”, con el operador OR para bits “|”.

Operadores de puntero

Los punteros son muy útiles para la manipulación de ciertas estructuras de datos, el uso de punteros puede simplificar el código, y el conocimiento y manipulación de estos son muy útiles.

  & (referencia)

  * (elimina la referencia)

Operadores bit a bit

Los operadores bit a bit realizan el cálculos a nivel de bit.

  & – AND // opera en cada posición de bit de las expresiones de forma independiente, de acuerdo con la siguiente regla: si los dos bits de entrada son 1, la salida resultante es 1, de lo contrario la salida es 0

0  0  1  1    expresión 1

0  1  0  1    expresión 2

0  0  0  1    (operand1 & operand2)

  | –  OR // opera en cada posición de bit de las expresiones de forma independiente, de acuerdo con la siguiente esta regla: si uno o ambos de los bits de entrada es 1, la salida resultante es 1, de lo contrario la salida es 0

0  0  1  1    expresión 1

0  1  0  1    expresión 2

0  1  1  1    (operand1 | operand2)

  ^ – XOR // opera en cada posición de bit de las expresiones de forma independiente, de acuerdo con la siguiente esta regla: si los dos bit de entrada son diferentes (0 o 1), la salida resultante es 1, si son iguales la salida es 0

0  0  1  1    expresión 1

0  1  0  1    expresión 2

0  1  1  0    (operand1 ^ operand2)

  ~ – NOT // opera en cada posición de bit de la expresión de forma independiente, de acuerdo con la siguiente esta regla: cada bit de entrada 1 lo cambia por 0 y cada 0 por 1.

0  1  0  1    expresión 1

1  0  1  0    ~expresión 1

  << – Rota a la izquierda // Este operador hace que los bits del operando se desplacen hacia la izquierda el número de posiciones especificado por el operando de la derecha.

int a = 5;                                              // binary: 0000000000000101

int b = a << 3;                                      // binary: 0000000000101000

  >> – Rota a la derecha // Este operador hace que los bits del operando se desplacen hacia la derecha el número de posiciones especificado por el operando de la derecha. Este operador hay que utilizarlos con cuidado ya que dependiendo del tipo de datos, y si se trabaja, con o sin signo el relleno de datos es diferente

int x = -16;                                            // binary: 1111111111110000

int y = x >> 3;                                     // binary: 1111111111111110

int y = (unsigned int)x >> 3;       // binary: 0001111111111110

Ya estamos listos para realizar nuestro tercer proyecto

Multivibrador Monoestable (Temporizador)

Esquema Eléctrico:

Esquema Práctico:

Código del Programa:

Código fuente:

Temporizador.pde

Ficha del Proyecto:

Temporizador Ficha 3

Vídeo resumen: