Académique Documents
Professionnel Documents
Culture Documents
El mejor programa que he visto para simular la placa Arduino UNO, es Proteus. Por una parte se
necesita el programa con la plantilla de Arduino, y por otra se necesita el programa que queremos
simular con la extensión HEX.
Proteus y Arduino
Una vez instalado el programa proteus, descargaremos el fichero correspondiente a la placa de
Arduino que queramos simular.
Si abrimos el esquema correspondiente al UNO con el Proteus , (versión 7.7 o superior) nos
encontraremos con la siguiente vista:
En ella se puede ver el modelo UNO de Arduino con los elementos que componen dicha placa, como
el LED de indicación de encendido, el led 'L' conectado a la patilla digital 13, las patillas nombradas,
etc.
Para poder simular el código, deberemos decirle al chip qué código y dónde se encuentra y para ello
deberemos acceder al microcontrolador del Arduino. Esto lo conseguiremos haciendo clic encima del
Arduino, con la combinación de teclas 'CTRL+C' accederemos al circuito que forma el Arduino en sí y
haciendo doble clic sobre el microcontrolador se nos abrirá la ventana de configuración del
ATmega328.
El microcontrolador ya sabe que tiene que ejecutar, por lo que salimos de la ventana aceptando los
cambios, pulsamos 'CTRL+X' para volver al circuito del Arduino y hacemos clic sobre el boton de play
para iniciar la ejecución del código, pudiendo ver su resultado si todo ha ido bien.
Una vez que hayamos indicado la ruta al archivo .hex, no hace falta que se la volvamos a indicar,
directamente modificamos el código, le damos a verificar y al darle al play en el Proteus,
automáticamente tomará la nueva versión del código. También se puede verificar el código mientras
la simulación está en curso sin ningún problema.
Si en vez de indicar la ruta al archivo .hex usamos el .elf podremos comprobar los errores del
programa, ejecutándose paso a paso. Para ello primero pulsamos el 'play' en Proteus, para luego
pulsar 'pausa', entonces saldrán las pantallas del código y de las variables. En mi opinión la pega que
le he encontrado a ejecutar paso a paso, es que el código sale en C puro y no en wiring por lo que
cuesta más la comprensión de este.
En las versiones del IDE anteriores al v1.0 para conocer la ruta en que el compilador guarda el '.hex'
y el '.elf' mantendremos pulsada la tecla 'Mayus' o 'Shift' mientras hacemos clic sobre el botón de
compilar, obteniendo en la pantalla de depuración la dirección de dicho archivo.
En la versión del IDE v1.0 para conocer la ruta, hay que ir a la pestaña 'File', 'Preferences' y marcar
la opción 'Show verbose output during: Compilación'. Se podría seleccionar Carga pero no tiene
demasiado sentido ya que si estamos simulando es porque no queremos tener la placa Arduino
conectada al PC, por lo que tener pulsada esta pestaña no da más que problemas.
Hay que tener en cuenta que la ruta del archivo puede pasar por carpetas ocultas y para mostrarlas
haremos la siguiente secuencia:
Podeis ver paso a paso la creación de un circuito en Proteus y la simulación con el archivo .hex
En éste ejemplo veremos dos ejemplo de como trabajar con un motor paso a paso unipolar.
Este tipo de motores los podemos encontrar en disqueteras antiguas, y son muy fáciles de
controlar. El que utilizamos en este ejercicio tiene seis conectores en los que dos (o uno
dependiendo del diseño del motor) es el voltaje de referencia (VCC) y otros cuantro se
utilizan para manejar el motor enviando señales sincronizadas.
El primer ejemplo muestra el código básico para hacer girar el motor en una dirección.
Pretende orientar a aquellos que nunca han manejado un motor paso a paso. El segundo
ejemplo muestra un código más complejo, que permite hacer girar el motor a distintas
velocidades y en ambas direcciones, controlando ambas cosas con un potenciómetro.
Código fuente
void setup() {
void loop() {
void setup() {
void moveForward() {
void moveBackward() {
void loop() {
val = analogRead(0);
if (val > 540) { // Cuanto mayor es el
valor del potenciómetro
delayTime = 2048 - 1024 * val / 512 + 1; // más rápido se
mueve hacia delante
moveForward();
} else if (val < 480) { // Cuanto menor es el
valor del potenciómetro
delayTime = 1024 * val / 512 + 1; // más rápido se
mueve hacia atrás
moveBackward();
} else {
delayTime = 1024; // Cuando el valor del
potenciometro se encuentra
} // en la zona media,
el motor se para.
Un driver de LED-s tiene incorporado un registro de desplazamiento que recibe los datos en
formato serie y los transfiere en paralelo. Es posible encadenar chips según el esquema daisy
chain, incrementando, cada vez en 8, el número de LED-s.
La forma en que todo esto funciona es a través de algo llamado “comunicación serial
sincrónica” que permite prender y apagar un pin de manera que se transmitan datos al registro
bit por bit. A través de un segundo pin llamado “Reloj” se indican los momentos
correspondientes a cada bit. Este sistema es lo contrario de la “comunicación serial
asincrónica” de la función Serial.begin(), que se basa en que el emisor y el receptor se
establecen de manera independiente sobre una tasa acordada de transmisión de datos. En
nuestro caso, cuando un byte completo se ha transmitido, los pulsos altos y bajos que
corresponden a cada bit se colocan en cada uno de los 8 pines de salida del 74HC595. Esta es
la función de salida paralela, en donde todos los pines hacen lo que tú indicaste al mismo
tiempo.
La función de salida serial del 74HC595 se puede realizar gracias a un pin adicional que
puede pasar la información recibida del Arduino de nuevo y sin cambios. Esto significa que
puedes transmitir 16 bits en fila (2 bytes), de manera que los primeros 8 pasarán de un primer
registro a un segundo y quedarán grabados allí. En el segundo ejemplo de este documento
aprenderás a hacerlo.
“3 estados” hace referencia a que puedes establecer la salida como “High”, “Low”, o “High
impedance”. A diferencia de los estados HIGH o LOW, no se puede colocar cada pin en alta
impedancia por separado, solamente se puede hacer con el chip completo. Esta es una labor
bastante especializada y ningún ejemplo de este cursillo usa esa propiedad y normalmente no
tendrás que preocuparte por obtener un chip que la tenga.
Esta es la representación del registro y una tabla que explica los pines adaptada de la hoja
técnica de Phillips.
1. Instalación
El primer paso es extender tu Arduino con un registro. Para hacer esto realiza las siguientes
conexiones:
Esta configuración hace que todos los pines de salida estén activos y sean accesibles todo el
tiempo. El único problema de esta configuración es que los pines retornan a su estado anterior
o a alguna cosa arbitraria desde que enciendes el circuito hasta que el programa comienza a
andar. Se puede solucionar controlando los pines MR y OE desde tu Arduino, pero así nada
más sirve y gastas menos pines.
2. Conéctalo al Arduino.
DS (pin 14) al pin digital 11 (cable azul)
SH_CP (pin 11) al pin digital 11 (cable amarillo)
ST_CP (pin 12) al pin digital 8 (cable verde)
3. Agrega 8 LEDs.
En este caso debes conectar el cátodo de cada LED a una tierra en común y el ánodo a su
respectivo pin de salida del registro. Usar el registro así, como origen del poder, se denomina
fuente de corriente. Algunos registros no pueden servir como fuente de poder, solamente
pueden asimilar corriente. Si tienes un registro así, deberás invertir la dirección de los LED,
colocando los ánodos directamente sobre el poder y los cátodos (tierras) en los pines de
salida. Vale la pena aclarar que en este último caso cuando el pin de salida se encuentre
activo el LED se apagará.
4. El código
En este ejemplo añadirás un Segundo registro, doblando así el número de pines de salida
mientras sigues usando el mismo número de pines en tu Arduino.
Dos de estas conexiones simplemente extienden las conexiones Reloj y Cierre del Arduino al
segundo registro (cables amarillo y verde). El cable azul debe ir desde el pin de salida serial
(pin 9) del primer registro a la entrada serial (pin 14) del segundo registro.
En este caso agregaremos LEDs verdes para que cuando leas el códido sea claro cuál Byte
están llegando a cada grupo de LEDs.
4. El código
Nuevamente tenemos 3 ejemplos de código. Si eres curioso, puedes probar los ejemplos del
primer ejercicio con este circuito para ver qué sucede. (En inglés aún).
Solamente hay una línea adicional de código con respecto al primer ejercicio, que envía un
segundo Byte. Esto fuerza al primer registro, el que está directamente conectado al arduino, a
pasar el primer dato enviado al segundo registro, prendiendo así los LEDs verdes, el segundo
Byte va a ser mostrado en los LEDs rojos.
En comparación al código del primer ejercicio, notarás que este ha cambiado un poco más.
La función parpadeo() ha sido cambiada por la función parpadeo_2Bytes() para reflejar el
hecho de que ahora hay 16 LEDs que controlar. Además en la versión 1 los pulsos del
pinCierre estaban situados dentro de la subfunción desplazarLuzA() y desplazarLuzB()
mientras que ahora se deben ubicar nuevamente en el Loop principal para poder correr cada
función dos veces en línea una para los LEDs verdes y otras para los rojos.
dato = pilaDatos[j];
se vuelve:
datoRojo = pilaDatosRojo[j];
datoVerde = pilaDatosVerde[j];
se vuelve:
El código del ejercicio que sigue a continuación toma el valor almacenado en la variable dato
y lo muestra como un número binario decodificado. Por ejemplo, si la variable dato es 1, sólo
se encendera el primer LED. Si la variable dato es 255, se encenderán todos los LED.
Código fuente
* -------------------
*
* Muestra un byte almacenado en la variable dato
* en una fila de 8 LED-s
*
* (copyleft) 2005 K3, Malmo University
* @author: David Cuartielles, Marcus Hannerstig
* @hardware: David Cuartielles, Marcos Yarza
* @project: made for SMEE - Experiential Vehicles
*/
int data = 9; // PIN-es digitales de la placa
conectados al chip
int strob = 8;
int clock = 10;
int oe = 11;
int count = 0; // Contador
int dato = 0; // Variable dato
void setup() {
void PulseClock(void) {
void loop() {