PROYECTO ARDUINO

      EL COCHE QUE SE ESTACIONA SOLO                               APPARCAR

OBJETIVO:

Poder establecer una forma automatica para estacionar un vehiculo usando progrmacion y sensores

Dar a conocer un poco mas del arduino y ser demostrado en el proyecto a realizar con su configuración y su respectiva maqueta.

RESUMEN:

Este proyecto cuenta de un vehiculo autonomo capaz de poder estacionarse como un vehiculo real teniendo en cuenta que el vehiculo es capaz de estacionarse de manera segura sin tener ningun choque puesto que posee una variedad de sensores ultrasónicos.

Actualmente todos hemos visto anuncios de coches que aparcan solos, es un

sistema que está en auge, ya que solo unas marcas disponen de ello. Es una

tecnología que a la mayoría de la población le gustaría tener en su propio coche.

Claro está que no todos los coches están preparados para ello, no podemos

modificar nuestro coche hasta el punto de que aparque solo, lo que si podemos

tener es una ayuda al aparcar, como cuanta distancia tenemos detrás en

centímetros, o cuanta delante, incluso lateral o bien la usual cámara trasera, etc.

Este proyecto mezcla esto, ya que directamente no aparcaría su coche pero si

podría darle una asistencia.

Materiales:
- Arduino (hay muchas versiones, aquí uso el UNO)

- Sensor de ultrasonido HC-SR04 (hay parecidos como HY-SRF05)

- Modulo bluetooth HC-05

- Transformador encendedor de coche(12v) /Arduino (9v) o portapilas

- Cable usb tipo A a usb tipo B

- Cables tanto macho-macho como hembra-macho


- Placa Ariston

- Chasis del coche con motores y ruedas


- Puente doble H L298N

CONEXONES

VIDEOS

En este video se da a conocer como en la vida real se usa vehículos que se estacionan por su cuenta esto gracias a sensores que llevan equipados y se estacionan sin necesidad del chofer 

https://www.youtube.com/watch?v=1I9U22UV5C4


En este video se da a conocer un proyecto relacionando con el estacionamiento del vehiculo en progrmacion arduino

https://www.youtube.com/watch?v=FJTombQ2luI

               

              

CONFIGURACION DEL CODIGO PARA LA APP

video demostraticvo del programa

PROGRAMACIÓN DEL SENSOR ULTRASÓNICO

VIDEO DE EXPLICACIÓN DE LOS MOTORES

CÓDIGO DEL ARDUINO

#include <SoftwareSerial.h>
#include <Ultrasonic.h>




SoftwareSerial Diego(1, 0); // Tx, Rx

int motor1pwm = 9;
int motor2pwm = 5;
int motor1delante = 8;
int motor1detras = 7;
int motor2delante = 4;
int motor2detras = 6;
Ultrasonic ultrasonic1(11,12); // (Trig PIN,Echo PIN)
Ultrasonic ultrasonic2(10,13);  // (Trig PIN,Echo PIN)
int lectura[4];
int lectura2[11];
int media;
int media2;
int BluetoothData;
int i=0;
byte respuesta= 0;
int caso=0;
int diferencia;
float  duracion1=0;
float  duracion2=0;
float  duracionintervalo;
float  tiempo1=0;
float  tiempo2=0;
float  duracionultimointervalo;
int profundidadminima=1000;
int mediaminima;
const int led = A0;
i        nt opcionbateria=0;
int aparcar=0;
int aux=0;
int pasobateria=0;

void setup() {

  Diego.begin(9600);

  pinMode(motor1pwm, OUTPUT);
  pinMode(motor2pwm, OUTPUT);
  pinMode(motor1delante, OUTPUT);
  pinMode(motor1detras, OUTPUT);
  pinMode(motor2delante, OUTPUT);
  pinMode(motor2detras, OUTPUT);
  pinMode(led, OUTPUT);
  delay(1000);
}

void motor (int pwm1, int pwm2, int motor1A, int motor1B, int motor2A, int motor2B){

  analogWrite(motor1pwm, pwm1);
  analogWrite(motor2pwm, pwm2);
  digitalWrite(motor1delante, motor1A); 
  digitalWrite(motor1detras, motor1B); 
  digitalWrite(motor2detras, motor2A);
  digitalWrite(motor2delante, motor2B); 
   
}



