Simulando ARDUINO UNO en ISIS

[agauss]

Hola gente del foro...

Pues estoy empezando con la tarjeta ARDUINO UNO y encontre los .DSN para simular el ARDUINO UNO y el MEGA, mi problema es que cuando simulo en PROTEUS  la velocidad se hace lenta como una cuatro veces. Pruebo con el ejemplo que trae ARDUINO el "BLINK" y el LED destella a una velocidad que no corresponde con la velocidad programada. Alguien sabe si hay algun truco o algo que este pasando por alto.

Saludos...

[AKENAFAB]

No hay truco

Proteus no simula en tiempo real.

Abajo trae un timer y es el registro que lleva el proteus.

[agauss]

Ok eso del tiempo real creo que utilice mal el termino, es cierto, PROTEUS no simula en tiempo real y efectivamente el clock debajo lleva los intervalos de tiempo, el problema es que, en este caso la simulacion se hace notablemente lenta, el trabajar solamente con el Atmega328P todo OK, pero al pasara el programa a la plantilla de "arduino" sale el mensaje "La simulacion no esta corriente en tiempo real debido a una sobrecarga en la CPU" o algo parecido. En fin despues de tratar insistentemente y sin exito me tope con otro simulador, al parecer al menos para simular los arduino es bueno y bastante novedoso. Con PROTEUS, esta vez le pondre una carita triste  , habrire un tema nuevo para compartir mi recien adquirida y poca experiencia en el Virtual BreadBoard. Gracias por la respuesta AKENAFAB, saludos a todos y feliz año...

[agauss]

Esto me pasa por desesperado e impaciente. Pues resulta que PROTEUS simula y bastante bien el codigo  compilado con arduino 0021. La carita triste ahora es para mi  . En fin aqui dejo mi primera grata experiencia con ISIS y ARDUINO. Una gran disculpa a todos los fans de PROTEUS  ... saludos!!!

isis_blink

Código: [Seleccionar]

