Archivo de la categoría: Proyecto Integrado

Teoría, comunicaciones y trabajos de Proyecto Integrado 4º ESO

2014-15. ARDUINO. PUENTE EN H

cabecera-entradas-blog
 ARDUINO. PUENTE EN H

Un Puente H o Puente en H es un circuito electrónico que hace posible que un motor eléctrico DC gire en ambos sentidos, avance y retroceda. Estos puentes están disponibles como circuitos integrados aunque también se pueden construir mediante componentes discretos.

El término de “Puente H” viene de la representación gráfica del circuito. Dicho puente se crea con 4 interruptores mecánicos o mediante transistores. Cuando los interruptores S1 y S4 están cerrados y S2 y S3 abiertos se aplica una tensión positiva en el motor, haciendo que gire en un sentido. Abriendo los interruptores S1 y S4 y los interruptores S2 y S3 cerrados el motor gira en sentido contrario.
El puente H, como ya se ha indicado, se utiliza para invertir el giro de un motor, así como para frenarlo, haciendo un corto entre las bornas del motor. Otra forma de utilizarlo es para permitir que el motor frene bajo su propia inercia, cuando desconectamos el motor de la fuente que lo alimenta.
Lo más común en estos circuitos es utilizar interruptores de estado sólido como los transistores ya que sus tiempos de vida y frecuencias de conmutación son mucho más altas.
Los interruptores son acompañados de diodos (conectados a ellos en paralelo) que permitan a las corrientes circular en sentido contrario al previsto cada vez que se conmute la tensión ya que el motor está formado por bobinados que durante cortos períodos de tiempo se opondrán a que la corriente varíe.
puente-h1
 puente-h2

El armado del circuito requiere básicamente de 12 componentes: 4 transistores, 4 resistores y 4 diodos.

2013-08-26-758

Puente H
Controlar motores usando el SN75441 (Puente H)
A continuación se mostrará cómo usar el SN75441 para controlar dos motores DC de 12V. 
En este esquema se puede observar donde a donde va dirigido cada pin del puente H. Ahora les mostraré un diagrama de pines del puente H. (OJO CON LOS PWM–> EN ARDUINO UNO NO TODOS LOS PINES SON PWM, ASÍ QUE EL ESQUEMA SIGUIENTE LO TENDRÍAS QUE ADAPTAR)
Como se muestra en el diagrama:
  • Los pines 1, 9 y 15 van a la parte positiva del protoboard donde habrá 5V. 
  • El pin 8 va a el pin VIN donde habrá 12 V y con este correrán los dos motores dc. 
  • Los pines 4, 5, 12 y 13 van a la parte negativa del protoboard.
  • El motor izquierdo va en los pines 3 y 6.
  • El motor derecho va en los pines 11 y 14.
  • El pin 2 del puente H va a el pin digital 2 del Arduino. 
  • El pin 7 del puente H va a el pin digital 3 del Arduino.
  • El pin 10 del puente H va al pin digital 8 del Arduino.
  • El pin 15 del puente H va al pin digital 7 del Arduino.
Después de estas conexiones ya puedes programar el Arduino para mover los motores usando el programa de Arduino. 
int I1=6;
int I2=7;
int I3=8;
int I4=9;
int E1=3;
int E2=12;
void setup()
{
pinMode(I1,OUTPUT);
pinMode(I2,OUTPUT);
pinMode(I3,OUTPUT);
pinMode(I4,OUTPUT);
pinMode(E1,OUTPUT);
pinMode(E2,OUTPUT);digitalWrite(I1,LOW);
digitalWrite(I2,LOW);
digitalWrite(I3,LOW);
digitalWrite(I4,LOW);
}void M1Adelante()
{
digitalWrite(I1,LOW);
digitalWrite(I2,HIGH);
}void M1Atras()
{
digitalWrite(I1,HIGH);
digitalWrite(I2,LOW);
}

void M2Adelante()
{
digitalWrite(I3,LOW);
digitalWrite(I4,HIGH);
}

void M2Atras()
{
digitalWrite(I3,HIGH);
digitalWrite(I4,LOW);
}

void paradM1()
{
digitalWrite(I1,LOW);
digitalWrite(I2,LOW);
}

void paradM2()
{
digitalWrite(I3,LOW);
digitalWrite(I4,LOW);
}

void loop()
{
for(int i=1; i<=253; i++)
{
analogWrite(E1,i);
M1Adelante();
delay(10);
}
for(int i=253; i>=1; i–)
{
analogWrite(E1,i);
M1Atras();
delay(10);
}
}

2014-15. INICIACIÓN A ARDUINO. SERVOMOTOR

Cabecera entradas blog

SERVOMOTOR ARDUINO


Conexión de un servo a la placa de Arduino

En este tutorial vamos a ver el funcionamiento de un servomotor y como podemos usarlo con Arduino. En este caso usaremos un microServo. El servomotor tiene 3 cables, Alimentación , Masa y la señal.

Los colores son los siguientes:

  • Rojo – Alimentación(Normalmente 5 V aunque pueden ser mas)
  • Negro o Marrón -Masa
  • Blanco o Naranja – Señal de control (pulso enviado al servomotor)