void loop() {

if (Diego.available()){ // asi solo lee cuando debe
   BluetoothData=Diego.read();
   analogWrite(led, 0);
   motor(115, 115,0 ,0 ,0 ,0);
   opcionbateria=0;
   aparcar=0;
   aux=0;
   pasobateria=0;
   caso = 0;
}


 
switch(BluetoothData){
 
  case 'a' : //Aparcando automatico
    analogWrite(led, 200);
    if(aux ==0 || aux == 1){
      motor(110, 110,1 ,0 ,0 ,1); //<-----------
      duracion1 = millis();
      if(duracion1>= tiempo1 && caso == 0){ 
        tiempo1=duracion1;
        aux = 1;     
      }
     
      for(i=1; i<4; i++){     
        delay(10);
        lectura[i];
        Ultrasonic Ranging(CM);
        if(i==3)
        {
          media = (lectura[1]+lectura[2]+ lectura[3])/3;
        }
      }
   

   
    if(media>=25 && aux==1){ //distancia minima para aparcar
     
          caso=1;
          if(media<= profundidadminima){ 
          profundidadminima = media;
          }   
       duracion2 = millis();
          if(duracion2>= tiempo2){ 
          tiempo2=duracion2;     
     
        }
   
    }
       
    if(media<=12 && caso==1){     
        duracionintervalo = (tiempo2-tiempo1)/1000;   
         motor(110, 110,0 ,0 ,0 ,0);
     
   
           
         aux = 0;
     
   
      if(duracionintervalo>=1.05 && profundidadminima<=29){ // En linea
       aparcar = 1;     
        Diego.print(" En linea");
      }
       if(duracionintervalo>=0.52 && profundidadminima>=30){ // En  bateria
        aparcar = 2;     
        Diego.print(" En bateria");     
       }
       if((duracionintervalo<0.52) || (duracionintervalo<1.04 && profundidadminima<30) || (duracionintervalo>1.06 && profundidadminima<25) ){ //No entra y continua
       aparcar = 3 ;     
       Diego.print(" Continua");
       }       
      caso = 2;
      aux = 2; 
     delay (1000);
    }     
         
   
} 
if(aux==2){
    //Diego.println(caso);
    delay(10);
 
  if(aparcar == 2 && caso==2){     
    //En Bateria     
      // Diego.println(aparcar);   
       
    // RETROCEDE UN POCO
    if(pasobateria==0){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==0){         
             tiempo1=duracion1;
             opcionbateria=1;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==1){         
             tiempo2=duracion2;         
             motor(100, 100, 0, 1, 1, 0);//<-----------
         }
   
     
     
        if((tiempo2-tiempo1)/1000 >=0.75){
   
          motor(90, 90, 0, 0, 0, 0);       
          opcionbateria = 3;
        pasobateria=1;     
      } 
    }   
       delay(10);
 
    //GIRA
     if(pasobateria==1){ 
     
       duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==3){         
             tiempo1=duracion1;
             opcionbateria=4;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==4){         
             tiempo2=duracion2;         
             motor(85, 80, 0, 1, 0, 0);//<-----------
         }
 
       
     
        if((tiempo2-tiempo1)/1000 >=0.5){
     
          motor(110, 115, 0, 0, 0, 0);   
          opcionbateria = 5;
          pasobateria = 2; 
        }   
     
    }
      delay(10);
    // MARCHA ATRAS
    if(pasobateria==2){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==5){         
             tiempo1=duracion1;
             opcionbateria=6;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==6){         
             tiempo2=duracion2;       
             motor(100, 100, 0, 1, 1, 0);//<-----------
         }
 
     
        if((tiempo2-tiempo1)/1000 >=0.4){
   
          motor(145, 145, 0, 0, 0, 0);
          opcionbateria = 7;
          pasobateria=3;
          Diego.println("\n Aparcado");
     
      } 
    }   
       delay(100);
     
    }

  if(aparcar == 1 && caso==2){       
      //En linea 
       // RETROCEDE UN POCO
    if(pasobateria==0){

          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==0){                       
             tiempo1=duracion1;
             opcionbateria=1;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==1){         
             tiempo2=duracion2;         
             motor(115, 115, 0, 1, 1, 0);//<---------------------------------------------------------------------------------------
         }
 
     
        if((tiempo2-tiempo1)/1000 >=0.5){//<---------------------------------------------------------------------------------------
   
          motor(115, 90, 0, 0, 0, 0);       
          opcionbateria = 3;
        pasobateria=1;     
      } 
    }   
       delay(10);
 
    //GIRA a 45º
     if(pasobateria==1){ 
     
       duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==3){         
             tiempo1=duracion1;
             opcionbateria=4;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==4){         
             tiempo2=duracion2;         
             motor(115, 90, 0, 1, 0, 0);//<---------------------------------------------------------------------------------------
         }
 
       
     
        if((tiempo2-tiempo1)/1000 >=0.25){//<---------------------------------------------------------------------------------------
       
          motor(100, 100, 0, 0, 0, 0);   
          opcionbateria = 5;
          pasobateria = 2; 
        }   
     
    }
      delay(10);
   
    // MARCHA ATRAS
    if(pasobateria==2){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==5){         
             tiempo1=duracion1;
             opcionbateria=6;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==6){         
             tiempo2=duracion2;       
             motor(100, 100, 0, 1, 1, 0);//<---------------------------------------------------------------------------------------
         }
 
     
     
        if((tiempo2-tiempo1)/1000 >=0.8){//<---------------------------------------------------------------------------------------
   
          motor(90, 115, 0, 0, 0, 0);
          opcionbateria = 7;
          pasobateria=3;             
      }         
     }
     //GIRA DE NUEVO PARA ENDEREZAR
      if(pasobateria==3){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==7){         
             tiempo1=duracion1;
             opcionbateria=8;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==8){         
             tiempo2=duracion2;       
             motor(90, 115, 0, 0, 1, 0);//<---------------------------------------------------------------------------------------
         }
   
     
     
        if((tiempo2-tiempo1)/1000 >=0.3){//<---------------------------------------------------------------------------------------   
          motor(110, 110, 0, 0, 0, 0);
          opcionbateria = 9;
          pasobateria=4;
          Diego.println("\n Aparcado");       
      }   1|       
   
 

        //No entra
    if(aparcar==3 && caso==2){
   
         Diego.println(aparcar);   
         motor(150, 150,1 ,0 ,0 ,1);
         Diego.print("\n No es suficiente \n ");
         caso = 0;
         aux = 0;
     
        }
   
 
 }

 break;


