Como Simular Arduino En Proteus 1i323b

Como simular Arduino en Proteus 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:

El Arduino UNO con sus pines de conexión

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 ATmeg329 que compone el Arduino Uno

Una vez allí sólo nos queda cargar el código haciendo clic en el icono de la carpeta de 'Program File:' y buscar el archivo '.hex' generado por el Arduino durante la compilación.

Ventana de configuración del ATmega

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.

Obteniendo el .hex o .elf Por defecto, al verificar el código (compilar) el archivo .hex se guarda en una carpeta temporal, por lo que su no será sencillo. Tenemos dos posibilidades, se puede cambiar para siempre donde guardar el archivo .hex de Arduino o sino que Arduino nos diga en que carpeta se ha creado el archivo. Como la primera opción ya la tratamos en otro artículo aquí hablaremos sobre la segunda opción. 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.

En ambos casos obtendríamos la ruta del archivo en el propio IDE.

Hay que tener en cuenta que la ruta del archivo puede pasar por carpetas ocultas y para mostrarlas haremos la siguiente secuencia: 1. Inicio -> de control -> Opciones de carpeta 2. Abrimos la pestaña 'Ver' 3. Activamos 'Mostrar todos los archivos y carpetas ocultas' Podeis ver paso a paso la creación de un circuito en Proteus y la simulación con el archivo .hex

Si os ha gustado simular con Arduino podéis ver como se ve la simulación del control de un servomotor con un potenciometro. Esta documentación está actualizada para la placa Arduino UNO con las versiones superiores del IDE 1.0. El documento original está escrito por para versiones anteriores a la 023, por Chiva.

Motor paso a paso unipolar 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. En este enlace se muestra más información sobre el funcionamiento de motores paso a paso 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. En la placa protoboard se ha empleado un potenciómetro de 10K Ohmios que está conectado a una entrada analágica y a un driver ULN2003A. Este driver cuenta con un puñado de transistores en su interior. Estos permiten conectar componentes y dispositivos que necesitan mucha más corriente que la que puede ofrecer el Atmaga8 de la placa Arduino.

Detalle del conexionado del motor paso a paso

Detalle del conexionado del driver ULN2003A

Esquema válido para ambos ejemplos. Para el ejemplo 1 hay que eliminar el potenciómetro

Imagen de una placa protoboard con un potenciómetro y un driver ULN2003A conectados a una placa Arduino

Código fuente Ejemplo 1: Código básico para manejar un motor paso a paso /* Motor paso a paso de Copal * --------------------------* * Programa para manejar un motor paso a paso unipolar extraido de una * unidad de disquette de 5'25. De acuerdo a la documentación que * he encontrado, este: "[...] motor paso a paso fabricado por * Copal Electronics, con 1,8 grados por paso y 96 ohmios por cada * vuelta (de la bobina), con una etapa central conectada a diferentes * cables [...]" * [http://www.cs.uiowa.edu/~jones/step/example.html] * * Es un motor paso a paso unipolar con cinco cables: * * - rojo: conector de alimentación, lo tengo a 5V y funciona bien * - naranja y negro: bobina 1 * - marrón y amarillo: bobina 2 * * (cleft) 2005 DojoDave for K3 * http://www.0j0.org | http://arduino.berlios.de * * @author: David Cuartielles * @date: 20 Oct. 2005 */ int motorPin1 = 8; // PIN-es del Motor int motorPin2 = 9; int motorPin3 = 10;

int motorPin4 = 11; int delayTime = 500; velocidad de giro

// Delay que determina la