[/********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador  Atmega328P *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : blink.c                                                 *
 * OBJETIVO: Generar un pulso de voltaje con una duracion  de  500us *
 *           en alto y 500us en bajo usando el bit 13  de la tarjeta *
 *           ARDUINO UNO.                                            *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


void setup()
{
   pinMode(13,OUTPUT);
}

void loop()
{
   digitalWrite(13,HIGH);
   delayMicroseconds(500);
   digitalWrite(13,LOW);
   delayMicroseconds(500);
}]



[agauss]

Ya encaminado el raton, aqui esta el contador binario de 0 - 15...

isis_count

Código: [Seleccionar]

[/********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador  Atmega328P *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : count.c                                                 *
 * OBJETIVO: Emular un contador binario de 4 bits con salida por los *
 *           pines 0 - 3 de la tarjeta  ARDUINO UNO. El  tiempo  por *
 *           cuenta es de 500ms.                                     *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


int dato[] = {0,1,2,3};

void setup()
{
   int i;
 
   for(i=0;i<4;i++)
      pinMode(dato[i],OUTPUT);
}

void loop()
{
   int i,j;

   for(i=0;i<16;i++)
   {
      for(j=0;j<4;j++)
      {
         if((i>>j)&1)
            digitalWrite(dato[j],HIGH);
         else
            digitalWrite(dato[j],LOW);
      }
     
      delay(500);
   }   
}]



[agauss]

Para terminar mi dia, les dejo el rotabit por los pines D0-D7. El video fue para ver el procedimiento (para quien le sirva) pero creo ahora solo dejare los archivos fuente. Hasta pronto!!!

isis_rotabit

Código: [Seleccionar]

[/********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : rotabit.c                                               *
 * OBJETIVO: Desplazador de un bit con salida por los pines 0 - 7 de *
 *           la tarjeta ARDUINO UNO. Considerar un tiempo aproximado *
 *           de 250 ms.                                              *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


int PortOut[] = {0,1,2,3,4,5,6,7};

void setup()
{
   int i;
 
   for(i=0;i<8;i++)
      pinMode(PortOut[i],OUTPUT);
}

void loop()
{     
   int i;
   
   for(i=0;i<8;i++)
   {
      digitalWrite(PortOut[i],HIGH);
      delay(250);
      digitalWrite(PortOut[i],LOW);
   }
}]



[agauss]

El programa para probar entradas y salidas inout.c con el arduino es este. Ojala que se animaran a publicar algunos ejemplillos simples y diferentes a estos.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *     ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : inout.c                                                 *
 * OBJETIVO: Reflejar el estado de las entradas 4 - 7 de  la  tajeta *
 *           ARDUINO UNO sobre los  pines 0 - 3. No  se  considerara *
 *           ninguna demora.                                         *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


int PortOut[] = {0,1,2,3};

void setup()
{
   int i;
 
   for(i=0;i<4;i++)
      pinMode(PortOut[i],OUTPUT);
}

void loop()
{     
   int i,dato;

   dato = 0;
   
   for(i=7;i>3;i--)
   {
      if((digitalRead(i))==1)
         dato = (dato<<1)|1;
      else
         dato = (dato<<1)|0;
   }
   
   for(i=0;i<4;i++)
   {
      if(((dato>>i)&1)==1)
         digitalWrite(PortOut[i],HIGH);
      else
         digitalWrite(PortOut[i],LOW);
   }
}
saludos...

[agauss]

Para convertir de binari a bcd les dejo este ejemplo basico. Todos estos emplillos han sido simulados con exito en PROTEUS 7.4 y Virtual BreadBoard, ademas de probados fisicamente.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : bin2bcd.c                                               *
 * OBJETIVO: Diseñar un contador de 0 - 59 con salida  por los pines *
 *           0 - 6 de la tarjeta ARDUINO UNO. La salida se  mostrara *
 *           en display de 7 segmentos. El tiempo por cuenta sera de *
 *           500 ms aprox.                                           *
 *                                                                   *
 * AUTOR   : agauss                              *
 *                                                                   *
 *********************************************************************/


int dato[] = {0,1,2,3,4,5,6};

void setup()
{
   int i;
 
   for(i=0;i<7;i++)
      pinMode(dato[i],OUTPUT);

   pinMode(7,OUTPUT);
   pinMode(8,OUTPUT);
}

void loop()
{     
   int i,j;
   int udato,cdato,xdato;
   
   for(cdato=0;cdato<6;cdato++)
   {
      for(udato=0;udato<10;udato++)
      {
         for(j=0;j<20;j++)
         {
            xdato = bin2bcd(cdato);

            for(i=0;i<7;i++)
            {
               if(((xdato>>i)&1)==1)
                  digitalWrite(dato[i],HIGH);
               else
                  digitalWrite(dato[i],LOW);
            }
         
            digitalWrite(7,HIGH);
            delay(10);
            digitalWrite(7,LOW);

            xdato = bin2bcd(udato);

         
            for(i=0;i<7;i++)
            {
               if(((xdato>>i)&1)==1)
                  digitalWrite(dato[i],HIGH);
               else
                  digitalWrite(dato[i],LOW);
            }
         
            digitalWrite(8,HIGH);
            delay(10);
            digitalWrite(8,LOW);
         }
      }
   }
}


int bin2bcd(int xdato)
{
   switch (xdato)
   {
      case 0:
      {
         xdato = 0x3F;
         break;
      }
      case 1:
      {
         xdato = 0x06;
         break;
      }
      case 2:
      {
         xdato = 0x5B;
         break;
      }
      case 3:
      {
         xdato = 0x4F;
         break;
      }
      case 4:
      {
         xdato = 0x66;
         break;
      }
      case 5:
      {
         xdato = 0x6D;
         break;
      }
      case 6:
      {
         xdato = 0x7D;
         break;
      }
      case 7:
      {
         xdato = 0x07;
         break;
      }
      case 8:
      {
         xdato = 0x7F;
         break;
      }
      case 9:
      {
         xdato = 0x6F;
         break;
      }
      default:
         break;
   }

   return(xdato);
}
saludos...

[agauss]

Retomando los ejemplillos con ARDUINO, ahora traigo el ADC de 10 bits con salida por los pines del 0 - 9, empiezo a usar tambien las funciones, en este caso outport(). Dejo la imagen del circuito armado en proteus y el archivo .DSN para quien lo quiera simular. Uso el proteus 7.4

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : adcard.c                                                *
 * OBJETIVO: Configurar el ADC de ARDUINO UNO a una resolucion de 10 *
 *           bits. Leer el canal A0 y mostrar el resultado sobre las *
 *           salidas digitales desde 0 (LSB) hasta 9 (MSB).          *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


int dport[] = {0,1,2,3,4,5,6,7,8,9};

void outport(int param)
{
   int i;
   
   for(i=0;i<10;i++)
   {
      if((param>>i)&1)
         digitalWrite(dport[i],HIGH);
      else
         digitalWrite(dport[i],LOW);
   }
}

void setup()
{
   int i;

   for(i=0;i<10;i++)
      pinMode(dport[i],OUTPUT);
}

void loop()
{
   int adato;

   adato = analogRead(0);
   outport(adato);
}

[agauss]

Les muestro el uso de la comunicacion serie con al USART de ARDUINO y un programita en Visual Basic 6.0, use el virtual serial port asignando los puertos COM2 a PROTEUS y COM3 a VB6.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : usartard.c                                              *
 * OBJETIVO: Leer el estado de los pines 0-7 de ARDUINO UNO, guardar *
 *           en una variable y enviar por la USART hacia  el  puerto *
 *           serie de la PC a una velocidad de 9600 baudios.         *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


void comport(int xdato)
{
   int j,dato[3];
   
   dato[0] = xdato/100;
   dato[1] = (xdato%100)/10;
   dato[2] = (xdato%100)%10;
       
   for(j=0;j<3;j++)
      Serial.print(dato[j]);
}

void setup()
{
   Serial.begin(9600);
}

void loop()
{     
   int i;
   
   for(i=0;i<256;i++)
   {
      comport(i);   
      delay(100);
   }
}

[agauss]

Como saben el PWM de arduino ya esta pre-configurado a 500Hz y aqui les pongo un programa sencillito que lee un dato de 8 bits de los pines 0 - 7, es decir un dato de 0 - 255 para variar el ciclo de trabajo de este modulo.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : pwmard.c                                                *
 * OBJETIVO: Generar una señal modulada en ancho de  pulso (PWM) con *
 *           salida por el bit 9 de ARDUINO UNO. El ciclo de trabajo *
 *           sera controlador por la  variable dato, la cual depende *
 *           del estado de las entradas 0 - 7.      *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/


int inport(int numbit)
{
   int i,dato;
   
   dato = 0;
   
   for(i=numbit-1;i>=0;i--)
   {
      if(digitalRead(i))
         dato = (dato<<1)|1;
      else
         dato = (dato<<1)|0;
   }
   
   return(dato);
}

void setup()
{
   pinMode(9,OUTPUT);
}

void loop()
{
   int dato;
   
   dato = inport(8);
   analogWrite(9,dato);
}

[agauss]

Uso simple de la interrupcion 0 de la tarjeta ARDUINO UNO. Se trata de un contador ascendente controlado por el flanco positivo sobre el pin 2 (ARDUINO) y una señal cuadrada con salida por el bit 8. La señal tiene una frecuencia de 1Khz y un ciclo de trabajo del 50%.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : intard.c                                                *
 * OBJETIVO: Generar una señal cuadrada con una frecuencia de 1Khz y *
 *           con salida por el bit  8  de ARDUINO UNO. Emular ademas *
 *           un contador de 4 bits con salida por los pines 4-7.     *
 *      *
 *           El contador sera activado por el flanco de bajada de la *
 *           interrupcion 0 y esto hara el incremento de la cuenta.  *
 *                                                                   *
 * AUTOR   : agauss                             *
 *                                                                   *
 *********************************************************************/

int port[] = {4,5,6,7};
volatile int count = 0;

void outport(int param)
{
   int i;
   
   for(i=0;i<=3;i++)
   {
      if((param>>i)&1)
         digitalWrite(port[i],HIGH);
      else
         digitalWrite(port[i],LOW);
   }
}

void setup()
{
   int i;

   for(i=0;i<=3;i++)
      pinMode(port[i],OUTPUT);
   
   pinMode(8,OUTPUT);

   attachInterrupt(0,rsi_count,FALLING);
}

void loop()
{
   digitalWrite(8,HIGH);
   delayMicroseconds(500);
   digitalWrite(8,LOW);
   delayMicroseconds(500);
}

void rsi_count()
{
   count++;
 
   if(count>15)
      count = 0;
     
   outport(count);
}

[agauss]

No podia faltar algo con la LCD. En este ejemplo se muestra el mensaje "Curso de ARDUINO" en la primera linea y en la segunda linea se muestra un contador de 0 - 15.

Código: [Seleccionar]

/*********************************************************************
 *                                                                   *
 * Compilador para la tarjeta basada en microcontrolador Atmega328P  *
 *      ARDUINO UNO      *
 *                                                                   *
 * NOMBRE  : lcdard.c                                                *
 * OBJETIVO: Desplegar un mensaje en la LCD LM016L haciendo  uso  de *
 *           la libreria LiquidCrystal. Esta configurar  la LCD para *
 *           operar con un BUS de 4 bits.                            *
 *                                                                   *
 * AUTOR   : agauss                              *
 *                                                                   *
 *********************************************************************/


#include <LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2);

void setup()
{

   lcd.begin(16,2);
}

void loop()
{
   int i;
   
   lcd.setCursor(0,0);
   lcd.print("Curso de ARDUINO");
   
   for(i=0;i<=15;i++)
   {
      lcd.setCursor(0,1);
      lcd.print("count = ");
      lcd.print(i);
     
      delay(250);
   }
   
   lcd.clear();
}

[stk500]

muy interesante Agauss
 y muchas gracias por tu aportacion
Saludos

[Torpedo1285]

Hola Agauss

¿puedes decirme donde descargar el DSN para el Arduino UNO, llevo varios dias buscandolo por internet y no lo he encontrado. Gracias

Saludos...