case 'b': //Distancia trasera
      analogWrite(led, 200);
        motor(115, 115,0 ,0 ,0 ,0);
       for(i=1; i<11; i++){   
      delay(50);
      lectura2[i] =  int(CM);
       if(i==10){ 
        media2 = (lectura2[1]+lectura2[2]+ lectura2[3]+ lectura2[4]+ lectura2[5]+ lectura2[6]+ lectura2[7]+ lectura2[8]+ lectura2[9]+ lectura2[10])/10;
         }
       }     
               delay(50);
      Diego.println(" ");       
      Diego.println(media2);
      Diego.println("cm");

case 'f':// Aparcar manual en bateria
    delay(10);
     analogWrite(led, 200);
    //En Bateria           
       
    // RETROCEDE UN POCO
    if(pasobateria==0){
   
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==0){         
             tiempo1=duracion1;
             opcionbateria=1;
               Diego.println("Manual Bateria");         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==1){         
             tiempo2=duracion2;         
             motor(105, 105, 0, 1, 1, 0);//<------------------------------------------------------------------------
         }
   
     
     
        if((tiempo2-tiempo1)/1000 >=0.55){//<---------------------------------------------------------------------------------------
   
          motor(90, 90, 0, 0, 0, 0);       
          opcionbateria = 3;
        pasobateria=1;     
      } 
    }   
       delay(10);
 
    //GIRA
     if(pasobateria==1){ 
     
       duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==3){         
             tiempo1=duracion1;
             opcionbateria=4;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==4){         
             tiempo2=duracion2;         
             motor(90, 90, 0, 1, 0, 0);//<---------------------------------------------------------------------------------------
         }
 
       
     
        if((tiempo2-tiempo1)/1000 >=0.65){//<---------------------------------------------------------------------------------------
       
          motor(110, 110, 0, 0, 0, 0);   
          opcionbateria = 5;
          pasobateria = 2; 
        }   
     
    }
      delay(10);

    if(pasobateria==2){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==5){         
             tiempo1=duracion1;
             opcionbateria=6;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==6){         
             tiempo2=duracion2;       
             motor(110, 110, 0, 1, 1, 0);//<---------------------------------------------------------------------------------------
         }

     
     
        if((tiempo2-tiempo1)/1000 >=0.5){//<---------------------------------------------------------------------------------------
   
          motor(115, 115, 0, 0, 0, 0);
          opcionbateria = 7;
          pasobateria=3;
           Diego.println(" Aparcado");         
      }         
break;