void setup() { pinMode(motorPin1, OUTPUT); PIN-es como salida digital pinMode(motorPin2, OUTPUT); pinMode(motorPin3, OUTPUT); pinMode(motorPin4, OUTPUT);

// Configuración de los

} void loop() { digitalWrite(motorPin1, secuencia digitalWrite(motorPin2, digitalWrite(motorPin3, digitalWrite(motorPin4, delay(delayTime); digitalWrite(motorPin1, digitalWrite(motorPin2, digitalWrite(motorPin3, digitalWrite(motorPin4, delay(delayTime); digitalWrite(motorPin1, digitalWrite(motorPin2, digitalWrite(motorPin3, digitalWrite(motorPin4, delay(delayTime); digitalWrite(motorPin1, digitalWrite(motorPin2, digitalWrite(motorPin3, digitalWrite(motorPin4, delay(delayTime);

HIGH);

// Los pines se activan en

LOW); LOW); LOW); LOW); HIGH); LOW); LOW); LOW); LOW); HIGH); LOW); LOW); LOW); LOW); HIGH);

} Ejemplo 2: Código avanzado para manejar un motor paso a paso /* Motor paso a paso unipolar avanzado * -----------------------------------* * Programa para manejar un motor paso a paso unipolar extraido de una * unidad de disquette de 5'25. De acuerdo a la documentación que * he encontrado, este: "[...] motor paso a paso fabricado por * Copal Electronics, con 1,8 grados por paso y 96 ohmios por cada * vuelta (de la bobina), con una etapa central conectada a diferentes * cables [...]" * [http://www.cs.uiowa.edu/~jones/step/example.html] * * Es un motor paso a paso unipolar con cinco cables: * * - rojo: conector de alimentación, lo tengo a 5V y funciona bien * - naranja y negro: bobina 1 * - marrón y amarillo: bobina 2

* * (cleft) 2005 DojoDave for K3 * http://www.0j0.org | http://arduino.berlios.de * * @author: David Cuartielles * @date: 20 Oct. 2005 */ int motorPins[] = {8, 9, 10, 11}; int count = 0; int count2 = 0; int delayTime = 500; la velocidad de giro int val = 0;

// // // //

PIN-es del motor Contador 1 Contador 2 Delay que determina

