MICROSOFT Y ARDUINO

MICROSOFT Y ARDUINO: UNA NUEVA ASOCIACIÓN

Con WINDOWS los desarrolladores de Arduino podrán tener un acceso remoto (inalámbrico) a las capacidades de Windows 10, como si estuvieran conectados físicamente a un Shield de Arduino y el aprovechamiento de las funcionalidades de Arduino directamente del menu de aplicaciones universales de Windows.

De este modo, Microsoft está permitiendo a los desarrolladores de aplicaciones extender su plataforma universal de Windows con comandos de Arduino. Combinando la potencia de los dispositivos con Windows 10, incluyendo características tales como el procesamiento de voz, análisis de sitios web, cámaras, audio y más, permitirá la creación de la creación de increíbles proyectos.

Por ejemplo un celular Lumia 530 contiene una gran capacidad para conectar todos los componentes a un shield de Arduino. Imagine que es capaz de crear un proyecto Arduino que incluya GPS, conectividad web/análisis, pantalla táctil, tecnologías de voz y mucho más (ver imagen).

Arduino es realmente feliz de que Microsoft se inspirara por el entusiasmo y la pasión por la tecnología representada por la comunidad Maker y todos estamos ansiosos de ver los proyectos increíbles que se abren a partir de este convenio.

´

De nuestra parte esperamos que se sigan desarrollando más convenios que permitan la integración de los todos los amantes y apasionados de la teconología Arduino.

Fuente: http://blog.arduino.cc/2015/04/30/microsoft-and-arduino-new-partnership/

CIRCUITOS ELECTRÓNICOS

DIODOS

En esta oportunidad vamos hablar de los diodos, un componente electrónico elaborado por semiconductores como Si o Ge que permiten la circulación de la corriente en un determinado sentido ¿Cómo así? observa la imagen y verás...

La corriente circula por una patilla llamada ÁNODO que el buen Faraday bautizó como "camino ascendente" o "de entrada" y termina en la otra patilla llamada CÁTODO y que pasa si circula por un sentido contrario, es decir de CÁTODO al ÁNODO pues el diodo prefiere morir antes de ser ultrajado de esa manera. Ahora veremos bien lo que más nos interesa es conocerlos en la realidad, para eso tenemos una infinidad de diodos que a continuación pasaremos a nombrar... acompáñanos ;)

1) DIODO RECTIFICADOR: Diodo muy conocido y usado en los que son rectificadores de onda (de ahí su nombre), ya sea de media onda o de onda completa:

RECTIFICADOR MEDIA ONDA

RECTIFICADOR DE ONDA COMPLETA

Vemos en la siguiente imagen al rectificador con su respectiva polaridad, también mencionar que tiene un aguante medio de corriente y que uno de los códigos más conocidos son los 1N4001, 1N4004, 1N4007.

Diodo rectificador

2) DIODO EMIZOR DE LUZ (LED): Personalmente es uno de mis favoritos, diodo que con un voltaje nos emite un color determinado que poder visualizar en el siguiente cuadro:

Diodos LED y su tensión umbral

Recorda que el CÁTODO en un LED es la patilla más corta que el ÁNODO, también podemos ver en la figura los demás componentes que conforman a ese diodo iluminador

Diodo LED

CONTROL DE MOTORES USANDO EL ULTRASONIDO HC SR04

Hola a todos, en esta ocasión haré un pequeño tutorial sobre como usar el ultrasonido HC SR04 con un Arduino, y también haremos una aplicación controlando unos motores DC.
Bueno lo primero que vamos hacer es conocer un poco del sensor HC SR04, el cual posee cuatro pines (Vcc, Trigger, Echo, GND)