case 'e':// Aparcar manual en linea
    delay(10);
     analogWrite(led, 200);
    //En linea               
   
       // RETROCEDE UN POCO
    if(pasobateria==0){

          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==0){                       
             tiempo1=duracion1;
             opcionbateria=1;
             Diego.println("Manual Linea");         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==1){         
             tiempo2=duracion2;         
             motor(115, 115, 0, 1, 1, 0);//<---------------------------------------------------------------------------------------
         }

     
        if((tiempo2-tiempo1)/1000 >=0.4){//<---------------------------------------------------------------------------------------
 
          motor(115, 90, 0, 0, 0, 0);       
          opcionbateria = 3;
        pasobateria=1;     
      } 
    }   
       delay(10);
 
    //GIRA a 45º
     if(pasobateria==1){ 
     
       duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==3){         
             tiempo1=duracion1;
             opcionbateria=4;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==4){         
             tiempo2=duracion2;         
             motor(115, 90, 0, 1, 0, 0);//<---------------------------------------------------------------------------------------
         }
 
     
        if((tiempo2-tiempo1)/1000 >=0.25){//<---------------------------------------------------------------------------------------
     
          motor(100, 100, 0, 0, 0, 0);   
          opcionbateria = 5;
          pasobateria = 2; 
        }   
     
    }
      delay(10);
   
    // MARCHA ATRAS
    if(pasobateria==2){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==5){         
             tiempo1=duracion1;
             opcionbateria=6;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==6){         
             tiempo2=duracion2;       
             motor(100, 100, 0, 1, 1, 0);//<---------------------------------------------------------------------------------------
         }
 
     
     
        if((tiempo2-tiempo1)/1000 >=0.8){//<---------------------------------------------------------------------------------------
   
          motor(90, 115, 0, 0, 0, 0);
          opcionbateria = 7;
          pasobateria=3;             
      }         
     }
     //GIRA DE NUEVO PARA ENDEREZAR
      if(pasobateria==3){
          duracion1 = millis();
            if(duracion1>= tiempo1 && opcionbateria ==7){         
             tiempo1=duracion1;
             opcionbateria=8;         
            }                 
     
        duracion2 = millis();
        if(duracion2>= tiempo2 && opcionbateria==8){         
             tiempo2=duracion2;       
             motor(90, 115, 0, 0, 1, 0);//<---------------------------------------------------------------------------------------
         }

     
        if((tiempo2-tiempo1)/1000 >=0.35){//<---------------------------------------------------------------------------------------
 
          motor(110, 110, 0, 0, 0, 0);
          opcionbateria = 9;
          pasobateria=4;
          Diego.println(" aparcar");       
      }         
     }
   
 
break;
    }
 delay(100); //se prepara
    }
}

PROGRAMACIÓN EN ARDUINO CON POTENCIÓMETRO

COMPETENCIA ESPECIFICA DE LA SESION

Programar la tarjeta ARDUINO UNO utilizando un lenguaje gráfico y comparar con lenguaje de texto. 

Conocer el entorno de mBlock y todas sus posibilidades. 

 Realizar programación básica utilizando software mencionado.

 CONTENIDOS A TRATAR

Entorno ARDUINO y tarjeta ARDUINO UNO  Entorno de programación básica con mBlock

RESULTADOS

Diseñan y optimizan sistemas y procesos para cumplir con las condiciones establecidas y gestionando adecuadamente los recursos materiales y humanos.

MATERIALES Y EQUIPO

-IDE Arduino y mBlock instalado.

-Tarjeta ARDUINO UNO

-Componentes accesorios.

-Guía de Laboratorio.

-El trabajo se desarrolla de manera GRUPAL.

-PC con Software de simulación.

ARDUINO

Arduino es una plataforma de creación de electrónica de código abierto, la cual está basada en hardware y software libre, flexible y fácil de utilizar para los creadores y desarrolladores. Esta plataforma permite crear diferentes tipos de microordenadores de una sola placa a los que la comunidad de creadores puede darles diferentes tipos de uso

               

POTENCIÓMETRO 

 Los potenciómetros limitan el paso de la corriente eléctrica (Intensidad) provocando una caída de tensión en ellos al igual que en una resistencia,  pero en este caso el valor de la corriente y  la tensión en el potenciómetro las podemos variar solo con cambiar el valor de su resistencia. En una resistencia fija estos valores serían siempre los mismos. Si esto no lo tienes claro es mejor que estudies las magnitudes eléctricas (enlace en lo subrayado). 

                          