void setup() { for (count = 0; count < 4; count++) { los PIN-es como salida digital pinMode(motorPins[count], OUTPUT); }

// Configuración de

} void moveForward() { if ((count2 == 0) || (count2 == 1)) { // Mueve el motor hacia delante. Para hacerlo desplaza los count2 = 16; } // bits de la vable count2 entre los PIN-es del motor. count2>>=1; for (count = 3; count >= 0; count--) { // 16 = 00010000 --> 00001000 --> 00000100 --> 00000010 ... digitalWrite(motorPins[count], count2>>count&0x01); } delay(delayTime);

} void moveBackward() { if ((count2 == 0) || (count2 == 1)) { // Mueve el motor hacia delante. Para hacerlo desplaza los count2 = 16; // bits de la vable count2 entre los PIN-es del motor. } count2>>=1; for (count = 3; count >= 0; count--) { // 16 = 00010000 --> 00001000 --> 00000100 --> 00000010 ... digitalWrite(motorPins[3 - count], count2>>count&0x01); } delay(delayTime);

} void loop() {

val = analogRead(0); if (val > 540) { valor del potenciómetro delayTime = 2048 - 1024 * val / 512 + 1; mueve hacia delante moveForward(); } else if (val < 480) { valor del potenciómetro delayTime = 1024 * val / 512 + 1; mueve hacia atrás moveBackward(); } else { delayTime = 1024; potenciometro se encuentra } el motor se para.

// Cuanto mayor es el // más rápido se // Cuanto menor es el // más rápido se

// Cuando el valor del // en la zona media,

}

Manejando múltiples salidas con un driver de LED-s En este ejemplo pretendemos mostrar la forma de utilizar un número elevado de LED-s utilizando tan sólo 4 PIN-es. Para ello utilizaremos un driver 4794 de Phiplips. 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.

Múltiples salidas digitales con un 74HC595

Tarde o temprano te verás sin suficientes pines en tu placa de Arduino y necesitarás extenderlos con "shift s" (registros de desplazamiento ¿?). Este ejemplo se basa en el 74HC595, descrito por su documentación técnica como un registro con entrada serial, con salida serial o paralela y con interruptores de salida; 3 estados. (“8-bit serial-in, serial or parallel-out shift with output latches; 3-state.”) En otras palabras puedes usarlo para controlar 8 salidas al mismo tiempo pero usando unos pocos pines del Arduino. Y puedes enlazar varios registros para extender aún más tus salidas. 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.

PINS 1-7, 15

Q0 – Q7

Pines de salida

PIN 8

GND

Tierra, Vss

PIN 9

Q7’

Salida serial

PIN 10

MR

Reset Maestro. Activo en LOW

PIN 11

SH_

Shift clock pin

PIN 12

ST_

Storage clock pin (latch pin)

PIN 13

OE

Salida activada. Activo en LOW.

PIN 14

DS

Entrada de datos Serial

PIN 16

Vcc

Alimentación, voltaje positivo.

1er Ejemplo: Un registro.

1. Instalación El primer paso es extender tu Arduino con un registro. Para hacer esto realiza las siguientes conexiones:    

GNG (oin 8) a tierra. Vcc (pin 5) a 5V. OE (pin 13) a tierra. MR (pin 10) a 5V.

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_ (pin 11) al pin digital 11 (cable amarillo) ST_ (pin 12) al pin digital 8 (cable verde)

Desde ahora nos referiremos a ellos como el pinDatos, el pinReloj y el pinCierre, respectivamente. Observa el condensador de 0.1 µf en el pinCierre, si tienes algo de parpadeos cuando el pinCierre pulsa puedes usar este condensador para solucionarlo.

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 El código se basa en dos partes de la información de la hoja técnica: el diagrama de tiempos y la tabla lógica. La tabla lógica es la que te indica básicamente todo lo importante que pasa en un tiempo. Cuando el pinReloj pasa de LOW hacia HIGH el registro lee el estado del pinDatos. Cuando los datos son empujados hacia el registro, van siendo salvados en una

memoria interna. Cuando el pinCierre pasa de LOW a HIGH los datos enviados son traspasados de la memoria interna hacia los pines de salida, prendiendo los LEDs.

He aquí 3 ejemplos de código. El primero es solamente el código “Hola mundo” que enviará los bytes desde 0 a 255. El segundo programa prende los LEDs uno por uno. El tercero recorre una pila de datos. 1.1 Hola Mundo 1.1 Uno por uno 1.1 Desde una pila de datos (en inglés -aún-).

2do Ejemplo: Dos registros.

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. 1. Agrega otro registro. Comenzando desde el ejemplo anterior, debes añadir un segundo registro en la placa de prototipos. Debe tener las mismas conexiones de poder y tierra.

2. Conecta los 2 registros. 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.

3. Agrega otro grupo de LEDs. 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). 2.1 Doble contador binario. 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. 2.2 Uno por uno. 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. 2.3 Pilas de datos dobles Como en el ejemplo 2.2, el 2.3 también toma provecho de la nueva función parpadeo_2Bytes(). La gran diferencia con el 1.3 es que en vez de una sola variable llamada “dato” y una sola pila llamada “pilaDatos” tienes que definir datoRojo, datoVerde, pilaDatosRojo, pilaDatosVerde desde el principio. Esto significa que las lineas: dato = pilaDatos[j];

se vuelve: datoRojo = pilaDatosRojo[j]; datoVerde = pilaDatosVerde[j];

y enviarDato(pinDatos, pinReloj, dato);

se vuelve: enviarDato(pinDatos, pinReloj, datoRojo); enviarDato(pinDatos, pinReloj, datoVerde);

Detalle del conexionado de un driver Philips 4794

Esquema

Montaje de un driver Philips 4794 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 /* Driver Philips 4794 * ------------------* * 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() { beginSerial(9600); 9600 baudios

// El puerto serie trabajrá a

pinMode(data, OUTPUT); digitales pinMode(clock, OUTPUT); pinMode(strob, OUTPUT); pinMode(oe, OUTPUT);

// Configuración de los PIN-es

} void PulseClock(void) { digitalWrite(clock, LOW); pulso de reloj delayMicroseconds(20); digitalWrite(clock, HIGH); delayMicroseconds(50); digitalWrite(clock, LOW);

// Procedimiento que emite un

} void loop() { dato = 5; // 5 en binario es 00000101 for (count = 0; count < 8; count++) { digitalWrite(data, dato & 01); // Obtiene el bit de más a la derecha (00000101 AND 00000001 = 00000001) y lo escribe en la entrada serie del chip //serialWrite((dato & 01) + 48); dato>>=1; // Desplaza un bit a la derecha de la variable dato (00000101 --> 00001010) if (count == 7){ // Cuando ha enviado los 8 bits se lo indica al chip digitalWrite(oe, LOW); digitalWrite(strob, HIGH); } PulseClock(); // Envía un pulso de reloj digitalWrite(oe, HIGH); // Le indica al chip que le ha enviado un bit } delayMicroseconds(20); digitalWrite(strob, LOW); delay(100); serialWrite(10); serialWrite(13); delay(100);

}