Ahora veremos el código en Arduino y un pequeño video de la demostración:

   Colocamos Trigger(disparo) al pin 50 del Arduino y Echo al pin 52, una vez echo esto se declara dos variables del tipo float (distancia y tiempo) que nos ayudarán a calcular la ida y venida del ultrasonido que se emite y que se recibe luego de tocar algún objeto.  Para medir la distancia usaremos la consola serial del Arduino, para eso invocamos el comando “Serial.begin(9600)”, seguido de eso declaramos el pin Trigger como salida, ya que es el que hace el disparo de la señal ultrasónica y el pin Echo como entrada que es aquel que va recibir la señal luego de tocar un objeto.
El algoritmo que se muestra en el void Loop, es el que nos permite inicializar el ultrasonido mandando un pulso para luego recibirla y calcular la distancia a través del tiempo que ha tomado en regresar teniendo en cuenta que la velocidad del sonido es de 340 m/s.
El comando Serial.print es para imprimir en la consola la distancia calculada, ese pequeño delay de 500 ms es recomendable para que pueda ser recalculado el valor de la distancia.

Ahora haremos una aplicación donde controlaremos la velocidad de unos motores DC, para eso tenemos que usar un puente H, el que tengo usa un driver L298N, que tiene pines de habilitación y pines que controlan el giro de los motores; esto se puede replicar a cualquier puente H que tengan, solo basta reconocer los pines del PWM y los pines de giro.
Bueno la programación que tenemos es:
//Pines del puente H
int in1 = 22;
int in2 = 23;
int enA = 2;
int in3 = 24;
int in4 = 25;
int enB = 3;
//Pines del ultrasonido
int trigger = 50;
int echo = 52;
float distancia,tiempo;
void setup()
{
Serial.begin(9600);
//Configuración como salida a los pines de giro
pinMode(in1,OUTPUT);
pinMode(in2,OUTPUT);
pinMode(in3,OUTPUT);
pinMode(in4,OUTPUT);
//Configuración como salida a los pines del PWM
pinMode(enA,OUTPUT);
pinMode(enB,OUTPUT);
pinMode(trigger,OUTPUT);
pinMode(echo,INPUT);
}
void loop()
{
//Algoritmo para el ultrasonido 
digitalWrite(trigger,LOW);
delayMicroseconds(2);
digitalWrite(trigger,HIGH);
delayMicroseconds(10);
digitalWrite(trigger,LOW);
tiempo=pulseIn(echo,HIGH);
distancia=(tiempo/2)/29.1;
Serial.print(distancia);
Serial.print("cm");
Serial.println();
//Establecemos un sentido de giro
digitalWrite(in1,HIGH);
digitalWrite(in2,LOW);
digitalWrite(in3,HIGH);
digitalWrite(in4,LOW);
//Le damos un valor al PWM
analogWrite(enA,150);
analogWrite(enB,150);
//Colocamos el valor de distancia al PWM, se puede jugar con esto
if(distancia<5)
{
analogWrite(enA,254);
analogWrite(enB,254);
}
delay(500);
}
Inicialmente se puede definir el giro de los motores escribiendo un cero o un uno a los pines in1,2,3,4 y también podemos poner un valor al PWM, en mi caso yo le puse 150; lo haremos cambiar al acercarnos a una distancia menor de 5 cm colocando el PWM 254, un valor que puede ser cambiado al gusto.

PROYECTO ROBOT SUMO

 

PARTES DEL CHASIS

Bueno ahora veremos la estructura final del robot sumo, pasare a detallar las partes que conforman el chasis; recordando lo último que vimos que era la base donde iban a estar los motores, después de hacer unos cuantos huecos al final queda así:

Como verán en las fotos, ya están colocados los famosos sensores CNY70, lo que hice fue hacer 4 huecos en las esquinas y luego pegar con silicona los sensores, claro que los sensores están debidamente conectados con los cables blanco (señal de salida), negro(tierra) y rojo( +5v) .

Ahora colocaremos los motores, las características de los motores que estoy utilizando ya están posteados en otra entrada del blog así que revísenla, ahora mostrare como han que dado después de hacerles algunos cortes y colocarlos en paralelo.