Si nos fijamos tienen 3 patillas como el anterior. Para conectarlo debemos conectar al circuito las patillas A y B o la C y B, es decir la del medio siempre con una de los extremos y así conseguiremos que sea variable. Tienen una rosca que puede variarse con un destornillador, como es el caso del de color negro, o puede tener un saliente que gira con la mano para variar la resistencia del potenciómetro al valor que queramos. Estos potenciómetros también se llaman rotatorios.

            

 SERIAL PRINT ()

Descripción

Imprime datos en el puerto serie como texto ASCII legible. Este comando puede tomar muchas formas. Los números se imprimen utilizando un carácter ASCII para cada dígito. Los flotantes se imprimen de forma similar como dígitos ASCII, con dos decimales por defecto. Los bytes se envían como un solo carácter. Los caracteres y las cadenas se envían tal como están.

Serial.print(78) da "78"

Serial.print(1.23456) da "1.23"

Serial.print('N') da "N"

Serial.print("Hello world.") da "hola mundo".

Un segundo parámetro opcional especifica la base (formato) a usar; Los valores permitidos son BIN(binary, or base 2), OCT(octal, or base 8), DEC(decimal, or base 10), HEX(hexadecimal, or base 16). Para los números de punto flotante, este parámetro especifica el número de decimales que se utilizarán. Por ejemplo-

Serial.print(78, BIN) da "1001110"

Serial.print(78, OCT) da "116"

Serial.print(78, DEC) da "78"

Serial.print(78, HEX) da "4E"

Serial.print(1.23456, 0) da "1"

Serial.print(1.23456, 2) da "1.23"

Serial.print(1.23456, 4) da "1.2346"

Puede pasar cadenas basadas en memoria flash a Serial.print () envolviéndolas con F () . Por ejemplo:

Serial.print(F(“Hello World”))

Para enviar datos sin conversión a su representación como caracteres, use Serial.write () .

VIDEO EXPLICATIVO DEL LABORATORIO 

OBSERVACIONES 

Al momento de utilizar los potenciómetros del entrenador estos en ocasiones no respondían de manera adecuada debido a que ya presentaban desgastes y necesitaban ser cambiados.

-Para comenzar a utilizar estos dispositivos con el Arduino se tuvieron que conectar sus tres polos en las entradas analógicas del Arduino como también en GND.

-El limite de salida digital que nos ofrecían estos potenciómetros mediante la programación usada fueron de  a 255.

CONCLUSIONES

Los ejemplos que Arduino nos son muy útiles para comenzar a aplicar conceptos básicos de promocionan y tener una base para poder crear nuestras propias programaciones.

Realizar este tipo de programación nos ayudara a conocer un poco mas del lenguaje Arduino y así poder realizar nuestro proyecto al final de semestre.

PROGRAMACIÓN EN ARDUINO SERIAL PRINT

        PROGRAMACIÓN EN ARDUINO SERIAL PRINT

 COMPETENCIA ESPECIFICA DE LA SESION

Programar la tarjeta ARDUINO UNO utilizando un lenguaje gráfico y comparar con lenguaje de texto.  Conocer el entorno de mBlock y todas sus posibilidades.  Realizar programación básica utilizando software mencionado.

 CONTENIDOS A TRATAR

Entorno ARDUINO y tarjeta ARDUINO UNO  Entorno de programación básica con mBlock

 RESULTADOS

Diseñan y optimizan sistemas y procesos para cumplir con las condiciones establecidas y gestionando adecuadamente los recursos materiales y humanos.

 MATERIALES Y EQUIPO

-IDE Arduino y mBlock instalado.
-Tarjeta ARDUINO UNO
-Componentes accesorios.
-Guía de Laboratorio.
-El trabajo se desarrolla de manera GRUPAL.
-PC con Software de simulación.

SERIAL PRINT

Imprime datos al puerto serie como texto ASCII legible por humanos. Este comando puede tomar muchas formas. Los números se imprimen mediante un carácter ASCII para cada dígito. Los float se imprimen de manera similar a los dígitos ASCII, por defecto con dos cifras decimales.Los bytes son enviados como un solo carácter. Los caracteres y las cadenas se envían como son. Por ejemplo:

Serial.print (78) da "78"

Serial.print (1,23456) da "1,23"

Serial.print ( "N") da "N"

Serial.print ( "Hola mundo".) Da "Hola mundo".

Un segundo parámetro opcional especifica la base (formato) a usar; Los valores permitidos son BIN (binario o de base 2), OCT (octal o base 8), DEC (decimal o base 10), HEX (hexadecimal, o base 16). Para los números de punto flotante, este parámetro especifica el número de decimales a utilizar. Por ejemplo:

Serial.print (78, BIN) da "1001110"

Serial.print (78, OCT) da "116"

Serial.print (78, DEC) da "78"

Serial.print (78, HEX) da "4E"

Serial.println (1,23456, 0) da "1"

Serial.println (1,23456, 2) da "1,23"

Serial.println (1,23456, 4) da "1.2346"

VIDEO EXPLICANDO EL FUNCIONAMIENTO ARDUINO

OBSERVACIONES 

-Para la programación del arduino se tuvo que comenzar aprendiendo en el simulador mBlock un entrenador fácil de usar y de una manera educativa

-para programar el arduino se nesecito saber las entradas y salidas del arduino en el cual se observa en la tarjeta para poder añadir a la programación y poder ejecutar el programa

-Para pasar los datos al arduino se debe identificar que arduino se esta usando en este caso se uso el Arduino modelo UNO

CONCLUSIONES

Es importante reconocer la diferencia entre el Void Loop y el Void Setup para poder comenzar a realizar una correcta programación.

-Existen plataformas de hardware libre, como lo es el Arduino, una placa con un controlador y un entorno de desarrollo, su sencillez y bajo costo nos permiten hacer múltiples diseños y múltiples tipos de uso de éste.

-El uso del Arduino permite realizar muchas tareas, ahorrando elementos electrónicos y en sustitución, el uso de un lenguaje de programación, lo que hace que sea de muy fácil uso.

                 MICROCONTROLADORES

     PROGRAMACIÓN DE ARDUINO UTILIZANDO                 MBLOCK

CAPACIDAD TERMINAL 
-Utilizar al microcontrolador en aplicaciones de control electrónico.
-Desarrollar y ejecutar programas en un microcontrolador PIC
-Programar y configurar interfaces básicas del microcontrolador.

 COMPETENCIA ESPECIFICA DE LA SESION 
-Programar la tarjeta ARDUINO UNO utilizando un lenguaje gráfico y comparar con lenguaje de   texto.
-Conocer el entorno de mBlock y todas sus posibilidades.
-Realizar programación básica utilizando software mencionado.

CONTENIDOS A TRATAR 
-Entorno ARDUINO y tarjeta ARDUINO UNO
-Entorno de programación básica con mBlock

MATERIALES Y EQUIPO
-IDE Arduino y mBlock instalado.
 -Tarjeta ARDUINO UNO
 -Componentes accesorios.
 -Guía de Laboratorio. El trabajo se desarrolla de manera GRUPAL.
-PC con Software de simulación

EL ARDUINO

Arduino es una plataforma de creación de electrónica de código abierto, la cual está basada en hardware y software libre, flexible y fácil de utilizar para los creadores y desarrolladores. Esta plataforma permite crear diferentes tipos de microordenadores de una sola placa a los que la comunidad de creadores puede darles diferentes tipos de uso.
                                          
El Arduino es una placa basada en un microcontrolador ATMEL. Los microcontroladores son circuitos integrados en los que se pueden grabar instrucciones, las cuales las escribes con el lenguaje de programación que puedes utilizar en el entorno Arduino IDE. Estas instrucciones permiten crear programas que interactúan con los circuitos de la placa.

El microcontrolador de Arduino posee lo que se llama una interfaz de entrada, que es una conexión en la que podemos conectar en la placa diferentes tipos de periféricos. La información de estos periféricos que conectes se trasladará al microcontrolador, el cual se encargará de procesar los datos que le lleguen a través de ellos.
                       
        MBLOCK

                                             

Es un programa propietario de la empresa MakeBlock basado en Scratch 2.0 Open Software para sus robots.

Aunque la anterior definición hace pensar que es un programa que no nos interesa, todo lo contrario, pues los robots de Makeblock están basados en Arduino por lo tanto se programa realmente el corazón de Arduino.

VIDEO DEL DOCENTE PARA EL LABORATORIO

OBSERVACIONES

• MBlock es un programa bien recomendable para la programación de arduino puesto que contiene una forma distinta de aprender la programación conteniendo bloques y dando instrucciones de como puedes hacer la programación
• En la programación mBlock es un programa bien requerido y tiene una conexión con arduino ya que puedes conectar tu arduino y probar la programación creada en mBlock

CONCLUSIONES

Existen plataformas de hardware libre, como lo es el Arduino, una placa con un controlador y un entorno de desarrollo, su sencillez y bajo costo nos permiten hacer múltiples diseños y múltiples tipos de uso de éste.