1

Básicamente un servomotor es un motor de corriente continua con un potenciometro que le permite saber la posición en la que se encuentra y así poder controlarla.
Para controlar el servomotor se le envía pulsos cada 20 ms es decir 50Hz. La anchura del pulso es lo que codifica el angulo de giro , es decir lo que se conoce como PWM, codificación por ancho de pulso. Esta anchura varia según el servomotor pero normalmente va entre 0.5 y 2.5 ms aunque pueden variar.
Dependiendo del tamaño del servo y su consumo es posible que no puedas alimentarlo desde tu placa arduino, en ese caso es necesario una fuente de 5V independiente para poder moverlo,en mi caso uso un microservo por lo que consume poca corriente y se puede alimentar directamente por el Arduino . Sobre el peso que pueden levantar se puede deducir con el par del servo. Normalmente los servos indican el par o torque que pueden realizar para un servo estándar suele ser 5kg/cm es decir puede mover 5kg a 1 cm de distancia. En caso de querer moverlo a 5 cm el servo solo podrá mover 1kg.
A continuación vamos a ver como controlar en Arduino un servomotor. Para ello iniciamos la aplicación de Arduino y pulsamos en sketch->importar libreria ->Servo
2
Con esto incorporamos la libreria, aunque tambien podemos escribir el texto directamente. Una vez echo esto ya podemos usar la libreria Servo.
Ahora vamos a definir nuestro objeto Servo, esto es como definir una variable de tipo int o float, pero un poco mas completa con funciones y campos que le pertenecen. Para ponemos Servo miServo.
3
Con el objeto servo definido vamos a pasar a inicializarlo, para ello usaremos la función attach(pin,min,max) los parámetros de esta función son el pin, casi cualquier pin del Arduino puede controlar un Servomotor y no es necesario que sea uno de los PWM. En las placas que no son la Mega la utilización de la librería Servo inhabilita el PWM en los pines 9 y 10 se usen estos pines o no como servo. Los dos siguientes parámetros son opcionales y indican cual es el ancho de pulso en microsegundos para 0º y para 180º por defecto 544 y 2400.
En este ejemplo usaremos el pin 9.
4
El siguiente paso consiste en enviarle el ancho de pulso al servo con el angulo que queremos. En esta primera parte le enviaremos un angulo constante por ejemplo 90º. Y lo visualizaremos el ancho de pulso en el osciloscopio. Donde en la parte inferior se puede ver el ancho de pulso y como el periodo es de 20 ms aproximadamente.
5
Tener en cuenta que no hemos puesto ningún delay por lo que el objeto servo enviara el pulso cada 20 ms independientemente de nuestro programa.
Para poder interactuar con el servo vamos a incorporar unas funciones que nos permitan moverlo desde el PC. Para ello usaremos el puerto Serie conectado al usb y le mandaremos la letra ‘a’ cuando querramos aumentar 10º o la letra ‘z’ cuando querramos decrementar 10º. Ademas con la función constrain nos aseguramos de que el valor no supere los 180 ni baje de los 0.
6
Para las conexiones simplemente la masa conectada con la del Arduino, la señal del servo(Naranja o blanco) al pin 9 y la alimentación si tenéis un servo pequeño al pin +5v del Arduino , sino tenéis que alimentarlo con alguna fuente externa.
NOSOTROS INCORPORAREMOS UN CÓDIGO MÁS SENCILLO PARA NUESTRA PRÁCTICA:
#include <Servo.h>
Servo Servo_coche;
int potpin = 0;
int val;
void setup()
{
Servo_coche.attach(9);
}
void loop()
{
for(int i=0;i<=180;i=i+1)
{
Servo_coche.write(i);
delay(100);
}
for(int i=180;i>=0;i=i-1)
{
Servo_base.write(i);
delay(100);}
}

2014-15. INICIACIÓN A ARDUINO. SENSOR ULTRASONIDOS Y LCD

Cabecera entradas blog

SENSOR DE ULTRASONIDOS Y PANTALLA DE CRISTAL LÍQUIDO LCD


Midiendo distancias con un sensor de ultrasonidos

Un complemento imprescindible para muchos de robots o vehículos controlados a distancia es un sensor que nos permita saber la distancia libre de obstáculos para movernos. Dependerá de las distancias con las que pretendamos interactuar:

  • Si las distancias van a ser pequeñas podemos emplear sensores de infrarrojos,
  • si queremos movernos en áreas grandes y poder medir distancias en un rango de varios metros el complemento perfecto es unsensor de ultrasonidos.

PRINCIPIO DE FUNCIONAMIENTO

Funciona exactamente igual que un radar, de hecho es un pequeño radar. Emite un pulso de sonido a una frecuencia tan alta que es imperceptible para el oído humano y cronometra el tiempo que el sonido tarda en llegar a un obstáculo, rebotar y volver al sensor. Como la velocidad de propagación del sonido en el aire es un dato bien conocido (343.2 m/s) echamos mano de una conocidísima formula (e = v * t) y calculamos la distancia recorrida por el sonido. Parece fácil ¿verdad?… por que lo es.