La parte de los postes que se van a colocar en la base de los motores están hechos de aluminio, un material bastante barato y sobre todo liviano, el poste mas pequeño este entre 7 y 8, el mas largo es de aproximadamente 16 cm.

Bueno por ahora eso es todo, en una siguiente entrada estaremos mostrando el armado final de la estructura para luego pasar a la pala del robot y luego ver la circuitería junto con la programación, hasta la próxima….

PROGRAMACION DE PIC EN C

JUEGO DE LUCES (COCHE FANTÁSTICO)

En esta oportunidad estaremos presentando un llamativo juego de luces que oscilaran de manera diferente, este juego de luces se realizara con la ayuda de sentencias como If o for.
Entonces para mejor comprensión tenemos el esquema en Isis Proteus, vamos a utilizar los pines del puerto B, para conectar como salidas a nuestros LEDs.

Bueno en este ejemplo no hay mucho que explicar, pero si hay que recordar como se usa el ciclo for.

for (inicializacion; condición de termino; incremento)
{
    sentencias();
}

A través del ciclo for recorreremos las matrices que vamos a crear para que los LEDs sean encendidos o apagados.

// Juego de Luces - PIC en C

#include <16f877a.h> // incluimos el archivo PIC a utilizar
#use delay(clock = 4000000) // Reloj de 4 Mhz
#fuses XT, NOWDT,NOLVP // fusibles XT(XTal) = 4 Mhz
#use fast_IO(B) // permite utilizar las funciones output_x() , etc.

// funcion principal
void main()
{
   signed int i;  // Declaramos a la variable entera i con signo
   int LEDs1[4] = {0b10000001,0b01000010,0b00100100,0b00011000} // Primer arreglo declarado
   int LEDs2[10]={0b01111111,0b10111111,0b11011111,0b11101111,0b11110111,0b11111011,0b11111101,0b11111110} // Segundo arreglo
 
  set_tris_B(0x00) ; // Declaramos a los pines del puerto B como salidas

     while(true) // Bucle infinito
     {
         for(i=0;i<4;i++)
         {
            output_B(LEDs1[i]); // por el puerto B se saca lo que hay en el primer arreglo del incio al final
            delay_ms(300); // 300 milisegundos es conveniente
         }
            output_B(0xFF);   // después que salga del bucle ponemos todos los pines a 1 durante 300 ms.
            delay_ms(300);
        for(i=0; i<9; i++)
        {
            output_b(LEDS2[i]);  // recorremos el 2 arreglo del inicio al final
            delay_ms(300);
        }
            output_B(0xFF); // ponemos otra vez a 5v todos los pines
            delay_ms(300);
   
       for(i=9; i>=0; i--)
       {
            output_b(LEDS2[i]); // recorremos el segundo arreglo de final al inicio
            delay_ms(300);
       }
            output_B(0xFF); // ponemos a 5v
            delay_ms(300);    
      for(i=4; i>=0; i--)
       {
            output_b(LEDS1[i]); // vamos del final al inicio
            delay_ms(300);
      }
    }//Fin del while
} // Fin del programa

Como se habrán dado cuenta, el programa es bastante sencillo y se puede hacer muchas variantes; ya queda  a la imaginación de cada uno como es que lo quiere hacer funcionar, puede aumentarle arreglos y poner mas ciclos for o poner a 5V los pines, etc.

PROGRAMACION DE PIC EN C

CONTADOR DE DE 0  a 9

En esta oportunidad haremos un contador que cuente de 0 a 9, o que cuente de 9 a 0, todo depende de lo que pongamos en el codigo del PIC.

Ahora pasaremos a ver el esquema en ISIS Proteus:

Explicaremos un poco del display, para poder entender que es lo que vamos hacer. El display que se presenta en la figura es de tipo Cátodo común, es decir que el pin común a todos es el cátodo  que es el pin que va a tierra; en el caso que sea Ánodo común, el pin en común va a +Vcc..

Para que a la salida del puerto D, visualizemos los numeros, tenemos que tener en cuenta lo siguiente:

Eso nos quiere decir, que si por el puerto D sacamos la secuencia de bits: 0b100000110 en el display se mostrara el numero "1"; el 1 que se encuentra al costado de la "b" es el bit que prende el punto que se encuentra abajo de todos los display. A continuación presentamos una tabla que donde se encuentran las posibles combinaciones para mostrar los números en el display.

Luego de haber explicado el funcionamiento del display, pasaremos hacer el codigo en C, en el código utilizaremos un poco de Arrays (Arreglos,matrices), a medida que iremos poniendo el codigo iremos comentando los que significa cada linea.

// Contador de 0 a 9

#include <16f877a.h> // incluimos el pic a utilizar.
#use delay (clock = 20 000 000) // Reloj de 20 Mhz
#fuses HS, NOWDT,NOLVP // son los fusibles que utilizaremos para la grabación de nuestro PIC
#fast_IO(D) // declaramos el pines del puerto de D

// declaracion de las variables y de nuestro arreglo
int i;
int DISPLAY[10] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67}
// Tambien se pudo haber puesto en binario: 0b10111111,0b10000110 ...

// funcion principal
void main ()
{
     set_tris_D(0x00) ; // declaramos pines del puerto D como salida (0= output)

     while(true) // Bucle infinito
     {
        output_D(DISPLAY[i]); // sacamos por el puerte D, lo que se encuentra en el arreglo DISPLAY
        delay_ms(300); // hacemos que cada numero de muestre en el display durante 300 ms
        i++ ; // tenemos que aumentar la cuenta para que pase al siguiente numero
      }
}  // Fin del programa.

Ahora si queremos que nuestro contador no pare en nueve y que se reinicie a 0 y vuelva a la cuenta, agregamos lo siguiente:

// Dentro del while ponemos:
      if(i>9)
      {
            i =0;
      }

Listo una vez hecho eso veremos que nuestro contador se reinicia y luego vuelve a contar.

PROGRAMACION DE PIC EN C

Parpadear un LED

En el siguiente ejercicio, haremos un ejercicio clásico  que es el de hacer parpadear un LED, para eso utilizaremos el PIC 16F877A, a medida que avancemos en el código iremos explicando lo que se necesita en la programación, para el código utilizaremos el IDE PIC C Compiler y para la simulación usaremos el ISIS Proteus.
Ahora veremos el circuito para hacer parpadear el LED:

Ahora crearemos un archivo en el PIC C Compiler

1. El primer paso es ir al icono de la carpeta, luego New- Source file y creamos nuestro archivo

2, Después de guardarlo nos vamos otra vez al icono de la carpeta  luego New - Project Manual, elegimos el PIC que queremos utilizar, añadimos (+Add) nuestro archivo antes guardado y luego en aplicar(Apply).

Una vez creada nuestro archivo, empezamos con la programacion:

// Parpadear un LED - PIC en C
 #include <16f877a.h>   // incluimos nuestro PIC  a utilizar

#use delay(clock = 20000000) // usamos un reloj de 20 Mhz

#fuses HS,NOWD,NOLVP // HS: high speed adecuado para reloj de 20 Mhz

#use fast_IO(B)  // declaramos los registro TRIS y PORT del puerto B

void main () // funcion principal
{
        set_tris_B(0x00) ; // Configuramos los pines del puerto B como salida
                                    // output = 0 (salida) , input = 1 (entrada)
 
         while(true)  // bucle infinito donde haremos parpadear al LED
         {
             output_high(pin_B0) ; // ponemos en alto(5V) el pin B0
             delay_ms(1000); // Le indicamos que este en 5V durante 1000mseg = 1seg

            output_low(pin_B0); // ponemos en 0 (0V) el pin B0
            delay_ms(1000);

          } // Fin del bucle
} // Fin del programa

Muy bien, una vez escrito el código pasamos a construir el proyecto (Build All) y luego compilamos.

Si acaso te de pereza leer el archivo, acá te dejo el vídeo que hice, Saludos !