El uso de arduino es un programa abierto en el cual se puede ejecutar una cantidad de tareas pudiendo ahorrar componentes electrónico  usando el lenguaje de arduino siendo muy fácil

MICROCONTROLADORES

LABORATORIO N° 07

Manejo del Timer y las

Interrupciones.

      I.     CAPACIDAD TERMINAL

●        Utilizar al microcontrolador en aplicaciones de control electrónico.

●        Desarrollar y ejecutar programas en un microcontrolador PIC

●        Programar y configurar interfaces básicas del microcontrolador.

    II.     COMPETENCIA ESPECIFICA DE LA SESION

●        Conocer el funcionamiento y la configuración de las Interrupciones

●        Conocer el funcionamiento y la configuración del Timer cero

●        Aplicar estos conocimientos en la realización de un cronómetro.

3. CONTENIDOS A TRATAR

●        Interrupciones

●        Timer cero.

      IV.     MATERIALES Y EQUIPO

●        CCS Compiler instalado.

●        Entrenador de PICS

●        Pantalla LCD

●        PIC16F877A

●        Guía de Laboratorio. El trabajo se desarrolla de manera GRUPAL.

●        PC con Software de simulación.

Timers:

Un timer no es más que un contador cuya entrada está conectada al reloj del sistema. De hecho, la mayoría de los timers pueden reconfigurarse como contadores. En ese caso, en lugar de contar pulsos de reloj cuentan los pulsos que llegan a un determinado pin.

Uso de TIMERS con interrupciones (timer)