EL SENSOR QUE EMPLEAREMOS

Utilizaremos un sensor de ultrasonidos SKU: SEN136B5B cuyo rango de medida va desde los 3 cm a los 4 m, suficiente para cualquier proyecto de robótica y que tiene la gran ventaja de necesitar un único pin de nuestro Arduino para hacerlo funcionar:

Captura1

A pesar de ser habitual encontrar sensores con cuatro pines (ECHO, TRIGGER, GND, PIN), nosotros trabajaremos en clase con el modelo de 3 pines, concretamente con el de la derecha.

Este componente dispone de 3 pines  (gnd, 5v, sig) Conectaremos los 2 pines de alimentación tal y como indican las leyendas que contienen y el tercero será el que utilicemos para comunicarnos con el sensor. El pin de señal se utilizara tanto como entrada o salida digital. Para solicitar que nos mande la información se le envía un pulso al aparato y este nos regresara una señal y en base a la longitud de la señal averiguaremos  la distancia a la que se encuentra el obstáculo en caso de existir o estar a rango.

¿Como puede funcionar con un solo pin? ¿acaso no necesitamos uno para mandarle una señal y otro para recibir la respuesta?. Pues no, se puede hacer todo por el mismo y de una forma nada complicada lo que también nos servirá, de paso, para disipar una de las dudas más comunes entre los principiantes: la inamovilidad de la declaración de pines como entrada o salidas.

En todos los ejemplos de código que nos encontraremos en la web oficial de Arduino y en las demás se utiliza el bloque setup() del Sketch para hacer declaraciones pinMode() y establecer los pines que vayamos a utilizar como entradas o como salidas. En todos estos ejemplos se busca la sencillez y estas declaraciones no se cambian a lo largo del código y esto da lugar a que muchos usuarios tengan la errónea creencia de que sólo se pueden declarar pines como entradas o salidas en el setup() y que una vez establecido un pin como entrada o salida ya no se puede cambiar…. FALSO.

  1. /* Tecnología 4º ESO y Electrónica 1ºBCHT */
  2. /* Sketch medidor ultrasonico */
  3. /* Utilizaremos un sensor de ultrasonidos SKU: SEN136B5B */
  4. unsigned long pulso; // necesitamos una variable para medir el pulso
  5. float distancia; // otra para calcular la distancia
  6. int pin = 8;  // y otra para el pin
  7. void setup() {
  8. Serial.begin(9600);  // inicializamos el puerto serie
  9. }
  10. void loop()
  11. {
  12.   pinMode(pin, OUTPUT);     // ponemos el pin como salida
  13.   digitalWrite(pin, HIGH);  // lo activamos
  14.   delayMicroseconds(10);    // esperamos 10 microsegundos
  15.   digitalWrite(pin, LOW);   // lo desactivamos
  16.   pinMode(pin, INPUT);      // cambiamos el pin como entrada
  17.   pulso = pulseIn(pin, HIGH);  // medimos el pulso de salida del sensor
  18.   Serial.print(“tiempo = “);   // lo pasamos a milisegundos y lo sacamos por el puerto serie
  19.   Serial.print(float(pulso/1000.0));
  20.   Serial.print(“ms, distancia = “);  // ahora calculamos la distancia en cm  y al puerto serie
  21.   distancia = ((float(pulso/1000.0))*34.32)/2;
  22.   Serial.print(distancia);
  23.   Serial.println(“cm”);
  24.   delay(1000);  // esperamos un segundo antes de hacer una nueva medida
  25. }

Captura2

REFLEXIONES SOBRE ALGUNAS VARIABLES

Dentro del código hay que prestar atención a los distintos tipos de datos ya que trabajamos con un unsigned long y con un float y además tenemos que hacer operaciones entre ellos, lo cual puede ser delicado.

El unsigned long es una variable tipo de dato para enteros sin signo (32 bits), números sin punto decimal. Los enteros largos puede ser tan grandes como 4294967295 y tan pequeños como 0. Son almacenados como 32 bits ( 4 bytes ) de información.

La diferencia entre el unsigned long y el int es que éste último es una variable tipo de datos para enteros, números sin punto decimal. Los enteros pueden ser tan grandes como 32.767 y tan pequeños como -32,768. Estos son almacenados como 16 bits de información.

Float es una variable de datos para números de punto flotante, un número que tiene un punto decimal. Los números de punto flotante son usados frecuentemente para aproximar valores análogos y continuos porque tienen más resolución que los enteros. Los números de tipo float pueden ser tan grandes como 3.4028235E+38 y tan pequeños como -3.4028235E+38. Estos son almacenados como 32 bits (4 bytes) de información.

ESQUEMA DE MONTAJE

Captura3

Conexión pantalla LCD a ARDUINO

Podemos conectar una pantalla de cristal líquido a nuestro Arduino.

Captura4

