Académique Documents
Professionnel Documents
Culture Documents
Mostrar las acciones bsicas que pueden realizarse con un control de ordenador:
accionamiento de diodos luminiscentes LEDs.
Diagramas de flujo.
PROCEDIMIENTOS
Disear programa para controlar las entradas y salidas digitales de una controladora.
Inters por abordar problemas que, a priori, pueden parecer difciles de solucionar.
pinMode (ntcPin,INPUT);
pinMode (2, OUTPUT);
pinMode (3,OUTPUT);
pinMode (4,OUTPUT);
pinMode (5,OUTPUT);
pinMode (6,OUTPUT);
pinMode (7,OUTPUT);
Serial.begin (9600);
}
void loop()
valanalogRead(ntcPin);
potmap(val,680,745,2,8);
Serial.println(val);
switch(pot)
case 2:
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
break;
case 3:
digitalWrite(2,LOW);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
break;
case 4:
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
break;
case 5:
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
break;
case 6:
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
break;
case 7:
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
break;
case 8:
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
break;
}
}
Pag 1 de 8
PROTOTIPO
SEMAFORO CONTROLADO
POR TECLADO
AUTOR: JOSE IGNACIO CASCAJO JIMENEZ
24-octubre-2011
!"#$%&' )#* +,&-' ./01202341256"216 61"7/32 83 892:
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 2 de 8
1. JUSTIFICACIN
Durante la realizacin del curso 'La microcontroladora Auduino en Secundaria' desarrollado en el ES
Andres Benitez de Jerez, organizado por el CEP de Jerez e impartido por D. Francisco J. Perea Reyes
(profesor de nformtica del ES Ciudad Jardn de Mlaga), durante los das 29-sept al 05-oct del ao 2011,
se tena como parte final del curso la preparacin y presentacin de un programa desarrollado por cada
alumno asistente al curso, de tema libre y que funcionase. De este modo se trata de cubrir un aspecto muy
importante dentro de la formacin que es el llevar a la prctica lo aprendido y ponerlo a funcionar.
El curso ha estado dirigido a profesores de secundaria de Tecnologa e nformtica y han asistido unos 17
alumnos. Hemos utilizado la placa Arduino Uno, adems de un set interesante de dispositivos electrnicos
(bsico, pero muy interesante) con resistencias (fijas y variables), pulsadores, leds, cables conectorizados
cortos y largos, armazn para pilas, . y la caja de plstico para guardar todo.
El objeto del curso era dotar al profesorado de conocimientos y habilidades para el trabajo con
microcontroladores de cara a su aplicacin en el segundo ciclo de educacin secundaria obligatoria a
travs de la asignatura de Tecnologa. Para ello se ha trabajado sobre una plataforma de cdigo libre
Arduino, ampliamente utilizada en la comunidad educativa y premiada en numerosos certmenes sobre
desarrollos electrnicos.
2. INTRODUCCIN
Es la primera vez que me he enfrentado en tener delante un microcontrolador y tener que "cacharrear'' para
hacerlo funcionar.
nicialmente no pareca difcil ni complicado, todo eran dos o tres comandos o instrucciones para luego, casi
por arte de magia, despus de disponer la "electrnica, se haca que un simple led se encendiera o
apagara, o que una simple "chicharra hiciera ms o menos ruido, o que un motorcillo de juguete fuera ms
o menos veloz. La cosa vista as no pareca difcil.
Sin embargo, todo se haca cada vez algo farragoso: nuevos comandos y nuevos elementos electrnicos.
Tambin haba que darle al "cerebro para dar alguna solucin mediante instrucciones y Entradas y Salidas
digitales o analgicas. En fin, al final parece que lo que has aprendido o entendido no deja de ser una mera
gota de agua dentro de un ocano de electrnica e instrucciones.
No obstante el prrafo anterior, he llegado a casa y despus de das dndole vueltas y tener despistados a
toda mi familia, pues "cacharrear con el Arduino, unos cuantos leds, resistencias y cables sobre la mesa de
la cocina no es de muy inteligentes, he llegado a "construir un semforo. Vaya! Un semforo pero algo
especial, o al menos para m.
Se trata de un semforo hecho de verdad para la ciudad, en el que el peatn tenga preferencia y mejore la
sealizacin ya que actualmente no est muy clara.
Espero poder dar toda la informacin en el apartado DESCRPCN.
3. EQUIPAMIENTO UTILIZADO
a) Para el desarrollo del programa se han utilizado
- microcomputador ARDUNO UNO
- entorno de desarrollo de Arduino 0021 que hay en los ordenadores de la Junta, que para instalarlo hay que
realizar las siguientes acciones
Aplicaciones
Educacin
Tecnologia
Entorno de desarrollo de Arduino
Se abre la aplicacin de desarrollo Arduino 0021
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 3 de 8
- conexin PC-Arduino con cable USB
- para poder funcionar correctamente, tanto con la placa como con la conexin serie va el cable USB es
necesario realizar las siguientes acciones desde la aplicacin de desarrollo Arduino 0021
En Tools
Board
Seleccionamos la opcin Arduino Uno
Serial Port
Seleccionamos el puerto serie (USB del porttil) donde hemos conectado la placa o
microprocesador.
- Para cargar el programa en el que se tenga grabadas las instrucciones se debe hacer del siguiente modo
En File
Sketchbook
Seleccionar el nombre del archivo que tiene cargado el programa y debemos descargar en
el micro Arduino
b) Para los componentes electrnicos se han utilizado
- cableados varios (6 cables para los leds y 1 cable para conectar GND-tierra)
- 6 leds (2 rojos, 2 amarillos y 2 verdes) y sus respectivas resistencias de 10k para limitar la corriente y
tensin)
- 1 placa breadboard
c) Para el desarrollo de la memoria: cmara de fotos digital, Aplicacin Fritzing, para los esquemas y
ordenador con procesador de textos y .pdf
Para ms informacin puede contactarse con plataforma Arduino en www.arduino.cc o www.arduino.cc/es
y sobre Fritzing en www.fritzing.org
4. DESCRIPCIN
Bueno, el nombre que he dado al proyecto es Semforo controlado por Teclado ya que se trata de un
Semforo, similar al que vemos en las calles de nuestras ciudades con las Luces para los vehculos y las
luces para los peatones pero que tiene preparada una conexin por teclado por si se quieren desarrollar
mejoras para el futuro.
a) El funcionamiento del programa es bsicamente el siguiente.
Se dispone de un semforo con 3 luces para vehculos (roja, amarilla y verde, con el significado que tienen
esas tres luces habitualmente): roja, parar; amarilla, precaucin y verde, marcha.
Los cambios de una a otra se han variado algo respecto a lo convencional. Si el semforo est en verde
(que es la situacin de inicio del sistema, verde para vehculos y rojo para peatones), cuando se ha agotado
el tiempo o el peatn pulsa la tecla 'H', el verde sigue encendido y simultneamente se enciende la amarilla
durante unos segundos. Pasados esos segundos se apagan el verde y el amarillo y se enciende el rojo.
Transcurrido un tiempo de encendido del rojo para vehculos (pocos segundos), se apaga el rojo de
peatones y se enciende el verde de peatones.
El verde de peatones realiza un parpadeo que va aumentando de velocidad a medida que transcurre el
tiempo (quiere indicar al peatn que se est agotando el tiempo). Cuando el tiempo finaliza se apaga el
verde del peatn y se enciende el rojo del peatn. De este modo estn rojo la luz de los vehculos y la de los
peatones durante unos 2-3 seg. Pasados este tiempo el rojo de vehculos se apaga y se enciende el verde
de vehculos, volviendo a la situacin inicial.
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 4 de 8
Por tanto, en resumen el funcionamiento es similar al de uno de nuestras calles excepto que el amarillo de
los vehculos se enciende simultneamente con el verde de vehculos durante un tiempo prudencial. El
tiempo aproximado de funcionamiento en verde para los vehculos es de unos 20 seg y para el verde de los
peatones es de unos 16 seg.
b) Funcionamiento del semforo cuando pulsa la tecla 'H' el peatn
El semforo funciona siempre como el caso anterior si es que el peatn no ha pulsado la tecla 'H', ya que si
es esta el funcionamiento vara.
En caso de pulsar el peatn la tecla 'H', el semforo minimiza el tiempo de espera del peatn (ya no tiene
que esperar todo el ciclo de los 20 segundos de espera). Mediante un programa en el que se realiza una
especie de bucle de supervisin de la tecla que llega al Arduino (durante el tiempo que el semforo tiene el
verde para vehculos y rojo para peatones). Si en este tiempo llega la tecla 'H' el semforo tarda muy poco
en iluminar la luz amarilla del peatn (significa que el peatn ha pulsado la tecla necesaria para pasar) y
sigue la luz roja del peatn y la verde de los vehculos.
En pocos segundos desde que el peatn ha pulsado comienza el proceso entero de cambio de luces del
semforo (tal y como se explic al principio en el funcionamiento bsico, slo que ahora parte de que la
situacin es que para el peatn estn encendidas la roja y la amarilla y para el vehculo est encendida la
roja). De este modo el peatn tarda poco tiempo en esperar para cruzar y la sealizacin, respecto a lo
actual, mejora sustancialmente.
c) Servicio del teclado
La introduccin del teclado en el proyecto del semforo no es otra que disponer del mismo para realizar
otras aplicaciones y/o aadir funcionalidades. En este caso slo recoge las teclas que se han pulsado y slo
hay actuacin cuando se pulsa la 'H'.
Como mejoras podran proponerse otras actuaciones que realizara este semforo o grupos de semforos
segn cual fuese la tecla que se pulsara o, tambin, realizar un control remoto del mismo.
Se dejan aqu estos comentarios para si alguien, prximamente, quisiera seguir trabajando este proyecto e
incorporarle mejoras o novedades.
5. PROGRAMA REAL
magen del programa y comandos sobre el ordenador de la Junta y con el programa Arduino 0021.
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 5 de 8
6. PLACA DE PROTOTIPOS
Placa de prototipos del semforo con control por teclado. Se han separado los leds en vertical para que se
vean mejor las pistas y los conexionados, adems se han pintado los cables para diferenciar unos de otros y
saber cuales son las entradas/salidas utilizadas.
7. ESQUEMA DEL PROTOTIPO ELCTRICO
Esquema del Prototipo elctrico del Semforo
(realizado con la aplicacin Fritzing)
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 6 de 8
8. INTRUCCIONES Y LNEAS DE COMANDO
Se incluye un listado completo de las instrucciones y las explicaciones de las mismas (estn realizadas
sobre las mismas lneas de comando).
// definicion de 3 variables con el valor 13, 12 y 11 que van a ser
// las salidas digitales de las luces del semaforo para vehiculos
int luzRoja = 13;
int luzAmar = 12;
int luzVerd = 11;
// definicion de 3 variables con valores 10, 9 y 8 que van a ser
// las salidas digitales de las luces del semaforo para peatones
int luzPulsa = 10;
int luzPeatRoja = 9;
int luzPeatVerd = 8;
// almacena el valor de la tecla puslada
int tecla = 0;
// variables de tipo contador
int contador = 0;
int n = 0;
// variables que controlan tiempo de encendido y apagado del verde
// del semaforo del peaton
int verdEncendido = 1000;
int verdApagado = 500;
// variable de control si se ha pulsado la tecla correspondiente
// en este caso 'H' por el peaton
int siPulsa = 0;
void setup() {
// declara como salidas las luces roja, amarilla y verde del semaforo de coches
// y las amarilla (luzPulsa), verde y roja del semaforo de peatones
pinMode(luzRoja, OUTPUT);
pinMode(luzAmar, OUTPUT);
pinMode(luzVerd, OUTPUT);
pinMode(luzPulsa, OUTPUT);
pinMode(luzPeatRoja, OUTPUT);
pinMode(luzPeatVerd, OUTPUT);
// declaracion del interface de comunicacion con el teclado
Serial.begin(9600);
}
void loop() {
// inicializa siPulsa a 0, pues no se ha pulsado la tecla 'H' por el peaton
// tambien inicializa tecla a 0
siPulsa=0;
tecla=0;
// inicia todas las luces del semaforo Verde para coches y Rojo para peatones
digitalWrite(luzRoja,LOW);
digitalWrite(luzAmar,LOW);
digitalWrite(luzVerd,HGH);
digitalWrite(luzPulsa,LOW);
digitalWrite(luzPeatRoja,HGH);
digitalWrite(luzPeatVerd,LOW);
delay(1000);
// durante unos 20 segundo realiza un seguimiento de ver si se pulta el teclado
// por parte del peaton, para eso esta este bucle for
for(n=0;n<=200;n++){
if(siPulsa==0){
delay(100);
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 7 de 8
pulsaTecla();
}
}
// si en el bucle fior anterior No se ha pulsado la tecla 'H' entones ha pasado el tiempo
// de verde para los coches y ya, por tiempo, hay que cambiar las luces del semaforo de verde a rojo
if (siPulsa==0){
cambiaLuces();
}
}
//funcion que detecta si se ha pulsado una tecla y que tecla es
//si la tecla es 'H' entones cambia las luces para que pase el peaton
//en caso contrario sigue ejecutandose dentro de un bucle hasta
//acabar los aproximadamente 20 segundos
void pulsaTecla(){
if (Serial.available()){
tecla=Serial.read();
if (tecla == 'H'){
digitalWrite(luzPulsa,HGH);
delay (3000);
digitalWrite(luzAmar, HGH);
delay (3000);
digitalWrite(luzRoja, HGH);
digitalWrite(luzAmar, LOW);
digitalWrite(luzVerd, LOW);
digitalWrite(luzPulsa, LOW);
delay (2000);
digitalWrite(luzPeatRoja, LOW),
digitalWrite(luzPeatVerd, HGH);
//llama a la funcion que hace el cambio de luces para que
//pase el peaton
pasaPeaton();
//pone a 1 siPulsa para saber que ha pulsado la tecla 'H'
//antes de salir del la instruccion if
//de este modo no se ejecutara otra vez el bucle
siPulsa=1;
}
}
}
//cambia las luces del semaforo en caso de que no se pulse
//la tecla 'H' por parte del peaton
void cambiaLuces(){
//cambia el semaforo de coches
digitalWrite(luzAmar, HGH);
delay(3000);
digitalWrite(luzRoja, HGH);
digitalWrite(luzAmar, LOW);
digitalWrite(luzVerd, LOW);
delay(2000);
// cambia el semaforo del peaton
digitalWrite(luzPulsa, LOW);
digitalWrite(luzPeatRoja, LOW),
digitalWrite(luzPeatVerd, HGH);
//realiza el encendido parpadeante del paso del peaton
pasaPeaton();
}
//realiza el encendido parpadeante del paso del peaton
Proyecto: Prototipo SemaIoro Controlado Por Teclado
Jose Ignacio Cascajo Jimenez Pag 8 de 8
void pasaPeaton(){
// inicializacion tiempos de encendido y apagado luz cruce peaton
verdEncendido=1000;
verdApagado=500;
// bucle para realizar encendido y apagado de luz verde peaton
for (contador =0; contador<=25; contador++){
delay(verdEncendido);
//disminucion del tiempo de encendido
verdEncendido=verdEncendido*0.9;
digitalWrite(luzPeatVerd, LOW);
delay(verdApagado);
//disminucion del tiempo de apagado
verdApagado=verdApagado*0.9;
digitalWrite(luzPeatVerd, HGH);
}
// termina de cambiar las luces del semaforo
digitalWrite(luzPeatVerd, LOW);
digitalWrite(luzPeatRoja, HGH);
delay(3000);
digitalWrite(luzVerd, HGH);
digitalWrite(luzRoja, LOW);
}
Teclado Electronico
1. lntroduccion
La undad ddctca pretende dar a conocer e funconamento de a tar|eta controadora Arduno, empeando como ho
conductor e monta|e de un tecado eectrnco de una escaa.
Hemos eegdo este monta|e tan repettvo para permtr a nuestros aumnos/as observar cmo se reazan os prmeros pasos
y que, a contnuacn, sgan soos hasta competar e crcuto y e cdgo de manera ntutva.
2. Objetivos
Conocer os prncpos fundamentaes de a programacn y a automatzacn.
Reazar un monta|e rea de un ob|eto de uso cotdano.
Comprender os prncpos que subyacen en e funconamento de os componentes eectrncos empeados: resstenca,
pusador y zumbador.
Vaorar a mportanca de contro y a robtca para resover probemas de nuestro entorno.
3. Temporalizacion
1 Sesn: E zumbador
Se expca e funconamento de zumbador.
Se cacuan as frecuencas de cada nota musca de a escaa 3. Bscamente, generamos un tren de pusos, pero con a
frecuenca de cada una de as notas. E tono est cacuado en funcn de a nversa de a frecuenca de a nota.
2 Sesn: E pano de una teca
Se entrega e monta|e en protoboard y e cdgo que permte hacer funconar un tecado de una soa teca.
Anss de monta|e y de cdgo.
3 y 4 Sesones: E tecado
Nuestros aumnos/as competan e cdgo y os componentes sobre a protoboard para construr un tecado competo de una
escaa 3.
4. !"#$%&
nt speakerOut =13; nt notado = 1915; nt notare = 1700; nt notam = 1519; nt notafa = 1432; nt notaso = 1275; nt
notaa = 1136; nt notas = 1014; nt notados = 1804; nt notares = 1607; nt notafas = 1351; nt notasos = 1204; nt
notaas = 1073; nt d; nt re; nt m; nt fa; nt so; nt a; nt s; nt dos; nt res; nt fas; nt os; nt as;
od setup(){
pnMode (speakerOut, OUTPUT); pnMode (1, INPUT); pnMode (2, INPUT); pnMode (3, INPUT); pnMode (4, INPUT);
pnMode (5, INPUT); pnMode (6, INPUT); pnMode (7, INPUT); pnMode (8, INPUT); pnMode (9, INPUT); pnMode (10,
INPUT); pnMode (11, INPUT); pnMode (12, INPUT);
}
vod oop() {
d=dgtaRead(12); re=dgtaRead(11); m=dgtaRead(10); fa=dgtaRead(9); so=dgtaRead(8); a=dgtaRead(7);
s=dgtaRead(6); dos=dgtaRead(5); res=dgtaRead(4); fas=dgtaRead(3); sos=dgtaRead(2); as=dgtaRead(1);
f (d==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notado);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notado);
}
f (re==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notare);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notare);
}
f (m==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notam);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notam);
}
f (fa==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notafa);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notafa);
}
f (so==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notaso);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notaso);
}
f (a==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notaa);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notaa);
}
f (s==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notas);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notas);
}
f (dos==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notados);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notados);
}
f (res==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notares);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notares);
}
f (fas==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notafas);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notafas);
}
f (sos==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notasos);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notasos);
}
f (as==HIGH){
dgtaWrte(speakerOut,HIGH);
deayMcroseconds(notaas);
dgtaWrte(speakerOut, LOW);
deayMcroseconds(notaas);
} }
5. !"#$%&'
Se necestan os sguentes componentes: 1 zumbador, 12 resstencas de 1kO y 12 `pusadores.
UNIDAD DIDCTICA
GENERACIN ACSTICO LUMINOSA DEL
CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
Moiss Garca Martnez
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 2
NDICE:
INTRODUCCIN
CARACTERSTICAS DE LA MICROCONTROLADORA ARDUINO
UNO
PROGRAMA
FOTOS DEL MONTAJE
COMPETENCIAS BSICAS TRABAJADAS EN ESTA UNIDAD
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 3
INTRODUCCIN:
La presente unidad didctica est realizada como actividad de fase no presencial
del curso La microcontroladora Arduino en Secundaria, y consiste en la generacin de
una seal tanto acstica como luminosa del cdigo Morse, para lo cual aparte de la
controladora, usaremos un pequeo zumbador y un LED con su resistencia limitadora.
El cdigo Morse es un cdigo o sistema de comunicacin que permite la
comunicacin telegrfica a travs de la transmisin de impulsos elctricos de longitudes
diversas o por medios visuales, como luz, sonoros o mecnicos. Este cdigo consta de
una serie de puntos, rayas y espacios, que al ser combinados entre si pueden formar
palabras, nmeros y otros smbolos.
Este sistema de comunicacin fue creado en el ao 1830 por Samuel F.B. Morse,
un inventor, pintor y fsico proveniente de los Estados Unidos, quien pretenda
encontrar un medio de comunicacin telegrfica. La creacin de ste cdigo tiene su
origen en la creacin del seor Morse de un telgrafo, invento que le trajo bastante
dificultades, ya que, en un principio, el registro de este fabuloso invento le fue negado
tanto en Europa como en los Estados Unidos. Finalmente, logr conseguir el
financiamiento del gobierno americano, el que le permiti construir una lnea telegrfica
entre Baltimore y Washington. Un ao despus se realizaron las primeras transmisiones,
resultando stas bastante exitosas, lo que dio pie a la formacin de una enorme
compaa que cubrira a todos los Estados Unidos de lneas telegrficas.
Como se dijo anteriormente, las letras, nmeros y dems signos, se representan
en el cdigo Morse a travs de puntos y lneas que se transmiten como impulsos
elctricos que producen una seal de luz o de sonido de una duracin determinada:
CDIGO MORSE (Alfanumrico)
Letra Cdigo Letra/Nmero Cdigo
A . S . . .
B . . . T
C . . U . .
D . . V . . .
E . W .
F . . . X . .
G . Y .
H . . . . Z . .
I . .
J . 1 .
K . 2 . .
L . . . 3 . . .
M 4 . . . .
N . 5 . . . . .
. 6 . . . .
O 7 . . .
P . . 8 . .
Q . 9 .
R . . 0
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 4
El punto es considerado, en el cdigo Morse, como una unidad, que en tiempo
equivale, aproximadamente a 1/25 de segundo. La lnea, en tiempo, equivale a tres
puntos. Cada letra se separa por un silencio de tres puntos de duracin, mientras que
cada palabra se separa por cinco puntos.
CARACTERSTICAS DE LA MICROCONTROLADORA ARDUINO UNO
Arduino puede ser utilizado para desarrollar objetos autnomos e interactivos,
como prototipos o interactuar con software instalado en el ordenador. Dada su rpida
curva de aprendizaje y su precio econmico es ideal para educadores, diseadores y
cualquiera interesado en la electrnica y robtica.
El compilador necesario para programarlo est disponible de forma gratuita en
www.arduino.cc y est disponible para Mac OS X, Windows y Linux.
Arduino UNO es la versin mejorada de su predecesor Duemilanove. Incluye
funcin de autoreset, proteccin de sobrecargas, conector USB para programarlo,
totalmente montado con componentes miniatura SMD (salvo el microcontrolador, para
poder cambiarlo facilmente) y nuevo bootloader OptiBoot a 155kbps.
La placa se entrega completamente ensamblada y probada con un
microcontrolador AVR ATmega328 con un cristal de cuazo de 32 Mhz.
Se entrega con el nueo chip Atmega328 de AVR con 32 KB de memoria de
programa en lugar de 16 KB de la anterior versin, RAM de 2KB (antes 1KB) y
EEPROM de 1 KB (antes 512 bytes).
La carga de los programas tambin es ms rpida ya que el bootloader fu
actualizado a una velocidad de 115000 baudios.
La Arduino Uno posee:
14 entrada/salida digitales, de los cuales 6 pueden ser usados como salidas PWM
Posee 6 entradas analgicas
Los pin 0 y 1 pueden funcionar como RX y TX serial.
Un oscilador de cristal de 32 MHz
Conector USB
Una entrada de alimentacin
Un conector ICSP
Botn de Reset
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 5
La Arduino UNO posee todo lo que se necesita para manejar el controlador,
simplemente se conecta a un ordenador por medio del cable USB o se puede alimentar
utilizando una batera o un adaptador AC-DC. Si se conecta por USB, la alimentacin
externa no es necesaria.
Para programar slo necesita el IDE de Arduino, que se encuentra en la seccin
de descargas en el sitio web de www.arduino.cc
Algunas caractersticas son:
Microcontroladora: ATmega328P-PU
Voltaje operativo: 5 V
Voltaje de entrada (recomendado): 7 12 V
Lmite voltaje de entrada: 20 V
Digital I/O Pins: 14 (6 de los cuales proporcionan salidas analgicas)
Pins de entradas analgicas: 6
Intensidad de corriente continua por I/O Pin: 40 mA
Intensidad de corriente continua por 3.3V Pin: 50 mA
Memoria: 32 KB
SRAM: 2 KB
EEPROM: 1 KB
Frecuencia del oscilador: 32 MHz
Las Entradas analgicas son de 10 bits, por lo que entregan valores entre 0 y 1023.
El rango de voltaje est dado entre 0 y 5 volts, pero utilizando el pin AREF disponible,
este rango se puede variar a algn otro deseado.
PROGRAMA
El programa que va a generar las seales acstico-luminosas es muy sencillo.
Para reproducir cada cdigo se ha usado la instruccin swicht que nos permite
distinguir entre cada letra o nmero. Adems se ha tenido en cuenta que nos pueda
permitir usar tanto las maysculas como las minsculas, para ello se ha aadido la
opcin case anidada que hace que se realice la misma funcin en los dos casos.
El programa, cada vez que se introduce una letra o nmero en el monitor del
programa de Arduino, ejecuta las subrutinas punto y raya segn el cdigo y las
muestra en la pantalla del monitor. El programa slamente ejecuta una letra o nmero
cada vez.
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 6
Para ello se ha usado la instruccin if(Serial.available()) que nos
introduce en el bucle siempre que recibamos un dato por la entrada de datos serie. Una
vez recibido este dato se asigna a la variable val con la instruccin
Serial.read() y se va realizando la comparacin con todos los cdigos mediante la
instruccin switch.
Para simplificar el programa se ha usado el concepto de subrutina. Esta opcin
nos permite realizar un trozo de programa repetidas veces, sin tener que escribirlo cada
vez. La forma de uso de una subrutina es la siguiente: antes de comenzar el programa
principal (loop), se realiza una declaracin de cada subrutina, en este caso punto y
raya. Para estas subrutinas no hay que pasarle ninguna informacin externa, por eso
va seguida de unos parntesis vacos ( ). Cada vez que se llama a una subrutina desde el
programa principal, el proceso sale de ste y contina su ejecucin en la subrutina
llamada. Una vez concluida } vuelve al programa principal en el punto donde lo
abandon.
/* unidad didctica morse */
int pito=9;
int val=0;
int draya=300;
int dpunto=150;
int espera=200;
/* SUBRUTINA PUNTO */
void punto(){
digitalWrite(pito,HIGH);
delay(250);
digitalWrite(pito,LOW);
Serial.println("Punto");
delay (espera);
}
/* SUBRUTINA RAYA */
void raya(){
digitalWrite(pito,HIGH);
delay(500);
digitalWrite(pito,LOW);
Serial.println("Raya");
delay (espera);
}
void setup (){
pinMode (pito, OUTPUT);
Serial.begin (19200);
}
void loop(){
if(Serial.available()){
val=Serial.read();
switch(val){
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 7
case 'A':
case 'a':
punto();
raya();
break;
case 'B':
case 'b':
raya();
punto();
punto();
punto();
break;
case 'C':
case 'c':
raya();
punto();
raya();
punto();
break;
case 'D':
case 'd':
raya();
punto();
punto();
break;
case 'E':
case 'e':
punto();
break;
case 'F':
case 'f':
punto();
punto();
raya();
punto();
break;
case 'G':
case 'g':
raya();
raya();
punto();
break;
case 'H':
case 'h':
punto();
punto();
punto();
punto();
break;
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 8
case 'I':
case 'i':
punto();
punto();
break;
case 'J':
case 'j':
punto();
raya();
raya();
raya();
break;
case 'K':
case 'k':
raya();
punto();
raya();
break;
case 'L':
case 'l':
punto();
raya();
punto();
punto();
break;
case 'M':
case 'm':
raya();
raya();
break;
case 'N':
case 'n':
raya();
punto();
break;
case ':
case ':
raya();
raya();
punto();
raya();
raya();
break;
case 'O':
case 'o':
raya();
raya();
raya();
break;
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 9
case 'P':
case 'p':
punto();
raya();
raya();
punto();
break;
case 'Q':
case 'q':
raya();
raya();
punto();
raya();
break;
case 'R':
case 'r':
punto();
raya();
punto();
break;
case 'S':
case 's':
punto();
punto();
punto();
break;
case 'T':
case 't':
raya();
break;
case 'U':
case 'u':
punto();
punto();
raya();
break;
case 'V':
case 'v':
punto();
punto();
punto();
raya();
break;
case 'W':
case 'w':
punto();
raya();
raya();
break;
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 10
case 'X':
case 'x':
raya();
punto();
punto();
raya();
break;
case 'Y':
case 'y':
raya();
punto();
raya();
raya();
break;
case 'Z':
case 'z':
raya();
raya();
punto();
punto();
break;
case '1':
punto();
raya();
raya(k);
raya();
raya();
break;
case '2':
punto();
punto();
raya();
raya();
raya();
break;
case '3':
punto();
punto();
punto();
raya();
raya();
break;
case '4':
punto();
punto();
punto();
punto();
raya();
break;
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 11
case '5':
punto();
punto();
punto();
punto();
punto();
break;
case '6':
raya();
punto();
punto();
punto();
punto();
break;
case '7':
raya();
raya();
punto();
punto();
punto();
break;
case '8':
raya();
raya();
raya();
punto();
punto();
break;
case '9':
raya();
raya();
raya();
raya();
punto();
break;
case '0':
raya();
raya();
raya();
raya();
raya();
break;
}
}
}
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 12
FOTOS DEL MONTAJE
De la salida digital nmero 9 se lleva un cable para conectar el diodo LED con
su resistencia limitadora y en paralelo va el zumbador. Asimismo, se lleva de la placa
Arduino la toma del negativo de la patilla GND correspondiente
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 13
COMPETENCIAS BSICAS TRABAJADAS EN ESTA UNIDAD
1.- Competencia en comunicacin lingstica.
El cdigo Morse es en si un lenguaje y requiere un tratamiento similar a la hora
de aprenderlo como otro lenguaje, de hecho solo consiste en relacionar cada letra o
nmero con su correspondiente cdigo expresado en forma de rayas y o puntos. Se hace
obvio que para su aprendizaje es imprescindible la prctica del mismo para mandar y
recibir los mensajes con rapidez en este cdigo as como la correcta interpretacin de
los mismos.
4.- Competencia en el tratamiento de la informacin y competencia digital.
El uso de las tecnologas de la informacin y comunicacin como un elemento
esencial para informarse y comunicarse.
Por otra parte, hemos de trabajar con componentes electrnicos, bien sea
analgicos y o digitales. En esta unidad en concreto usamos componentes analgicos
(resistencia, LED, zumbador) y en la parte digital, la propia microcontroladora Arduino.
6.- Competencia cultural y artstica.
Aunque este tipo de comunicacin se hace an hoy da pero de forma puntual y
en mbitos muy concretos, desde comienzos del siglo XX, tuvo un uso muy
generalizado en comunicaciones terrestres, martimas y militares, por lo que hay que
valorarlo como una manifestacin del mundo social de una poca ya pasada.
7.- Competencia para aprender a aprender.-
Este cdigo necesita de la memorizacin de su tipologa (raya y punto), por lo
que se hace necesario usar unas tcnicas de organizacin, memorizacin e incluso
inventar y desarrollar reglas nemotcnicas para que cada alumno de forma individual
pueda recordar el cdigo asociado a cada letra o nmero. Se hace evidente que para su
uso de forma fluida es muy necesaria la prctica de forma continuada.
8.- Competencia de autonoma e iniciativa personal.
Hay que desarrollar la habilidad para relacionarse y trabajar en equipo, ya que si
se pretende utilizar este cdigo como medio de comunicacin, ha de haber al menos una
persona que acte como emisor del mensaje y otra como receptora e interpretadora del
mismo y viceversa.
UNIDAD DIDCTICA
GENERACIN ACSTICO LUMINOSA DEL
CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
Manuel Garca Carrera
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 2
NDICE:
INTRODUCCIN
CARACTERSTICAS DE LA MICROCONTROLADORA ARDUINO
UNO
PROGRAMA
FOTOS DEL MONTAJE
COMPETENCIAS BSICAS TRABAJADAS EN ESTA UNIDAD
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 3
INTRODUCCIN:
La presente unidad didctica est realizada como actividad de fase no presencial
del curso La microcontroladora Arduino en Secundaria, y consiste en la generacin de
una seal tanto acstica como luminosa del cdigo Morse, para lo cual aparte de la
controladora, usaremos un pequeo zumbador y un LED con su resistencia limitadora.
El cdigo Morse es un cdigo o sistema de comunicacin que permite la
comunicacin telegrfica a travs de la transmisin de impulsos elctricos de longitudes
diversas o por medios visuales, como luz, sonoros o mecnicos. Este cdigo consta de
una serie de puntos, rayas y espacios, que al ser combinados entre si pueden formar
palabras, nmeros y otros smbolos.
Este sistema de comunicacin fue creado en el ao 1830 por Samuel F.B. Morse,
un inventor, pintor y fsico proveniente de los Estados Unidos, quien pretenda
encontrar un medio de comunicacin telegrfica. La creacin de ste cdigo tiene su
origen en la creacin del seor Morse de un telgrafo, invento que le trajo bastante
dificultades, ya que, en un principio, el registro de este fabuloso invento le fue negado
tanto en Europa como en los Estados Unidos. Finalmente, logr conseguir el
financiamiento del gobierno americano, el que le permiti construir una lnea telegrfica
entre Baltimore y Washington. Un ao despus se realizaron las primeras transmisiones,
resultando stas bastante exitosas, lo que dio pie a la formacin de una enorme
compaa que cubrira a todos los Estados Unidos de lneas telegrficas.
Como se dijo anteriormente, las letras, nmeros y dems signos, se representan
en el cdigo Morse a travs de puntos y lneas que se transmiten como impulsos
elctricos que producen una seal de luz o de sonido de una duracin determinada:
CDIGO MORSE (Alfanumrico)
Letra Cdigo Letra/Nmero Cdigo
A . S . . .
B . . . T
C . . U . .
D . . V . . .
E . W .
F . . . X . .
G . Y .
H . . . . Z . .
I . .
J . 1 .
K . 2 . .
L . . . 3 . . .
M 4 . . . .
N . 5 . . . . .
. 6 . . . .
O 7 . . .
P . . 8 . .
Q . 9 .
R . . 0
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 4
El punto es considerado, en el cdigo Morse, como una unidad, que en tiempo
equivale, aproximadamente a 1/25 de segundo. La lnea, en tiempo, equivale a tres
puntos. Cada letra se separa por un silencio de tres puntos de duracin, mientras que
cada palabra se separa por cinco puntos.
CARACTERSTICAS DE LA MICROCONTROLADORA ARDUINO UNO
Arduino puede ser utilizado para desarrollar objetos autnomos e interactivos,
como prototipos o interactuar con software instalado en el ordenador. Dada su rpida
curva de aprendizaje y su precio econmico es ideal para educadores, diseadores y
cualquiera interesado en la electrnica y robtica.
El compilador necesario para programarlo est disponible de forma gratuita en
www.arduino.cc y est disponible para Mac OS X, Windows y Linux.
Arduino UNO es la versin mejorada de su predecesor Duemilanove. Incluye
funcin de autoreset, proteccin de sobrecargas, conector USB para programarlo,
totalmente montado con componentes miniatura SMD (salvo el microcontrolador, para
poder cambiarlo facilmente) y nuevo bootloader OptiBoot a 155kbps.
La placa se entrega completamente ensamblada y probada con un
microcontrolador AVR ATmega328 con un cristal de cuazo de 32 Mhz.
Se entrega con el nueo chip Atmega328 de AVR con 32 KB de memoria de
programa en lugar de 16 KB de la anterior versin, RAM de 2KB (antes 1KB) y
EEPROM de 1 KB (antes 512 bytes).
La carga de los programas tambin es ms rpida ya que el bootloader fu
actualizado a una velocidad de 115000 baudios.
La Arduino Uno posee:
14 entrada/salida digitales, de los cuales 6 pueden ser usados como salidas PWM
Posee 6 entradas analgicas
Los pin 0 y 1 pueden funcionar como RX y TX serial.
Un oscilador de cristal de 32 MHz
Conector USB
Una entrada de alimentacin
Un conector ICSP
Botn de Reset
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 5
La Arduino UNO posee todo lo que se necesita para manejar el controlador,
simplemente se conecta a un ordenador por medio del cable USB o se puede alimentar
utilizando una batera o un adaptador AC-DC. Si se conecta por USB, la alimentacin
externa no es necesaria.
Para programar slo necesita el IDE de Arduino, que se encuentra en la seccin
de descargas en el sitio web de www.arduino.cc
Algunas caractersticas son:
Microcontroladora: ATmega328P-PU
Voltaje operativo: 5 V
Voltaje de entrada (recomendado): 7 12 V
Lmite voltaje de entrada: 20 V
Digital I/O Pins: 14 (6 de los cuales proporcionan salidas analgicas)
Pins de entradas analgicas: 6
Intensidad de corriente continua por I/O Pin: 40 mA
Intensidad de corriente continua por 3.3V Pin: 50 mA
Memoria: 32 KB
SRAM: 2 KB
EEPROM: 1 KB
Frecuencia del oscilador: 32 MHz
Las Entradas analgicas son de 10 bits, por lo que entregan valores entre 0 y 1023.
El rango de voltaje est dado entre 0 y 5 volts, pero utilizando el pin AREF disponible,
este rango se puede variar a algn otro deseado.
PROGRAMA
El programa que va a generar las seales acstico-luminosas es muy sencillo.
Para reproducir cada cdigo se ha usado la instruccin swicht que nos permite
distinguir entre cada letra o nmero. Adems se ha tenido en cuenta que nos pueda
permitir usar tanto las maysculas como las minsculas, para ello se ha aadido la
opcin case anidada que hace que se realice la misma funcin en los dos casos.
El programa, cada vez que se introduce una letra o nmero en el monitor del
programa de Arduino, ejecuta las subrutinas punto y raya segn el cdigo y las
muestra en la pantalla del monitor. El programa slamente ejecuta una letra o nmero
cada vez.
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 6
Para ello se ha usado la instruccin if(Serial.available()) que nos
introduce en el bucle siempre que recibamos un dato por la entrada de datos serie. Una
vez recibido este dato se asigna a la variable val con la instruccin
Serial.read() y se va realizando la comparacin con todos los cdigos mediante la
instruccin switch.
Para simplificar el programa se ha usado el concepto de subrutina. Esta opcin
nos permite realizar un trozo de programa repetidas veces, sin tener que escribirlo cada
vez. La forma de uso de una subrutina es la siguiente: antes de comenzar el programa
principal (loop), se realiza una declaracin de cada subrutina, en este caso punto y
raya. Para estas subrutinas no hay que pasarle ninguna informacin externa, por eso
va seguida de unos parntesis vacos ( ). Cada vez que se llama a una subrutina desde el
programa principal, el proceso sale de ste y contina su ejecucin en la subrutina
llamada. Una vez concluida } vuelve al programa principal en el punto donde lo
abandon.
/* unidad didctica morse */
int pito=9;
int val=0;
int draya=300;
int dpunto=150;
int espera=200;
/* SUBRUTINA PUNTO */
void punto(){
digitalWrite(pito,HIGH);
delay(250);
digitalWrite(pito,LOW);
Serial.println("Punto");
delay (espera);
}
/* SUBRUTINA RAYA */
void raya(){
digitalWrite(pito,HIGH);
delay(500);
digitalWrite(pito,LOW);
Serial.println("Raya");
delay (espera);
}
void setup (){
pinMode (pito, OUTPUT);
Serial.begin (19200);
}
void loop(){
if(Serial.available()){
val=Serial.read();
switch(val){
case 'A':
case 'a':
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 7
punto();
raya();
break;
case 'B':
case 'b':
raya();
punto();
punto();
punto();
break;
case 'C':
case 'c':
raya();
punto();
raya();
punto();
break;
case 'D':
case 'd':
raya();
punto();
punto();
break;
case 'E':
case 'e':
punto();
break;
case 'F':
case 'f':
punto();
punto();
raya();
punto();
break;
case 'G':
case 'g':
raya();
raya();
punto();
break;
case 'H':
case 'h':
punto();
punto();
punto();
punto();
break;
case 'I':
case 'i':
punto();
punto();
break;
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 8
case 'J':
case 'j':
punto();
raya();
raya();
raya();
break;
case 'K':
case 'k':
raya();
punto();
raya();
break;
case 'L':
case 'l':
punto();
raya();
punto();
punto();
break;
case 'M':
case 'm':
raya();
raya();
break;
case 'N':
case 'n':
raya();
punto();
break;
case ':
case ':
raya();
raya();
punto();
raya();
raya();
break;
case 'O':
case 'o':
raya();
raya();
raya();
break;
case 'P':
case 'p':
punto();
raya();
raya();
punto();
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 9
break;
case 'Q':
case 'q':
raya();
raya();
punto();
raya();
break;
case 'R':
case 'r':
punto();
raya();
punto();
break;
case 'S':
case 's':
punto();
punto();
punto();
break;
case 'T':
case 't':
raya();
break;
case 'U':
case 'u':
punto();
punto();
raya();
break;
case 'V':
case 'v':
punto();
punto();
punto();
raya();
break;
case 'W':
case 'w':
punto();
raya();
raya();
break;
case 'X':
case 'x':
raya();
punto();
punto();
raya();
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 10
break;
case 'Y':
case 'y':
raya();
punto();
raya();
raya();
break;
case 'Z':
case 'z':
raya();
raya();
punto();
punto();
break;
case '1':
punto();
raya();
raya(k);
raya();
raya();
break;
case '2':
punto();
punto();
raya();
raya();
raya();
break;
case '3':
punto();
punto();
punto();
raya();
raya();
break;
case '4':
punto();
punto();
punto();
punto();
raya();
break;
case '5':
punto();
punto();
punto();
punto();
punto();
break;
case '6':
raya();
punto();
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 11
punto();
punto();
punto();
break;
case '7':
raya();
raya();
punto();
punto();
punto();
break;
case '8':
raya();
raya();
raya();
punto();
punto();
break;
case '9':
raya();
raya();
raya();
raya();
punto();
break;
case '0':
raya();
raya();
raya();
raya();
raya();
break;
}
}
}
FOTOS DEL MONTAJE
De la salida digital nmero 9 se lleva un cable para conectar el diodo LED con
su resistencia limitadora y en paralelo va el zumbador. Asimismo, se lleva de la placa
Arduino la toma del negativo de la patilla GND correspondiente
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 12
COMPETENCIAS BSICAS TRABAJADAS EN ESTA UNIDAD
1.- Competencia en comunicacin lingstica.
GENERACIN ACSTICO LUMINOSA DEL CDIGO MORSE USANDO LA
MICROCONTROLADORA ARDUINO
PG. 13
El cdigo Morse es en si un lenguaje y requiere un tratamiento similar a la hora
de aprenderlo como otro lenguaje, de hecho solo consiste en relacionar cada letra o
nmero con su correspondiente cdigo expresado en forma de rayas y o puntos. Se hace
obvio que para su aprendizaje es imprescindible la prctica del mismo para mandar y
recibir los mensajes con rapidez en este cdigo as como la correcta interpretacin de
los mismos.
4.- Competencia en el tratamiento de la informacin y competencia digital.
El uso de las tecnologas de la informacin y comunicacin como un elemento
esencial para informarse y comunicarse.
Por otra parte, hemos de trabajar con componentes electrnicos, bien sea
analgicos y o digitales. En esta unidad en concreto usamos componentes analgicos
(resistencia, LED, zumbador) y en la parte digital, la propia microcontroladora Arduino.
6.- Competencia cultural y artstica.
Aunque este tipo de comunicacin se hace an hoy da pero de forma puntual y
en mbitos muy concretos, desde comienzos del siglo XX, tuvo un uso muy
generalizado en comunicaciones terrestres, martimas y militares, por lo que hay que
valorarlo como una manifestacin del mundo social de una poca ya pasada.
7.- Competencia para aprender a aprender.-
Este cdigo necesita de la memorizacin de su tipologa (raya y punto), por lo
que se hace necesario usar unas tcnicas de organizacin, memorizacin e incluso
inventar y desarrollar reglas nemotcnicas para que cada alumno de forma individual
pueda recordar el cdigo asociado a cada letra o nmero. Se hace evidente que para su
uso de forma fluida es muy necesaria la prctica de forma continuada.
8.- Competencia de autonoma e iniciativa personal.
Hay que desarrollar la habilidad para relacionarse y trabajar en equipo, ya que si
se pretende utilizar este cdigo como medio de comunicacin, ha de haber al menos una
persona que acte como emisor del mensaje y otra como receptora e interpretadora del
mismo y viceversa.
ROBOT HEXAPODO
CONTROLADO CON ARDUINO UNO
RAMON SANCHEZ-FERRAGUT SERRANO
I.E.S. ASTA REGIA. Jerez
!"#$%$&$'%
El hexapodo consta de seis patas dispuestas paralelamente en una estructura o chasis, las cuales se
mueven dos a dos, gobernadas por un microcontrolador. Estos robots pueden ser mas o menos
complejos dependiendo de los grados de movilidad de sus patas y de los obstaculos que se quieran
sortear, teniendo asi que dotar al robot de sensores y crear una aplicacion soItware complejo. Hay
muchos modelos diIerentes, diIerenciandose sobre todo en el tipo de patas empleadas.
()*"+$,(-
- Conocer las partes de un Robot.
- Diseo y construccion de Robot hexapodo.
- Manejar el programa de arduino en sus Iunciones basicas.
- Programar el robot para que realice las tareas que se especiIiquen.
&./-( 12 3." ,1 !$/$4$!(
El robot hexapodo se proyecta para realizar en cursos de 4 de la ESO.
+"56(/12$71&$'%
Se disea para su realizacion en 4 semanas, 12 sesiones.
5"+(!(2(481
Se utilizara distintas metodologias. Por un lado, la transmisiva que se usara para explicar los
distintos conceptos que aparecen; por otro lado la de construccion, ya que deberan llevar a cabo el
montaje del robot, y por ultimo la metodologia de experimentacion, dado que tendran que realizar
ejercicios de programacion, descargandolos sobre el robot construido y explicar que realiza este en
cada caso, ademas, de llevar a cabo distintos desaIios.
/"&./-(-
1 Panel de plastico o madera
3 unidades de servomotores
1 Placa de Arduino UNO
1 Portapilas
9"//15$"%+1-
Segueta o sierra de calar
Limas, lijas.
Taladro.
Brocas.
&/$+"/$(- !" ",12.1&$'%
Se valorara la capacidad de conocer las partes de un Robot.
Se valorara la capacidad de construir el Robot utilizando los recursos y herramientas descritas.
Se valorara la capacidad de utilizar el programa para el manejo y control del Robot.
!"#$%&'!()#
Pasaremos las piezas del plano a la placa de plastico o panel de madera. Recortaremos las piezas y
las montaremos segun el dibujo (PLANO adjunto). Montaremos los servos en los huecos indicados
y le colocaremos las patas pegadas con pegamento rapido.
Una vez construido el esqueleto del Hexapodo, prepararemos la placa controladora realizando el
montaje de los servos y programandola.
Colocaremos el portapilas para dar corriente a los distintos elementos y que el hexapodo tenga
autonomia de movimiento.
Se realizaran las pruebas y ajustes necesarios para que el Robot Hexapodo realice las Iunciones que
hemos programado.
!"#$"%&%'()*
#include <Servo.h>
Servo myservo01; // crea un objeto tipo servo para controlar el servo
Servo myservo02; // crea un objeto tipo servo para controlar el servo
Servo myservo03; // crea un objeto tipo servo para controlar el servo
void setup()
{
myservo01.attach(3); // liga el servo conectado en el pin 3 al objeto servo
myservo02.attach(5); // liga el servo conectado en el pin 5 al objeto servo
myservo03.attach(6); // liga el servo conectado en el pin 6 al objeto servo
}
void loop()
{
myservo03.write(0); // dice al servo que se posicione en un lado
delay(15); // espera 15 ms para que el servo se posicione
myservo01.write(0); // dice al servo que se coloque a un giro avante
delay(15); //espera 15 ms para que el servo se posicione
myservo02.write(180); // dice al servo que se coloque a un giro atras
delay(15); // espera 15 ms para que el servo se posicione
myservo03.write(180); // dice al servo que se posicione al otro lado
delay(15); //espera 15 ms para que el servo se posicione
myservo01.write(180); // dice al servo que se posicione en un lado
delay(15); // espera 15 ms para que el servo se posicione
myservo02.write(0); // dice al servo que se coloque a un giro avante
delay(15); //espera 15 ms para que el servo se posicione
}
}
Enlace a video para ver su Iuncionamiento: http://youtu.be/r2GZPKhXlUY
IMAGENES DE DIFERENTES MODELOS
!"#$%$
'#$()*#)%
"#$%&'
()&*"*+% ,#&-..% /".01*
2345 .6789763 0:83;6<8 05==59>
!"#$%&'& )&*+'&,-.& /&' 01
"#$%& '()*+,+-./
0(1 2(3*/*"+ 1/4/'(3
!"#$%&%'()*)+)!",-.&%'*/%!-#%0
!
#$%#&'(
!" $%&'()'*+,-.+/-0& 1( ,+ *&-1+1" """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" 2
2" 3,(4(&'%5 1( 678(&1-.+9(: ;<9('-=%5> $%&'(&-1%5 ? $8-'(8-%5 1( (=+,*+/-0&" """"""""""""""""""""""""""""""""""""""""""" 2
@" A('%1%,%BC+ """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" D
E" F(5+88%,,% 1( ,+ G&-1+1 """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" D
E"! H+5( I&-/-+, """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" D
E"2 H+5( 1( F(5+88%,,% """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" J
D" 3=+,*+/-0& 1( ,+ G&-1+1 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" K
D"!I&5'8*4(&'% 1( (=+,*+/-0& """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" K
!
#$#%&'( )*+,-./. 0.12/.345. 6./ 78
9:2./( lernando Murlllo Palcn
;< 8.12*=2:43>?40>@1 5* 34 :1>545<
Ll lnsLlLuLo se encuenLra slLuado en una manzana [unLo a un coleglo y un parque, exlsLe
basLanLe Lrflco a su alrededor, y sobre Lodo en deLermlnados momenLos. no hay elemenLos para
regulacln del Lrflco, y es por ello que queremos dlsenar y consLrulr un semforo para esLe fln
para dar respuesLa a esLe problema y slLuarlo en el punLo ms adecuado que esLlmen oporLuno
Lenlendo en cuenLo Lodo Llpo de facLores.
!"#$%&'(& * +&",&-.-& /- $01'0#1(- 20 3'#1("#-.(0#%" 20 '# $0.43"&" +-&- 50671'/"$ * 8'#%"
1"# '#" +-&- +0-%"#0$.
Condlclones de dlseno:
- La maqueLa del semforo Lendr una base o soporLe con las medldas mxlmas de 20*20
cm y su alLura no ser superlor a 23 cm.
- La secuencla de funclonamlenLo y conLrol con el ordenador se har con la Lar[eLa Ardulno y
con su enLorno de programacln.
- ueber slmular las pauLas de funclonamlenLo de un semforo real.
- A excepcln de cables, LLus, reslsLenclas, eLc, los dems elemenLos necesarlos para
consLrulr la maqueLa se consLrulrn en el aula, valorndose el uso de maLerlales reclclados.
- Ll proyecLo-consLruccln se har por pare[as.
A>B*3: 4 de LSC
C3.D:* 5* 8.12*1>5.E: ConLrol por ordenador
#*+6./43>?40>@1: 12
Seslones lase
lnlclal
Seslones lase
uesarrollo
Seslones lase
SlnLesls y Lval.
1oLal Seslones
1 10 1 12
!< F3*+*12.E 5* 96/*15>?4G*( 'HG*2>B.EI 8.12*1>5.E J 8/>2*/>.E 5* *B43:40>@1<
!
Se preLende que esLa unldad aporLe a los ob[eLlvos de rea y eLapa aquellos aspecLos que se
vayan a Lraba[ar con el fln de cumpllr esos ob[eLlvos, como refle[a la Labla ad[unLa
8elacln de Cb[eLlvos de LLapa y rea
1ecnologlas
1 2 3 4 3 6 7 8
M
e
L
o
d
o
r
o
y
e
c
L
o
s
M
a
n
l
p
u
l
a
c
.
1
e
c
n
l
c
a
M
e
L
o
d
o
d
e
A
n
l
l
s
l
s
L
x
p
r
e
s
l
n
d
e
l
d
e
a
s
1
e
c
n
o
l
o
g
.
v
S
M
.
A
m
b
.
l
n
f
o
r
m
L
l
c
a
-
8
e
d
e
s
n
u
e
v
a
s
L
e
c
n
o
l
o
g
l
a
s
1
r
a
b
a
[
o
e
n
e
q
u
l
p
o
L
d
u
c
a
c
l
n
S
e
c
u
n
d
a
r
l
a
C
b
l
l
g
a
L
o
r
l
a
8
e
a
l
u
e
c
r
e
L
o
a 8espeLo a los dems # #
b 1raba[o en equlpo # #
c lgualdad de sexos #
d 8elaclones con oLros #
e 1ecnologlas lnformacln # # #
f MeLodo clenLlflco # # #
g lnlclaLlva auLodldacLa # # # # #
h Lengua casLellana # #
l Lengua exLran[era # # #
[ PlsLorla, arLe y culLura # #
k Salud, cons y M.Amb # # #
l Creacln arLlsLlca # #
m Conocer y apreclar #
A
n
d
a
l
u
c
l
a
And a Pabllldades domesL # # #
And b Cdlgos clenL y Lecn # # # #
And c uemocracla, cludadanla #
And d Medlo AmblenLe # # #
And e Lengua Andaluza #
And f CulLura Andaluza # #
!
#$%&'()*+
Conocer el funclonamlenLo y uLlllzar una Lar[eLa conLroladora.
Aprender a uLlllzar los dlagramas de flu[o al reallzar Lareas de programacln.
lnLroduclr el concepLo de conLroladora.
MosLrar cules son las prlnclpales conLroladoras dlsponlbles en el aula de 1ecnologla y en el
mblLo educaLlvo.
MosLrar las conexlones bslcas.
Conocer las lnLerfaces de alguna de las conLroladoras empleadas en el Laller de Lecnologla.
Conocer los fundamenLos bslcos del lengua[e para la conLroladora.
resenLar el dlagrama de bloques de un slsLema de conLrol por ordenador.
8evlsar el concepLo de senal analglca y de senal dlglLal.
MosLrar las acclones bslcas que pueden reallzarse con un conLrol de ordenador:
acclonamlenLo de lnLerrupLores y moLores, capLacln de senales de sensores.
resenLar un slsLema senclllo de conLrol por ordenador.
,*-'&-(.*+
,*-/&0'*+
ConLrol por ordenador.
ConLroladoras e lnLerfaces de conLrol.
ulsposlLlvos de enLrada-sallda de conLrol.
1lpos de conLroladoras.
Codlflcacln de programas.
lnLerfaces de conLrol y programacln.
ulagramas de flu[o.
12*/&.(3(&-'*+4 .&+'2&56+ 7 86$(9(.6.&+
uLlllzar la Lar[eLa conLroladora.
lnLerpreLar y elaborar de dlagramas de flu[o.
ulsenar programas para conLrolar las enLradas y salldas dlglLales de una conLroladora.
uLlllzar una conLroladora para regular el funclonamlenLo de clrculLos elecLrlcos con la ayuda
de un ordenador.
Llaborar programas senclllos en el lengua[e de programacln de la conLroladora y uLlllzarlos
a conLlnuacln para el conLrol de slsLemas.
:/'(';.&+
CusLo por el orden y la llmpleza en la elaboracln de dlbu[os y esquemas.
valorar poslLlvamenLe el lmpacLo que puede suponer en la vlda coLldlana, en parLlcular en el
hogar, la adopcln de auLomaLlsmos y el conLrol remoLo por ordenador.
!
Apreclar el Lraba[o comple[o y planlflcado que exlge el monLa[e de slsLemas de conLrol.
lnLeres por abordar problemas que, a prlorl, pueden parecer dlflclles de soluclonar.
lnLeres por abordar Lraba[os en grupo.
Con esLa unldad queremos que nuesLros alumnos/as Lraba[en los slgulenLes campos que les
permlLan llegar a ser capaces de:
1.- 8esolucln de problemas, buscando soluclones y sln mledo a equlvocarse, con
lnlclaLlva, valorando poslLlvamenLe LanLo los aclerLos y los errores, y aprendlendo de ellos
CompeLencla en auLonomla e lnlclaLlva personal.
2.- Aprendan a Lraba[ar en grupo y valoren la lmporLancla que cada uno de los
componenLes del mlsmo Llene a nlvel lndlvldual como grupal. CompeLencla soclal y
cludadana
3.- Aprendan a conLrolar un proyecLo con el ordenador, comprendlendo las varlables
que le afecLan y puedan darle dlferenLes formas de funclonamlenLo. CompeLencla dlglLal y
LraLamlenLo de la lnformacln.
4.- Aprendan el lengua[e de programacln para la Lar[eLa conLroladora, y que sepan
lnLerpreLar lo que con el se escrlbe. CompeLencla en comunlcacln llngulsLlca.
Los crlLerlos de evaluacln que se emplearn para esLa unldad sern los slgulenLes:
#$ ulsLlngulr los prlnclpales elemenLos de enLrada y sallda de un slsLema de conLrol.
%$ uescrlblr las caracLerlsLlcas de una conLroladora, presLando especlal aLencln a sus salldas y
enLradas, LanLo analglcas como dlglLales.
&$ uLlllzar la conLroladora para examlnar el funclonamlenLo de un slsLema a Lraves del
ordenador.
'$ Llaborar procedlmlenLos senclllos de conLrol medlanLe lengua[e de programacln.
!$ Llaborar dlagramas de flu[o.
($ Llaborar programas que conLrolen las enLradas y salldas de una conLroladora.
)$ Mane[ar senclllos clrculLos elecLrnlcos a parLlr de un ordenador y una conLroladora.
&$ *+,-.-/-012
La meLodologla va a ser compleLamenLe prcLlca, faclllLando y fomenLando la auLonomla
personal, lndlvldual y grupal de las pare[as. 1endrn que manlpular, mane[ar, probar y
experlmenLar por ensayo/error las soluclones a las que se vaya llegando, y asl, valora las mlsmas y
deLermlnar cul es la ms aproplada para la resolucln del problema.
'$ 3+4255-//- .+ /2 678.2.
'$# 924+ :78;82/
!
Ln esLa fase se planLear la problemLlca en los alrededores del CenLro y las poslbles
soluclones que les podrlamos dar. 1odo ello Lraba[ando con el grupo, medlanLe charla-debaLe-lluvla
de ldeas, en la que cada uno aporLarla su oplnln. lanLeada y eleglda la solucln del semforo,
ahora exponemos oLro problema que puede surglr: los Llempos para el paso de vehlculos y
peaLones.
#$% &'() *) +)(',,-..-
LsLa es la programacln que se lnLenLar que lleguen y me[ore el alumnado.
# deflne verdevehlculo 13
# deflne amarlllovehlculo 12
# deflne ro[ovehlculo 11
# deflne ro[opeaLon 10
# deflne verdepeaLon 9
# deflne Llempoespera 3000
vold seLup()
[
plnMode(verdevehlculo, Cu1u1),
plnMode(amarlllovehlculo, Cu1u1),
plnMode(ro[ovehlculo, Cu1u1),
plnMode(ro[opeaLon, Cu1u1),
plnMode(verdepeaLon,Cu1u1),
}
vold loop()
[
dlglLalWrlLe(verdevehlculo,PlCP), //verde coches encendldo
dlglLalWrlLe(ro[opeaLon,PlCP), //ro[o peaLon encendldo
delay(Llempoespera), // verde coches Llempo espera
dlglLalWrlLe(verdevehlculo,LCW), // verde coches apagado
dlglLalWrlLe(amarlllovehlculo,PlCP), //amarlllo coches encendldo
delay(Llempoespera), //amarlllo coches Llempo espera
dlglLalWrlLe(amarlllovehlculo,LCW), // amarlllo coches apagado
dlglLalWrlLe(ro[opeaLon,LCW), //ro[o peaLon apagado
dlglLalWrlLe(ro[ovehlculo,PlCP), // ro[o coches encendldo
dlglLalWrlLe(verdepeaLon,PlCP),//verde peaLos encendldo
delay(Llempoespera), // ro[o coches Llempo espera..
dlglLalWrlLe(verdepeaLon,LCW),// verde peaLon apagado
delay(1000), // Llempo espera lnLermlLencla verde peaLon
dlglLalWrlLe(verdepeaLon,PlCP),// verde peaLon encendldo lnLermlLenLe
delay(1000), // Llempo espera lnLermlLencla verde peaLon
!
dlglLalWrlLe(verdepeaLon,LCW), // verde peaLon apagagado lnLermlLenLe
delay(1000), // Llempo espera lnLermlLencla verde peaLon
dlglLalWrlLe(verdepeaLon,PlCP),
delay(1000), // Llempo espera lnLermlLencla verde peaLon
dlglLalWrlLe(verdepeaLon,LCW), //apagar verde peaLones
delay(300), // Llempo espera fln lnLermlLencla verde peaLon
dlglLalWrlLe(ro[ovehlculo,LCW), // ro[o coches apagado
dlglLalWrlLe(ro[opeaLon,PlCP), // ro[o peaLon encendldo
dlglLalWrlLe(ro[ovehlculo,PlCP), // ro[o coches encendldo-[unLo al ro[o peaLon-segurldad
delay(800), // Llempo espera encendldo ro[os coches y ro[o peaLon
dlglLalWrlLe(ro[opeaLon,LCW), // ro[o peaLon apagado
dlglLalWrlLe(ro[ovehlculo,LCW), // ro[o coches apagado
//flnal_loop(),
}
vold flnal_loop()
[
whlle (Lrue == Lrue) [
}
}
nuesLra Lar[eLa debe de responder de la slgulenLe manera:
!
#$ %&'()'*+,- ./ (' 0-+.'.
Se evaluar usando los slgulenLes lnsLrumenLos de evaluacln:
AC1lvluAuLS. lnulvluuALLS ? uL C8uC (en clase y en casa).
- Cuaderno de clase.
- 8esolucln de e[erclclos y problemas.
- 1raba[o de consLruccln y dlseno.
8C?LC1CS (concepLos, procedlmlenLos y acLlLudes)
- Acabado.
- 8elacln enLre lo dlsenado y lo consLruldo.
!
- Cuaderno de proyecLos.
- Lxposlcln del proyecLo acabado. uso de vocabularlo Lecnlco.
AC1l1uu.
- arLlclpacln e lnLeres.
- ulsclpllna.
- Culdado y respeLo del maLerlal, herramlenLas, moblllarlo, eLc., asl como a sus companeros.
- Segurldad y orden en el puesLo de Lraba[o.
- AprovechamlenLo del maLerlal.
ASlS1LnClA ? un1uALluAu.
Ln Lodos los casos se valorar el orden, la llmpleza, los conLenldos, la presenLacln, la expresln
escrlLa y oral.
REALIZAR UN MEDIDOR DE LUZ CON DOS DISPLAYS 7 SEGMENTOS
OBJETIVOS
Realizar un medidor de luz con dos displays 7 segmentos (medida en porcentaje de 0 a 99%)
COMPETENCIAS
Especificas.
- Conocer el uso y funcionamiento del display de 7 segmentos
- Conocer el uso y funcionamiento de Arduino como multiplexor.
- Utilizar Arduino para desplegar nmeros decimales en el display de 7 segmentos.
Generales.
! Manejar las herramientas apropiadas.
! Utilizar de forma coherente y correcta las unidades adecuadas para cada magnitud.
! Presentar los resultados de los clculos con la precisin requerida.
! Utilizar herramientas informticas de simulacin.
! Montar circuitos y realizar medidas en ellos para comprobar clculos previos.
! Realizar informes sobre las prcticas realizadas que incluyan una adecuada
explicacin terica, los clculos y simulaciones realizadas, los resultados medidos
y los errores encontrados.
METODOLOGA
Se combinarn diferentes mtodos didcticos con el fin de presentar los contenidos bajo
distintas perspectivas que favorezcan la motivacin del alumnado:
MTODO EXPOSITIVO
Informativa
Esquema general de los contenidos a tratar.
Exposicin explicativa de conceptos utilizando diferentes recursos de exposicin:
pizarra, proyector (presentaciones), directamente sobre el/los Toma de apuntes e
informacin complementaria (esquemas, diagramas,.)
MTODO PRCTICO.
Adquisicin de destrezas mediante la realizacin de trabajos prcticos.
TEMPORALIZACIN.
Dos sesiones de 2 horas (1 hora de exposicin y 3 de desarrollo de la prctica).
MATERIAL:
2 Displays 7 segmentos de ctodo comn
1 LDR
Resistencia de 1 k
Placa arduino
Cable.
FUNDAMENTO TERICO
Una LDR (Light Dependent Resistors) es una resistencia que disminuye el valor
hmico al aumentar la luz que incide sobre ella. Se emplean como sensores de luz,
barreras fotoelctricas, etc.
MONTAJE
PROGRAMA
int pin_ldr = 3; // Patilla de arduino para la Medida del sensor
int lectura = 0; // Variable donde almacenamos la medida
int val = 0; // Variable donde almacenamos el mapeo
int unidad = 0; //variable donde se almacenar el dgito unidad de la medida mapeada
int decena = 0; // variable donde se almacenar el dgito decena de la magnitud medida
void loop()
{
lectura = analogRead(pin_ldr);// Tomamos la medida
//Serial.println(lectura);
//delay(1000);
val = map(lectura, 0, 1023, 0, 99); //Mapeamos entre esos valores
//Serial.println(val);
descompon(val); //Ejecutamos esta funcin para descomponer el valor en dos dgitos
//Serial.println(unidad);
//Serial.println(decena);
//delay(1000);
switch (unidad) {
case 0:
D1_num_0();
break;
case 1:
D1_num_1();
break;
case 2:
D1_num_2();
break;
case 3:
D1_num_3();
break;
case 4:
D1_num_4();
break;
case 5:
D1_num_5();
break;
case 6:
D1_num_6();
break;
case 7:
D1_num_7();
break;
case 8:
D1_num_8();
break;
case 9:
D1_num_9();
break;
//default:
}
switch (decena) {
case 0:
D2_num_0();
break;
case 1:
D2_num_1();
break;
case 2:
D2_num_2();
break;
case 3:
D2_num_3();
break;
case 4:
D2_num_4();
break;
case 5:
D2_num_5();
break;
case 6:
D2_num_6();
break;
case 7:
D2_num_7();
break;
case 8:
D2_num_8();
break;
case 9:
D2_num_9();
break;
//default:
}
}
void descompon (int valor)
{
if(10 - val > 0)
{
unidad = val;
decena = 0;
}
else if(20 - val > 0)
{
unidad = val - 10;
decena = 1;
}
else if(30 - val > 0)
{
unidad = val - 20;
decena = 2;
}
else if(40 - val > 0)
{
unidad = val - 30;
decena = 3;
}
else if(50 - val > 0)
{
unidad = val - 40;
decena = 4;
}
else if(60 - val > 0)
{
unidad = val - 50;
decena = 5;
}
else if(70 - val > 0)
{
unidad = val - 60;
decena = 6;
}
else if(80 - val > 0)
{
unidad = val - 70;
decena = 7;
}
else if(90 - val > 0)
{
unidad = val - 80;
decena = 8;
}
else
{
unidad = val - 90;
decena = 9;
}