Tras verificar que los TIMERS funcionan pasemos a usarlos en combinación con las interrupciones para poder establecer tareas a intervalos regulares. Por descontado, para poder usar interrupciones tenemos que habilitar las interrupciones globales y la interrupción del TMR0 en particular (aunque esto también se puede en la función OpenTimer con la máscara TIMER_INT_ON/OFF. Como vimos en el tutorial de interrupciones es conveniente trabajar con macros para no tener que recordar que bits habilitaban que interrupciones.

Ciertos timers están considerados periféricos, por lo que también tendríamos que habilitar las interrupciones periféricas, aunque no es el caso del TMR0.

El fundamento del proceso es sencillo. La interrupción del TMR0 se producirá cuando el contador del timer pase por cero (cada 256 o 65536 ciclos dependiendo de si estamos en 8 o 16 bits). La idea es arrancar con un valor del contador tal que en el tiempo deseado alcance el valor máximo (256 o 65536).

Consideremos el modo 8 bits (sin divisor) y arranquemos con un valor 156 en TMR0L. Necesitaremos 100 ciclos (256-156) para rebosar el contador y provocar la interrupción. Al cabo de 100 x 0.2 usec = 20 usec se producirá la primera interrupción.

El PIC 16F876A tiene un único vector de interrupción y todas las interrupciones que ocurran  provocan un salto que se dirija ese vector, para este suceso la rutina de manejo de la interrupción debe reconocer que  evento o efecto interrumpió el programa para ejecutar la rutina correcta.

Al finalizar la rutina del ciclo de interrupción  (RETFIE) el programa retorna al punto donde fue interrumpido

Las interrupciones permiten la interrupción del programa a cualquier suceso ya sea de tipo interno o externa, la interrupción que se da en el PIC  salta a la dirección del vector  (0004h) de interrupción y ejecuta el ciclo

El PIC  posee registros con flags  de interrupción los cuales les permiten  identificar el evento.

TEMPORIZADOR

En este caso los temporizadores etarana referidos en base al PIC 16F876A:

El PIC 16F876A dispone de tres temporizadores/contadores:

 Timer 0: 8 bits.

 Timer 1: 16 bits.

 Timer 2: 16 bits.

Pueden funcionar como contadores de flancos externos o como temporizador (contador de ciclos máquina)y disponen de “prescaler” para ampliar el tamaño de la cuenta (hasta x256), ademas un temporizador posee una cuenta de 16 bits en dos registros de 8 bits:

 TMR1H (parte alta)

 TMR1L (parte baja)

      

I.EVALUACIÓN

A partir del código mostrado, realice los cambios necesarios para realizar un programa que CUENTE EN FORMA DESCENDENTE, (temporizador regresivo), bajo  las siguientes condiciones:

-Al presionar pulsador en D0, incrementar SEGUNDOS. el temporizador aún no debe estar contando el tiempo. (sirve para configurar tiempo de cuenta).

-Al presionar pulsador en D1, iniciar CUENTA REGRESIVA desde los minutos previamente configurados.

-Si la cuenta llega a 00:00, congelar la cuenta y sonar BIP 3 veces.

CODIGO 

#include <16f877a.h>             // Incluimos archivo con PIC a utilizar
#use delay (clock=20M)           // Indicamos al compilador que trabajaremos a 20Mhz
#fuses HS, NOPROTECT, NOWDT      // Configuración básica de los fusibles

#define LCD_ENABLE_PIN        PIN_D3   //Definimos los pines a ser utilizados por la
#define LCD_RS_PIN            PIN_D2   //pantalla LCD
#define LCD_RW_PIN            PIN_A0  
#define LCD_DATA4             PIN_D4
#define LCD_DATA5             PIN_D5
#define LCD_DATA6             PIN_D6
#define LCD_DATA7             PIN_D7 
#include <lcd.c>                 // Incluimos librería para manejar Pantalla LCD

int centesimas=0,segundos=0,minutos=0;
INT encendido=0;
void BIP();
#int_TIMER0                      // FUNCION DE INTERRUPCION POR
void TIMER(VOID)                 // DESBORDAMIENTO DEL TIMER 0
{
   ++centesimas;                 // incrementar una centésima
   if (centesimas>99)
      {
      --segundos;                // si llegamos a 100, incrementar un segundo
      centesimas=0;
      }
   if (segundos==-1)
      {
      --minutos;                 // si llegamos a 60, incrementar un minuto
      segundos=59;
      }
   if (minutos==-1)                // si llegamos a 3 minutos, hacer alguna acción
      {
      minutos=0;
      disable_interrupts (INT_TIMER0);          //habilita interrupcion de timer0
      // agregar cualquier otra acción necesaria.
      }
  
   set_timer0 (61);              //reinicar cuenta desde 61
}

void main ()
{
   lcd_init () ;                                // Inicializamos pantalla LCD
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);   //configuracion del timer0
   set_timer0 (61);                             // interrupción cada centésima
   //enable_interrupts (INT_TIMER0);              //habilita interrupcion de timer0
   enable_interrupts (GLOBAL);                  //todas las interrupciones activadas
  
   printf (lcd_putc, "\f***Temporizador***") ;    // Mandamos mensaje por única vez

  
   WHILE (true)
   {
      lcd_gotoxy(2,2);
      Printf(lcd_putc,"Tiempo %02u:%02u",minutos, segundos);
     
   IF(!input(PIN_D0))                  
   {
   segundos = segundos + 1;
   delay_ms(500);
   }
   IF(!input(PIN_E0))                  
   {
   minutos = minutos + 1;
   delay_ms(500);
   }
   IF(!input(PIN_E2))
   {
   disable_interrupts (INT_TIMER0);   
   delay_ms(500);
   }
   IF(!input(PIN_D1))              
   {
   enable_interrupts (INT_TIMER0);
   encendido =1;
   }
   IF (minutos==0 && segundos==0 && encendido==1)
   {
      delay_ms(100);
      BIP();
      delay_ms(500);
      BIP();
      delay_ms(500);
      BIP();
      delay_ms(500);
    
      minutos=0;
      segundos=0;
      encendido =0;
    }
   }
}
void BIP()
{
    int i; 
    FOR (i=0;i<=50;++i)
    {
    output_high(PIN_E1); 
    delay_ms(1); 
    output_low(PIN_E1); 
    delay_ms(1); 
     }

}

OBSERVACIONES
  El registro TMR0 del timer0 en el PIC está formado por 8 bits por lo que se puede contar desde 0 hasta 255.

- Para generar los segundos, minutos y centésimas, debemos usar 3 variables de tipo entero  

-  Si queremos saber el tiempo de un segundo real debemos usar el timer 0 el cual es de 8 bits

-  Si queremos parar el cronómetro, usamos la sentencia: “disable_interrups” y el pulsador en el pin A5 el cual también aumenta los minutos y para iniciarlo de nuevo:  “enable_interrups” y el pulsador en el pin D0. 

CONCLUSIONES

-Se concluye que los Timer para los PICs tiene una amplia gama de aplicaciones en la práctica. Sólo unos pocos programas no lo utilizan de alguna forma. Es muy conveniente y fácil de utilizar en programas o subrutinas para generar pulsos de duración arbitraria, en medir tiempo o en contar los pulsos externos (eventos) casi sin limitaciones.

Para el caso de realizar un cronómetro con cuenta hacia atrás. Fue necesario asignar a la variable segundos 59 y terminarla en -1, igualmente con minutos.