Esta pantalla funciona gracias al famoso y superconocido chip HD44780 que se utiliza en infinidad de proyectos.
Bien, veamos los pines:

  • VSS que es el pin de negativo o masa o 0 volts o GND.
  • VDD es la alimentación principal de la pantalla y el chip, lleva 5 volts.
  • VO es el contraste de la pantalla, debe conectarse con un potenciometro de unos 10k ohms o una resistencia fija una vez que encontremos el valor deseado de contraste. Tengan en cuenta que si no conectan esto, no verán nada.
  • RS es el selector de registro (Register select).
  • RW es el pin que comanda la lectura/escritura. En nuestro caso siempre estará en 0 (conectado a GND) para que escriba en todo momento.
  • E es enable, habilita la pantalla para recibir información.
  • D0~D3 no los vamos a utilizar. Como pueden ver la pantalla tiene un bus de datos de 8 bits, de D0 a D7. Nosotros solamente utilizaremos 4 bits, de D4 a D7.
  • A y K son los pines del led del backlight de la pantalla. A se conectará a 4 o 5 volts y K a gnd.

En nuestro caso utilizaremos el siguiente conexionado:

  • VSS: a GND.
  • VDD: a 5 volts.
  • VO: Al pin medio de un potenciometro de 10K con sus terminales entre 5v y GND.
  • RS: Pin 11.
  • RW: a GND.
  • E: Pin 12.
  • D0~D3: Sin conectar.
  • D4~D7: pines 7 a 10. (bits de datos).
  • A: A 5 volts pasando por una resistencia de 5K para bajar un poco la luminosidad.
  • K: a GND.

Para comandar la HD44780 utilizamos la librería ya conocida LiquidCrystal.

Captura5

 

 

2014-15. PROYECTO INTEGRADO. ARDUINO. INICIACIÓN II

cabecera-entradas-blog

PROYECTO INTEGRADO. INTRODUCCIÓN A ARDUINO II

CONOCIMIENTOS BÁSICOS. PRÁCTICAS COMENTADAS

Encender LED con un pulsador

Tenemos conocimientos suficientes para detectar las partes de un programa o sketch y el momento de declarar variables que emplearemos en el mismo.  Ahora vamos a introducir un elemento básico como es un PULSADOR. Pues bien, un pulsador es un mecanismo que permite el paso de la corriente o no, es decir, en Arduino, permitirá el paso de 5 voltios o bien cortará este flujo (0 voltios). Los pulsadores pueden estar normalmente abiertos (no permiten el paso de tensión) o bien normalmente cerrados (permiten el paso de la tensión que proporciona la placa de Arduino). Cuando permiten el paso, el estado será HIGH o bien valor 1, mientras que, caso contrario, será estado LOW o valor 0. Un led tendrá asociada una resistencia de 220 Ohms, mientras que un pulsador la tendrá de 10KOhms.

Estado digital 5 voltios 0 voltios
 Opción 1  HIGH  LOW
 Opción 2  1  O
 Opción 3  TRUE  FALSE

Un pulsador se encuentra conectado a 5 voltios en un polo y (10KOhmios + Pin) en el otro polo.

Ya en la programación, el número del pin en el que conectamos un pulsador se puede introducir tal cual está serigrafiado en la placa (del 0 al 13) , pero es muy recomendable introducirlo como una variable, constante o definición con el valor introducido previamente en la parte del Sketch en la que se hace la definición de variables, de ahí que definamos int pulsador=(pin donde se conecta). Del mismo modo declaramos que el pulsador será un INPUT.

pinMode (pulsador, INPUT);

// declara el pin al que está conectado el pulsador como entrada

Posteriormente, en el loop definiremos la función IF que es la que comprobará si el pulsador está en posición HIGH o LOW.

Lo primero que se puede apreciar es la aparición de la función if-else. Esta es una condicional que evalúa una condici[on y dependiendo del resultado ejecuta una u otra acción.  En nuestro caso la condición a evaluar será: Si al iniciar loop()  Arduino entrega 5 voltios (HIGH) en el pin que nosotros elijamos, entonces Arduino ejecutará la tarea de secuenciar el encendido de los leds. Podemos emplear el presente esquema como visualización del ejemplo.
t02_31

Pues, después de esta introducción, os dejo una nueva forma de trabajar en clase.  DESARROLLAREMOS NUESTRAS PRÁCTICAS A TRAVÉS DEL PROGRAMA DE AUTODESK que podemos encontrar en este enlace:

http://www.123d.circuits.io

Nos damos de alta con un usuario y contraseña y el programa guardará las programaciones automáticamente en su base de datos asociada a nuestro usuario.

Este programa reúne el software IDE de Arduino (donde confeccionábamos el sketch de Arduino) y la visualización del software FRITZING. Podremos probar nuestro programa, hacerlo funcionar sin necesidad de montarlo físicamente. Del mismo modo, nos permite exportar el código del sketch al IDE de Arduino. Todas nuestras prácticas las desarrollaremos a través del citado software online libre.

Ahora os explicaré cómo desarrollar la sencilla práctica que enciende un led cuando accionamos un pulsador. Se ha desarrollado con 123d.circuits, se ha simulado y se ha exportado al IDE de Arduino para poder exportarlo al soporte físico de Arduino.

Pulsador con led_123

Escogemos los componentes a emplear y los situamos en la protoboard. Asignamos el valor de las resistencia pulsando sobre ellas y editando el dígito y las unidades empleadas. Los componentes se agregan pulsando el icono superior derecho COMPONENTS.

Pulsador con led_123_2

Posteriormente procedemos a programar nuestro código. Pulsamos CODE EDITOR. 123circuits nos escribe un código automático, pero este lo debemos adaptar a nuestras necesidades. Definimos los bloques habituales (DEFINICIÓN DE VARIABLES, VOID SETUP, VOID LOOP). Cuando terminemos la programación, pulsamos START SIMULATION. Ahí podemos observar si nuestro programa es eficiente. Terminada satisfactoriamente la simulación, podemos exportar el código pulsado el icono DOWNLOAD CODE, generándonos un archivo RAR que una vez descomprimido puede ser abierto por el IDE de Arduino. A partir de entonces, procedemos de forma habitual.

Pulsador con led_exportado123

Adjunto os dejo el sketch para que lo probéis y podamos desarrollar las dos prácticas que os dejo al final de esta entrada.

Como podéis ver, aparece el comando if. Intentaré explicar su funcionamiento lógico de forma concisa, alejada de tecnicismos.

El comando if (podemos traducirlo como SI OCURRE ESTO) comprobará si se dan unas condiciones determinadas. Caso de que así sea, procede a ejecutar una serie de comandos. En nuestro caso el if comprueba si el pulsador está accionado. Pues bien, si está accionado cierra el circuito y la placa entrega 5 voltios, por tanto está en estado HIGH. Arduino debe leer pues este valor o voltaje. Como ya sabemos, Arduino lee con la orden digitalRead (para señal digital), por tanto el comando dirá: if (digitalRead(…….)==HIGH). Acto seguido, ¿QUÉ LEEMOS? Pues queremos leer el pin 4, al que hemos denominado PULSADOR, por tanto debemos escribir lo que sigue, en cualquiera de las dos formas, preferiblemente la primera:

A) if (digitalRead(pulsador)==HIGH) {

B) if (digitalRead(4)==HIGH){

Después de la llave abierta, indicamos QUÉ QUEREMOS QUE HAGA ARDUINO DE CUMPLIRSE LA CONDICIÓN. Por tanto, en nuestro caso, tal y como vemos en la captura de pantalla, será poner en estado HIGH el led asociado al pin 7. Finalmente volvemos a cerrar llaves.

Adicionalmente podemos añadir varias condiciones al if, por ejemplo que se den dos simultaneas, teniendo la estructura que sigue:

if (…………)&&(………..) {(ejecuta algo}

Podemos incluir también qué queremos que haga en caso de que no se cumpla el comando if, resultando lo que sigue:

if (…………)&&(………..) {(ejecuta algo}

else {(ejecuta esto otro)}

Otros comparativos pueden ser:

 x == y (x is equal to y)
 x != y (x is not equal to y)
 x <  y (x is less than y)  
 x >  y (x is greater than y) 
 x <= y (x is less than or equal to y) 
 x >= y (x is greater than or equal to y)

PRÁCTICAS BÁSICAS A DESARROLLAR 

PRÁCTICA 1. JUEGO DE BALONCESTO

Debemos programar dos jugadores con dos canastas conectadas a un pulsador cada una de ellas. Cuando un jugador enceste tres veces en su canasta, se encenderá el primer led, así hasta alcanzar tres leds encendidos tras encestar tres veces tres. El jugador que termine antes con su secuencia de encestes ganará con el sonido de un buzzer zumbador, dando por terminado el juego. Montaremos en 123d.circuits, simulamos y exportamos a Arduino IDE. Finalmente, intentaremos fabricarlo físicamente.

PRÁCTICA 2. JUEGO DE REFLEJOS

Dos jugadores. Cada uno vuelve a tener tres leds que encender. En este caso, existirá un led aislado, que se irá encendiendo de forma aleatoria (enciende y apaga sin pauta predefinida). Cuando uno de los jugadores pulse con antelación al otro tres veces, encederá uno de los tres leds, así hasta alcanzar tres leds encendidos tras concluir la secuencia propuesta.

ANEXO

Arduino no recuerda acciones que ha desarrollado en el void loop si vuelve a ejecutar el mismo comando. Por decirlo de alguna forma, al volver a pasar por el mismo comando, borra la lectura realizada en el anterior ciclo y recuerda la nueva lectura hasta que vuelva a pasar por ahí el loop.

Para que recuerde cualquier lectura externa, ya sea un tiempo, una temperatura, una pulsación… debemos generar una variable. Y decimos variable porque varía en función de los datos que se reciben. Así, será variable el número de veces que encestamos, del mismo modo que varía la temperatura exterior o bien el tiempo que pudiera tardar en accionar un pulsador.

En nuestro caso, Arduino debe recordar cuándo se ha pulsado 3 veces un mecanismo (pulsador). Por ello, tenemos que definir una variable entera, previa al void loop para que solo lo lea al principio y una vez. La estructura sería  de este modo:

int contador==0;

Aquí decimos que una variable denominada contador (o cualquier otra cosa que queramos) parte de un valor igual a cero. Ponemos dos iguales para que lo asocie con el valor cero y no con un pin.

Usando el comando if, pudiéramos construir algo parecido a esto: Si accionamos el pulsador, el contador debe sumar 1 a su valor anterior, por tanto, sería:

if (digitalRead(pulsador)==HIGH) {

contador=contador+1;

En este momento, la variable contador modifica su valor (dentro del void loop) y cada vez que vuelva a pasar el loop y compruebe que se ha accionado el pulsador, sumará 1 al valor que tenía antes CONTADOR.  Claro está, nuestro programa objeto (ejercicios propuestos) quiere que cuando ocurra algo 3 veces, encienda un led. Por tanto, dentro del IF primero, debemos colocar otro if que compruebe si CONTADOR es igual a 3 y, caso de que así sea, encender el led primero, si es igual a 6 encender el led segundo y, finalmente, si es igual a 9, encender el led 3 y sonar el zumbador. Por tanto, debemos usar varios if. Como tenemos dos jugadores, debemos asociar tanto leds como contador con cada jugador, así sería, por ejemplo: led_1_P1    led_1_P2  (led primero del player 1…); contadorP1    contador P2  …….

Me pongo a vuestra disposición para cuantas dudas os surjan.

2014-15. PROYECTO INTEGRADO. ARDUINO. INICIACIÓN I

cabecera-entradas-blog

PROYECTO INTEGRADO. INTRODUCCIÓN A ARDUINO

CONOCIMIENTOS BÁSICOS. TRABAJO DE EVALUACIÓN

Algunos apuntes básicos para el desarrollo de la práctica

En este apéndice repasaremos los comandos vistos hasta ahora, su función, su sintaxis y disiparemos algunas dudas sobre ellos.

Arduino no utiliza como entrada un teclado y como salida una pantalla (la configuración más habitual en ordenadores), sino que se conecta directamente a su entorno físico o a periféricos que serán los que interactuarán con el entorno físico. Arduino es un ordenador que enciende y apaga luces, mueve cosas, mide temperaturas, presiones, emite sonidos y se comunica con otros dispositivos.

Básicos del void setup y void loop

pinMode (númerodepin, modo);

El comando pinMode() sirve para establecer a cada pin de entrada o salida digital que vayamos a utilizar el modo en el que lo haremos, es decir, declararemos un pin identificado por su número como entrada o como salida.

El número del pin se puede introducir tal cual está serigrafiado en la placa (del 0 al 13) , pero es muy recomendable introducirlo como una variable, constante o definición con el valor introducido previamente en la parte del Sketch en la que se hace la definición de variables. Esto nos permitirá cambiar su valor sin tener que repasar todo el código para cambiar el número de pin de forma manual y en las ocasiones en las que trabajamos con cables y, por la razón que sea, los queremos cambiar de pin resulta sumamente práctico.

Como modo pondremos OUTPUT o INPUT dependiendo de si queremos que el pin sea una salida o una entrada digital. En mayúsculas, recordemos que en este lenguaje se hace distinción entre mayúsculas y minúsculas, si escribimos una palabra mal el compilador nos dará un error.

Declararemos solo los pines que vayamos a utilizar, no tiene sentido declarar pines a los que no vamos a conectar a nada. ¿Que pasa con los pines que no declaramos? por definición Arduino trata a todos los pines como entradas a menos que especifiquemos lo contrario, esto significa que los pines que vayamos a utilizar como entradas no sería necesario declararlos con el comando pinMode(), solo los que vayamos a utilizar como salidas. Pero esto último no es nada recomendable, de hecho casi sería mejor que no lo hubiera dicho.

No cuesta nada declarar cada pin que utilice el Sketch como entrada o salida en el setup() y si lo documentamos correctamente ganamos en claridad y limpieza. Esto es especialmente útil si vamos a publicar nuestro Sketch o si lo vamos a tener que volver a editar en el futuro.

pinMode (pulsador, INPUT);  // declara el pin al que está conectado el
//pulsador como entrada

Este ejemplo es perfectamente comprensible para todo el que lo lee hoy y dentro de seis meses, si no lo hacemos así y suponemos que un pin está conectado a un pulsador y trabajamos con el directamente será difícil de entender por otra persona… en unos meses incomprensible incluso para nosotros.

digitalWrite (númerodepin, estado);

El comando digitalWrite() sirve para establecer la salida digital en el pin que establezcamos. Para el parámetro del número de pin digital sirve todo lo dicho en la explicación del comando pinMode(), mejor desde una variable, constante o definición y por los mismos motivos.

Este comando sólo admite dos estados HIGH o LOW, alto o bajo y que se corresponden con un 1 ó un 0. De hecho podríamos introducir el comando de las siguientes formas:

1
2
3
digitalWrite(pin, HIGH);   // la forma correcta de hacerlo
digitalWrite(pin, 1);   // no es nada conveniente hacerlo así
digitalWrite(pin, estado);   // donde estado es una variable

En el último caso la variable de nombre estado, declarada en la cabecera del Sketch, puede ser del tipo entero (int) y contener un 0 o un 1 o asignarle los valores HIGH o LOW.

Eléctricamente un nivel HIGH de corresponde a +5v en la salida del pin y el nivel LOW a 0v.

Los modelos de Arduino que trabajan a 3’3v tienen esta misma salida para el nivel HIGH.

El comando delay

delay(número);

El comando delay() detiene la ejecución del Sketch durante el tiempo que le especifiquemos expresado en milisegundos.

Generalmente utilizaremos este comando de forma muy limitada precisamente por esa característica suya de detener completamente la ejecución del Sketch. Es útil en algunos procesos de comunicación para darle tiempo a un periférico a que procese la información que le mandamos y nos devuelva un resultado o para impedir rebotes en la lectura de sensores, y en estos casos el intervalo de tiempo lo introduciremos de forma directa como un número.

Si necesitamos pasarle al comando delay() el tiempo dentro de una variable hay que tener en cuenta que esta debe ser del tipo unsigned long, es decir, un número de 32 bits sin signo (veremos lo que esto significa en el siguiente comando).

El bucle FOR

El bucle for es una estructura que se utiliza cuando queremos que una serie de acciones se repita un número determinado de veces, para ello se necesita de una variable índice, una condición y un incrementador.
Su sintaxis es la siguiente:

1
2
3
4
for (variable índice; condición; incrementador)
{
// comandos
}

Así que si queremos que un led parpadee 5 veces tras accionar un pulsador… aprovecharemos el código del ejemplo anterior:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// variables para el pulsador y el led
int pulsador = 12;
int led= 4;void setup()
{
pinMode(pulsador, INPUT);
pinMode(led, OUTPUT);
}void loop()
{
if (digitalRead(pulsador) == HIGH)
{
for (int i = 0; i<=4; i++)
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
}
else
{
digitalWrite(led, LOW)
}
}

Hay que tener en cuenta varios aspectos que hacen del bucle for una estructura peculiar:

-necesita una variable índice que en el ejemplo hemos definido directamente como int i = 0, esta variable índice es local y solo es accesible dentro del bucle for.

-necesita de una condición y se ejecutara tantas veces como sea necesario mientras se cumpla la condición, en el ejemplo hemos hecho que el código se repita mientras que la variable índice sea menor o igual a 4, como hemos empezado con el valor 0 para la variable índice esta condición solo se cumplirá 5 veces.

-necesita un incrementador de la variable índice. Cada vez que se evalúa la condición y se ejecuta el código se incrementa la variable índice, en nuestro caso el incrementador tiene la forma i++, que es la forma abreviada de i = i + 1.

Entradas y salidas analógicas

Ya hemos visto como trabajan las E/S digitales: son todo o nada, solo admiten esos dos estados. Para muchos proyectos esto nos sera útil pero para otros proyectos necesitaremos ir un paso mas allá y utilizaremos sensores o actuadores analógicos.

Las placas mas difundidas como la Arduino UNO o la Arduino Leonardo trabajan de 0 a 5 voltios, en la forma digital estos son los dos niveles lógicos: 0v para el nivel bajo (LOW) y 5v para el nivel alto (HIGH). Cuando hablamos de valores analógicos podremos trabajar con valores comprendidos entre el mínimo y el máximo. En el caso de las entradas analógicas (marcadas de A0 a A5) Arduino utiliza un convertidor analógico-digital de 10 bits, lo que nos da 1024 niveles intermedios entre 0 y 5 voltios numerados del 0 al 1023. Para las salidas analógicas Arduino UNO utiliza los pines 3, 5, 6, 9, 10 y 11 (en el caso de la Arduino Leonardo los mismos pines mas el numero 13) con una señal PWM de 8 bits, lo que nos da 256 niveles numerados del 0 al 255.

Para hacer lecturas analógicas utilizamos el comando analogRead que tiene la siguiente sintaxis:

analogRead(número de pin);

Donde “número de pin” es uno de los pines marcados de A0 a A5. Este comando nos devolverá un valor de 0 a 1023, por lo que generalmente lo usaremos como asignación del valor a una variable:

Variable = analogRead(A0);

o como parte de una comparación:

1
2
3
4
If (analogRead(A0) &lt;= 500))
{
// comandos
}

En el caso de las salidas analógicas utilizamos el comando analogWrite de la siguiente manera:

analogWrite(pinPWM, valor);

Como caso práctico vamos a ver un sencillo programa en el que utilizaremos un potenciómetro para la toma del valor analógico y como salida uno de los colores del LED, pues sus patillas están conectadas a las salidas PWM 9, 10 y 11.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int valor; // definimos una variable en la que almacenaremos el valor leído del potenciómetro
int pin = 9; // pin PWM de salidavoid setup()
{
pinMode(led, OUTPUT);
}

void loop()
{
// tomamos una lectura analogica y la almacenamos en la variable valor
valor = analogRead(A0);

/* valor contiene un numero de 0 a 1023 y la salida la tenemos que dar de 0 a 255
por lo que tenemos que convertirla de un rango a otro, la forma mas sencilla es
dividir por 4 */

valor = valor / 4;

// ahora sacamos el valor analogico por el pin PWM
analogWrite(pin, valor);
}

Este sencillo ejemplo hace que al girar el potenciómetro con el correspondiente mando el LED  brille más o menos

Práctica a desarrollar

Adjunto os dejo la práctica que debéis realizar todos los alumnos de proyecto integrado para este trimestre. La originalidad de cada planteamiento para resolver este problema, básico por otra parte, será determinante para valoraros vuestra calificación trimestral, por ello, os recomiendo que, aunque sea el mismo ejercicio para todos, cada uno de vosotros intente ser original al resto, aportando indicaciones y comentarios, así como ampliando cualquier aspecto fuera del enunciado del problema, por ejemplo, haciendo un video-tutorial del desarrollo de la práctica.

 
CES_ARDUINO_BASICO1CES_ARDUINO_BASICO2

TECHNOLOGY WITH CAMBRIDGE ENGLISH CENTENARY

cabecera-entradas-blog

CAMBRIDGE ENGLISH CENTENARY COMPETITION FOR SCHOOLS 2013

The art teacher drew a huge European map on the floor and some students from primary education coloured it and wrote the names of the countries. We did an activity on this “painting” with the youngest ones (3-5).

(c) M.Carmen Gómez OLYMPUS DIGITAL CAMERA 57 OLYMPUS DIGITAL CAMERA

Our students ( from 6 to 18) looked for information about the member countries of the European Union such as typical food, tourist sights, fictional characters, famous people, coat-of-arms, their flags, customs, festivals, animals, etc. Everything is glued to a mural painting that the students drew.

(c) M.Carmen Gómez IMG_2202 IMG_2215 IMG_2459 OLYMPUS DIGITAL CAMERA

We( The English and Technology teachers) have filmed our pupils telling us some very interesting facts about each country using several programs to edit everything: Sony Vegas Pro, BuidAR, Audacity, Photoshop, Adobe Premiere cs5, Sketchup and 3dstudio max. The Technology teacher has used “BuidAR”  for  “augmented reality” in 14 countries.

 

(c) FJ Cortés

DSC_0178 DSC_0267 DSC_0274 DSC_0278

The good examples of how we made these experiences can be seen in the links.

Este trabajo, empezando por esta introducción, no podría ser posible sin nuestra profe de inglés, M.Carmen Gómez, sin la que esta fantástica experiencia no habría sido posible, con una coordinación admirable para mover a todo un colegio como el nuestro.

Proyecto Integrado 4ºB ESO. La WEB 2.0 y “Ocurrió… hoy”

PROYECTO INTEGRADO 4ºB ESO

COLEGIO ESPÍRITU SANTO DE BAENA (CÓRDOBA)

PROFESOR: FCO. JAVIER CORTÉS ARIZA

OCURRIÓ … HOY

En continuidad con la programación de la asignatura de Proyecto Integrado, os propongo un nuevo trabajo que vinculará narración literaria, hechos históricos y nuevas tecnologías aplicadas a la edición gráfica y de video, todo ello apoyado en la llamada WEB 2.0.

1. Pues bien, empezaremos por elegir un determinado fragmento de la Historiade la Humanidad, destacado por su particularidad, su trascendencia a lo largo del tiempo, pero… fundamentalmente, por su capacidad para ser adaptada a un suceso de nuestro tiempo. Por ejemplo podríamos tomar la leyenda de la muerte de Esquilo, escritor griego que vivió rondando el 500 a.C y padre de las tragedias griegas, que cuenta como murió cuando un águila confundió la cabeza del escritor con una piedra (ya que era calvo) y le lanzó una tortuga (las águilas cazaban tortugas  abrían su caparazón tirándolas contra rocas).

2. A continuación procederemos a adaptar la historia elegida a nuestro tiempo, con personajes cotidianos, cercanos a nosotros (aunque sin personificar) y, a ser posible, desarrollada en nuestro pueblo, colegio… Es fundamental el empleo de recursos literarios. El empleo correcto de cada uno de ellos dentro de un contexto adecuado será valorado con 0.2 puntos por el empleo de cada una de estas figuras. Es necesario el uso de, al menos, 10 recursos, incluidos en la última página de este documento.
3. Finalmente, haremos un pequeño relato gráfico a modo de cómic o similar empleando un programa informático online que se os dejará convenientemente en clase. Emplearemos el programa freeware MAKE BELIEFS COMIX
MAKE BELIEFS COMIX
El resultado que he obtenido con este programa freeware, en respuesta al tema elegido de Esquilo, sería…

Para la redacción se empleará el programa GOOGLE DOCS. Para usarlo debemos crear una cuenta de GMAIL y podremos trabajar con esta herramienta que procesa textos.

Evidentemente, cada aportación semanal será valorada hasta con 0.5 puntos por semana, dependiendo de la calidad y extensión (4 semanas para una valoración final de 2 puntos)

Trabajo en clase se valorará con 4 puntos y montaje animado de la historia con 2 puntos

CONTENIDO DE LA PRÁCTICA ARCHIVO PDF: Proyecto Integrado. Ocurrió … hoy