Registro de desplazamiento de 8 leds.

publicado en: Blog, Tutoriales | 0

Registro de desplazamiento de 8 leds

En tutoriales anteriores aprendimos a usar el BLINK con arduino, ahora haremos una extensión de el para hacer un desplazamiento a un registro de desplazamiento  de 8 leds. Los leds estarán encendiendo de manera individual y repetitiva.

El orden de encendido será del bit menos significativo al bit más significativo ósea de derecha a izquierda.

 

 

 

Sin título

 

En la figura se muestra una forma opcional de conectar el circuito.

La salida del arduino correspondiente al primer bit (al menos significativo) es la 13, mientras que la salida que corresponde al bit más significativo es la 6.

 

En esta ocasión mostraremos dos códigos diferentes para hacer la misma función y queda en criterio del lector cual implementar, en el  primer programa, se pondrá en alto el bit menos significativo, se desplazara  hasta llegar al más significativo y se repetirá el ciclo.

 

 

PROGRAMA

// Registro de desplazamiento con 8 leds

int LED=13;    //Declaracion de variables
int LED1=12;
int LED2=11;
int LED3=10;
int LED4=9;
int LED5=8;
int LED6=7;
int LED7=6;


void setup()
{

 pinMode(LED,OUTPUT);    //Declarar las variables como salidas
 pinMode(LED1,OUTPUT);
 pinMode(LED2,OUTPUT);
 pinMode(LED3,OUTPUT);
 pinMode(LED4,OUTPUT);
 pinMode(LED5,OUTPUT);
 pinMode(LED6,OUTPUT);
 pinMode(LED7,OUTPUT);

}


void loop()
{
  digitalWrite(LED,HIGH);    // El ciclo inicia encendiendo el LED 
     delay (1000);           //correspondiente al bit menos significativo  
  digitalWrite(LED1,LOW);    //para continuar encendiendo los demas leds.
  digitalWrite(LED2,LOW);    //El retardo solo se utilizara para el led   
  digitalWrite(LED3,LOW);    //que encendemos para que se visualice este proceso
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 

  digitalWrite(LED,LOW);    
  digitalWrite(LED1,HIGH);
       delay (1000);             
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 


  digitalWrite(LED,LOW);    
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,HIGH);
         delay (1000);             
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 
  
  digitalWrite(LED,LOW);    
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,HIGH);
       delay (1000);             
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 
  
  digitalWrite(LED,LOW);    
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,HIGH);
          delay (1000);             
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 
  
  digitalWrite(LED,LOW);    
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,HIGH);
       delay (1000);             
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW); 
  
  digitalWrite(LED,LOW);    
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,HIGH);
      delay (1000);  
  digitalWrite(LED7,LOW); 
  
  digitalWrite(LED,LOW);     //En esta rutina encendera el LED7 correspondiente  
  digitalWrite(LED1,LOW);   //al led mas significativo.
  digitalWrite(LED2,LOW);      
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,HIGH);
       delay (1000); 
      
  digitalWrite(LED,LOW);      //En esta parte del programa no encendera ningun
  digitalWrite(LED1,LOW);     //para evitar el encendido de dos leds al mismo tiempo
  digitalWrite(LED2,LOW);     
  digitalWrite(LED3,LOW);      
  digitalWrite(LED4,LOW);      
  digitalWrite(LED5,LOW);      
  digitalWrite(LED6,LOW);      
  digitalWrite(LED7,LOW);
    delay(1000);
 
  
    }

En el segundo programa usaremos una rutina con un ciclo “For” y obtendremos el mismo resultado pero con menos líneas de código ofreciendo muchas ventajas, este ciclo se compara el valor de la variable i entre el valor de la condición, cuando sean iguales el valor de i y el valor de la condición el ciclo se repetirá.

 

PROGRAMA 2

//Registro de desplazamiento de 8 bits con for

int i;        //Declaracion de variables
int LED=13;
int LED1=12;
int LED2=11;
int LED3=10;
int LED4=9;
int LED5=8;
int LED6=7;
int LED7=6;


void setup()
{

 pinMode(LED,OUTPUT);    //La variables se declaran como salidas
 pinMode(LED1,OUTPUT);
 pinMode(LED2,OUTPUT);
 pinMode(LED3,OUTPUT);
 pinMode(LED4,OUTPUT);
 pinMode(LED5,OUTPUT);
 pinMode(LED6,OUTPUT);
 pinMode(LED7,OUTPUT);

}

void loop()
{
  
  for (i=13;i>=6;i--)       // En el ciclo for la variable i 
  {                        //su valor inicial es 13 y se compara 
    digitalWrite(i,HIGH);  //con la condicion i>=6 si i es mayor 
    delay(1000);           //o igual a 6 i decrementa. 
    digitalWrite(i,LOW);  
    }
    }
    

 

 

 

 

 

QDSP6064

publicado en: Tutoriales | 0

QDSP6064.

Es un circuito integrado que contiene cuatro dígitos en 7 segmentos con un cátodo independiente por cada dígito. Su presentación consta de un encapsulado tipo DIP de 12 pines.

 

 

 

QDSP6064_Four_Digit_Seven_Segment_Bubble_LED_Display_Module_1__65680.1412121494.1280.1280

 

Especificaciones:

Corriente: 5 mA en promedio por segmento.

Tensión: 5 volts de corriente continúa.

Potencia: potencia de disipación por dígito 80 mW.

 

QDSP6064_Four_Digit_Seven_Segment_Bubble_LED_Display_Module_3__92738.1412121492.1280.1280

 

La numeración de los pines se hace tomando como referencia el circulo blanco que está a un lado del pin número 1.

Sin título
Usaremos el QDSP6064 para mostrar un mensaje con los 4 displays de 7 segmentos que contiene para ello usaremos una tarjeta arduino 1 , conectaremos cada segmento (ánodo) y cátodo a una salida digital del arduino.

 

El código que utilizamos para hacer funcionar el QDSP6064 es el siguiente:

//QDSP Conexión y funcionamiento.

int i;    //declaramos las variables.
int a=6;
int b=7;
int c=8;
int d=9;
int e=10;
int f=11;
int g=12;
int k1=5;
int k2=4;
int k3=3;
int k4=2;


void setup()
{
  for(i=2;i<13;i++)  // declaramos del pin 2 al pin 13
                     //como salidas digitales                  
    {
    pinMode(i,OUTPUT);
    }
    
    digitalWrite(k1,HIGH);  
    digitalWrite(k2,HIGH);
    digitalWrite(k3,HIGH);
    digitalWrite(k4,HIGH);
    
    }
    
   void loop()
    {
     
     //Para que en el dígito 1 correspondiente al cátodo 1 
     //aparezca la letra H

    digitalWrite(a,LOW);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,LOW);
    digitalWrite(e,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,HIGH);
    digitalWrite(k1,LOW);
    digitalWrite(k2,HIGH);
    digitalWrite(k3,HIGH);
    digitalWrite(k4,HIGH);
    delay(10);
    
  
  //Para que en el dígito 2 correspondiente al cátodo 2 
  //aparezca la letra O    


    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,HIGH);
    digitalWrite(e,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,LOW);
    digitalWrite(k1,HIGH);
    digitalWrite(k2,LOW);
    digitalWrite(k3,HIGH);
    digitalWrite(k4,HIGH);
    delay(10);
    
  
  //Para que en el dígito 3 correspondiente al cátodo 3 
  //aparezca la letra L    
  
    digitalWrite(a,LOW);
    digitalWrite(b,LOW);
    digitalWrite(c,LOW);
    digitalWrite(d,HIGH);
    digitalWrite(e,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,LOW);
    digitalWrite(k1,HIGH);
    digitalWrite(k2,HIGH);
    digitalWrite(k3,LOW);
    digitalWrite(k4,HIGH);
    delay(10);
    
  //Para que en el dígito 4 correspondiente al cátodo 4 
  //aparezca la letra A

    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,LOW);
    digitalWrite(e,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,HIGH);
    digitalWrite(k1,HIGH);
    digitalWrite(k2,HIGH);
    digitalWrite(k3,HIGH);
    digitalWrite(k4,LOW);
    delay(10);
        }

    

 

Una vez programado el arduino con el código fuente anterior y conectado correctamente el resultado de nuestro circuito será el siguiente.

 

11139656_965848550106154_1800026521_n

Tutorial de CadSoft EAGLE “diseño de Circuitos”

publicado en: Tutoriales | 0

Con el fin de compartir conocimiento el equipo de Geekbot realizo este pequeño tutorial en el cual se muestra como diseñar un circuito en Eagle utilizando la herramienta de auto ruteado, el tutorial es paso a paso y está enfocado en aquellas personas que quieren empezar a utilizar este grandioso software de diseño.

 

 

 

Motores de DC

publicado en: Tutoriales | 0

Descripción
El motor de corriente continua (motor DC) es una máquina que convierte la energía eléctrica en mecánica, provocando un movimiento rotatorio. En algunas modificaciones, ejercen tracción sobre un riel. Estos motores se conocen como motores lineales.

Una máquina de corriente continua (generador o motor) se compone principalmente de dos partes, un estator que da soporte mecánico al aparato y tiene un hueco en el centro generalmente de forma cilíndrica. En el estator además se encuentran los polos, que pueden ser de imanes permanentes o devanados con hilo de cobre sobre núcleo de hierro. El rotor es generalmente de forma cilíndrica, también devanado y con núcleo, al que llega la corriente mediante dos escobillas.

Partes de un motor de corriente directa:

images (4)

 

Funcionamiento


  • Sentido de giro

 

El sentido de giro de un motor de corriente continua depende del sentido relativo de las corrientes circulantes por los devanados inductor e inducido.
La inversión del sentido de giro del motor de corriente continua se consigue invirtiendo el sentido del campo magnético o de la corriente del inducido.
Si se permuta la polaridad en ambos bobinados, el eje del motor gira en el mismo sentido.

Los cambios de polaridad de los bobinados, tanto en el inductor como en el inducido se realizarán en la caja de bornes de la máquina, y además el ciclo combinado producido por el rotor produce la fuerza magneto-motriz

 

motor

 

Fuerza contra electromotriz inducida en un motor

Es la tensión que se crea en los conductores de un motor como consecuencia del corte de las líneas de fuerza, es el efecto generador de pines.

Aplicaciones
Para la mini robótica, este es un actuador muy básico ya que en la electrónica el voltaje de corriente continua es muy común y fácil de conseguir en baterías. Las aplicaciones van desde motores con reducción para desplazar una plataforma, actuadores para mover mecanismos de brazos, servo motores, y múltiples usos más.

 

Brazo robótico

BRAZO_ROB__TICO_51f2b2e709cf3

Movimiento de ruedas

motor-reductor

Reducciones mecánicas
Toda máquina cuyo movimiento sea generado por un motor (ya sea eléctrico, de explosión u otro) necesita que la velocidad de dicho motor se adapte a la velocidad necesaria para el buen funcionamiento de la máquina. Además de esta adaptación de velocidad, se deben contemplar otros factores como la potencia mecánica a transmitir, la potencia térmica, rendimientos mecánicos (estáticos y dinámicos).

Esta adaptación se realiza generalmente con uno o varios pares de engranajes que adaptan la velocidad y potencia mecánica montados en un cuerpo compacto denominado reductor de velocidad aunque también se le denomina caja reductora.

images (5) motor-micro-metal-dc-con-reductora-5-1


Potencia

Amplificación de la potencia de una señal eléctrica
Un amplificador de potencia convierte la potencia de una fuente de corriente continua (polarización Vcc de un circuito con transistores), usando el control de una señal de entrada, a potencia de salida en forma de señal. Si sobre la carga se desarrolla una gran cantidad de potencia, el dispositivo deberá manejar una gran excursión en voltaje y corriente.

formula 1

 

formula 2

Fpzt5

 

Drivers de potencia integrados tipo puente “H”
Un Puente “H” es un circuito electrónico que permite a un motor eléctrico DC girar en ambos sentidos, avance y retroceso. Son ampliamente usados en robótica y como convertidores de potencia. Los puentes “H” están disponibles como circuitos integrados, pero también pueden construirse a partir de componentes discretos.

 

Estructura de un puente H

250px-H_bridge.svg

Teoría de funcionamiento de un puente “H” y control de sentido de giro en motores de CD

El término “puente H” proviene de la típica representación gráfica del circuito. Un puente H se construye con 4 interruptores (mecánicos o mediante transistores). Cuando los interruptores S1 y S4 están cerrados (y S2 y S3 abiertos) se aplica una tensión positiva en el motor, haciéndolo girar en un sentido. Abriendo los interruptores S1 y S4 (y cerrando S2 y S3), el voltaje se invierte, permitiendo el giro en sentido inverso del motor.

Estados básicos del circuito.

350px-H_bridge_operating.svg

el puente H que ocupamos el L293D cuyas conexiones básicas son las siguientes:

chipl293ne

Tabla de manejo para control bidireccional del motor

MotoresCC_293D_ejemplo01tabla

Control de tracción de un motor y Arduino

clase_2_control de motor_bb

 

Código

int m1=13; //pin donde se conectó la 1° entrada del driver
int m2=12;//pin donde se conectó la 2° entrada del driver
void setup() {
 pinMode(m1,OUTPUT); //declaración de los pines como salida
 pinMode(m2,OUTPUT);
}

void loop() {
 digitalWrite(m1,HIGH); //escribir un estado alto digital en el pin
 digitalWrite(m2,LOW); //escribir un estado bajo digital en el pin
 delay(1000); //retardo en mS = 1S
 digitalWrite(m1,LOW); //escribir un estado bajo digital en el pin
 digitalWrite(m2,HIGH); //escribir un estado alto digital en el pin
 delay(1000); //retardo en mS = 1S

}

 

 

DHT11 Sensor de humedad y temperatura

publicado en: Tutoriales | 0

El sensor DTH11 es un módulo que nos permite medir la humedad relativa y temperatura ambiental. Este sensor tiene una resolución de 1°C y un rango de trabajo de 0°C a 50°C para la temperatura, y resolución de 1% y un rango de trabajo desde el 20% hasta el 95% de humedad relativa. El sensor trabaja con una tensión de 3.3 V a 5 V.

Humedad relativa. Relación entre la cantidad de vapor de agua que tiene una masa de aire y la máxima que podría tener.

dht11_pins

Este sensor se caracteriza por enviar una señal digital calibrada por lo que asegura una alta calidad y una fiabilidad a lo largo del tiempo, ya que contiene un microcontrolador de 8 bits integrado. Está constituido por dos sensores resistivos (NTC y humedad). Tiene una excelente precisión y una respuesta rápida en las medidas.

Cada sensor DHT11 está estrictamente calibrado en laboratorio, presentando una extrema precisión en la calibración. Los coeficientes de calibración se almacenan como programas en la memoria OTP, que son empleados por el proceso de detección de señal interna del sensor.

La comunicación con este sensor se realiza mediante un protocolo de un único hilo (protocolo 1-wire), lo que hace que la integración de este sensor en nuestros proyectos sea rápida y sencilla. Además presenta un tamaño reducido, un bajo consumo de energía y la capacidad de transmitir la señal hasta 20 metros de distancia.

Características del sensor:

caracteristicas

ya conocidas las características se explicara las conexiones eléctricas del sensor DTH11 con el arduino.

esquema-fritzing-dht11

 

El sensor tiene 4 pines de conexión, el primero es VCC, el segundo es el de Señal, el tercero no se conecta y el cuarto es GND.

Como se mensiono la tension de VCC puede ser de 3.3V a 5V el pin de señal tiene que tener una resistencia PULL-UP de 22KΩ, esto ya que el protocolo lo requiere. Y el ultimo pin se coencta directo a GND.

Instalar Bibliotecas del sensor DTH11

Antes de verificar el código y cargarlo al arduino es necesario desargar la biblioteca del sensor DTH11  y agregarla a la carpeta de nuestro programa.

Para descargar la biblioteca junto con los diagramas de conexión se puede ir a este link:

http://www.geekbotelectronics.com/wp-content/uploads/2014/09/DTH11-Biblioteca.zip

o ingresar a la pagina de http://www.geekbotelectronics.com/producto/dth11-sensor-de-temperatura-y-humedad-digital/ y dar clic en Biblioteca Arduino

 

pagGeekBot

el archivo descargado lo deberás descomprimir en la carpeta donde se guardo el proyecto de arduino.

Es hora de explicar el código en Arduino para el sensor DTH11.

 

// Sketch de ejemplo para testear el famoso sensor DHT de

//humedad y temperatura

#include “DHT.h”

//Añadimos la Biblioteca con la cual trabaja nuestro sensor

#define DHTPIN 2

// Indicamos el pin donde conectaremos la patilla data de nuestro //sensor

//este pin puede ser cualquiera que se desee

// Descomenta el tipo de sensor que vas a emplear. En este caso //usamos el DHT11

#define DHTTYPE DHT11 // DHT11

//#define DHTTYPE DHT22 // DHT22(AM2302)

//#define DHTTYPE DHT21 // DHT21 (AM2301)

// Conecta el pin 1 (el de la izquierda) del sensor a +5V

// Conecta el pin 2 del sensor al pin que has elegido para DHTPIN

// Conecta el pin 4 (el de la derecha) del sensor a GROUND

// Conecta una resistencia de 10K del pin 2 (data) al pin 1 (+5V) del sensor

DHT dht(DHTPIN, DHTTYPE);

//Indica el pin con el que trabajamos y el tipo de sensor

void setup()

{

  //Inicio comunicación serie para ver los datos en el ordenador

  Serial.begin(9600);

  //Mensaje de inicio

  Serial.println(“Comprobacion sensor DHTxx:”);

  //Iniciamos el sensor

  dht.begin();

}

void loop()

{

 // La lectura de la temperatura o de la humedad lleva sobre 250

 //milisegundos

 // La lectura del sensor también puede estar sobre los 2 segundos

 //(es un sensor muy lento)

  int h = dht.readHumidity();  //Guarda la lectura de la humedad en //la variable int h

  int t = dht.readTemperature();

   //Guarda la lectura de la temperatura en la variable int t

  // Comprobamos si lo que devuelve el sensor es valido, si no son //numeros algo       //esta fallando

  // función que comprueba si son números las variables indicadas

  if (isnan(t) || isnan(h))

  {

    Serial.println(“Fallo al leer del sensor DHT”);

   //Mostramos mensaje de fallo si no son números

  }

  else {

    //Mostramos mensaje con valores actuales de humedad y temperatura

    Serial.print(“Humedad relativa: “);

    Serial.print(h);

    Serial.print(” %\t”);

    Serial.print(“Temperatura: “);

    Serial.print(t);

    Serial.println(” *C”);

      }

}

 

 

El circuito del sensor DTH11 se vera de la siguiente manera.

DTH11 PRoto 2 DTH11 proto

¡Visitanos en Facebook y comparte tus proyectos!

https://www.facebook.com/GeekbotMexico

BLINK la primera práctica en MicroControladores

publicado en: Tutoriales | 0

Todos los lenguajes de programación tienen su famoso programa de iniciación en la materia. En los lenguajes gráficos como lo son Java, C, C++, Python, etc., tienen el famoso “¡hola mundo!”, el programa que muchos de nosotros hemos realizado alguna vez, o que lo realizaremos al entrar en la materia. El mundo de la electrónica programada y diseño de hardware no se queda lejos de este programa de iniciación en la materia, ya que tenemos nuestro propia forma de inicializar a los nuevos con un emotivo y rápido programa llamado “BLINK”.

Blink es el programa en el que logramos hacer que un LED encienda y se apague intermitentemente, controlando el tiempo de ambos estados.

Esto puede ser maravilloso para muchos, ¡claro! “Ya somos programadores expertos, ya podemos encender y apagar un LED” -al menos eso pensé la primera vez que hice mi primer Blink-. Pero estoy seguro que es muy motivador y mágico hacer esto, ya sea en Arduino, AVR, PIC, Beaglebone, Raspberry, o cualquier plataforma de micro controladores y ARM que estemos aprendiendo a usar.

Pero para los que todavía estamos perdidos en el tema nos preguntaremos ¿qué es un LED?, un LED es un diodo emisor de luz que funciona polarizando de forma adecuada sus terminales “ánodo” y “cátodo”. El “ánodo” es la terminal donde se conecta el voltaje positivo y el “cátodo” es la terminal donde se conecta el negativo (Gnd, 0V).

 

led_blink,jpg
led utilizado en la practicca Blink

 

Ya que se tenga identificado las terminales del led, se tendrá que tomar en cuenta otro factor antes de iniciar con el programa, la “corriente”, “tensión” y “resistencia” de consumo de nuestro led.

La “tensión” es el voltaje nominal que necesita el led para funcionar, si se alimenta con una tensión menor a su voltaje nominal el led no encenderá y si se sobrepasa este voltaje es necesario colocar una resistencia para regular su “corriente”.

La “corriente” se puede conseguir con el fabricante, vendedor o con la hoja de datos, la corriente es el consumo energético que tiene el led, esa corriente es para que el led trabaje a su 100% de eficiencia, la corriente se puede limitar usando una resistencia. Ojo si polarizamos un led directo sin utilizar una resistencia, el led consumirá toda la corriente posible hasta llegar a quemarse.

Y con tantos valores de resistencias ¿que valor debo colocar a mi led?.

La “Resistencia” de un dispositivo o de un led se calcula con la ley de ohm, en la cual ya se debiera saber los datos anteriores, tensión con que alimentaremos el led y la corriente que consume.

La formula para calcular la resistencia es la siguiente:

R= V-Vled/I → resistencia=tensión / corriente.

Ejemplo de aplicación con un micro controlador.

La tensión que un micro controlador proporciona por sus puertos es= 5V. Esta seria nuestra tensión.

La corriente nominal de nuestro led es de 15mA (este valor es para un led Rojo difuso).

Con estos datos aplicamos la formula:

R=5V -1.2V/ 0.015 A = 253.33 ohm.

Este valor comercial no existe asi que tendremos que buscar el mas próximo, el cual seria 330 ohm.

Ahora calcularemos la corriente que recibe nuestro led con la nueva resistencia.

I = V / R → I = 5V / 330 ohm = 0.01515 A

Si a 0.015Amp el led trabaja a su 100% entonces a 0.01515 nuestro led sobre pasa su eficiencia lo cual provocará que nuestro led se caliente un poco, pero de ahí no pasa. El led no se quemará.

 

leds_VRI
corriente de cada tipo de led y sus resistencias de acuerdo a su voltaje de alimetnacion, utilizados en la practica blink

 

Ahora que se tiene el conocimiento eléctrico del blink el cual ha sido tedioso si lo vemos matemáticamente, se pasa a lo divertido, a la programación.

El programa de Blink se explicará para Arduino, PIC y AVR

Arduino – Blink

// declaramos una variable y se igualara al numero //del pin donde se conectara el led

//en este caso Arduino tiene un led conectado //directo al pin 13 asi que se ocupara ese para la //prueba

int led = 13;

// se incia la funcion setup en la cual se configurara //los registros de arduino

void setup() {

//se declara el pin de la variable “led” como salida //para hacer Blink utilizando la funcion pinMode

pinMode(led, OUTPUT);

}

// se cierra la función setup y se inicia la función //loop

//la función loop es la que se repetirá durante el //tiempo que el arduino este energizado

void loop() {

// con la funcion ”digitalWrite” se establece el //estado electrico del led “HIGH” = encendido

digitalWrite(led, HIGH);

//con la funcion “delay” se ingresa un retardo en //miliSegundos en el programa

//esto permitira observar el led encendido ese //tiempo

delay(1000);

// con la funcion ”digitalWrite” se establece el //estado electrico del led “LOW” = apagado

digitalWrite(led, LOW);

// se ingresa otro delay para ver el led apagado

delay(1000);

//si se desea que el blink sea mas rapido o lento se //pueden cambiar los tiempos de “delay”

}

 

arduino blink
conexiones de arduino para la practica blink

PIC – Blink

//se importa la biblioteca del micro controlador que //se va a ocupar

#include <16f84a.H>

//se declara la frecuencia a la que trabajara el micro //controlador

#use delay( clock = 4000000 ) // reloj de 4 MHz

void main( void ){

// se declara todo el registro A como salida para //hacer blink

// 0 igual a salida

// 1 igual a entrada

set_tris_a( 0x00 );

//se inicia el ciclo del programa también conocido //como LOOP

while(TRUE){

output_a(0x01); // enciende el led RA0

delay_ms( 1000 ); // retardo de 1seg.

output_a(0X00); // apaga el led

delay_ms( 1000 ); // espera 1 ms

}

 

pic blink
conexiones de pic para la practica blink

 

AVR – Blink

//se declaran las bibliotecas que se ocuparan

#include <avr/io.h> //biblioteca para utilizar las //entradas y salidas de AVR

#include <util/delay.h> //biblioteca para utilizar los //retardos

//se inicia la funcion principal

int main(void)

{

//se configura el registro C como salida para hacer //Blink

// 1 igual a salida

// 0 igual a entrada

DDRC=0xff;

//se inicia el ciclo del programa también conocido //como LOOP

while(1) {

// se enciende el led PC0 o pin 23

PORTC=0x01;

//retardo de 1seg.

_delay_ms(1000);

//se apaga el led del pin PC0 o pin 23

PORTC=0x00;

//retardo de 1seg.

_delay_ms(1000);

}

return 0;

}

 

avr blink
conexiones de avr para la practica blink

 

Visitanos También en Facebook

https://www.facebook.com/GeekbotMexico

Instalación de Driver para Arduino Nano de Geekbot

publicado en: Tutoriales | 0

ArduinoNano de Geekbotelectronics utiliza como interfaz USB el Circuito integrado CP2102 que funciona como convertidor USB a Serial FT232. Esta interfaz permite la comunicación con el ordenador y la programación del ArduinoNano.
Para lograr esta comunicación se tiene que instalar el driver correspondiente.

Se puede descargar el driver desde la página de www.geekbotelectronics.com en producto Arduino Nano o bien dar clic en el siguiente link.

http://www.geekbotelectronics.com/producto/arduino-nano-clon/

y dar un clic en la opción correspondiente ya sea el sistema operativo Linux o Windows.

 

descargar driver

Instalación en Windows

  • Se inicia la descarga del driver para Windows.

descarga_windows

  • Se descomprime el archivo DRI_CP210x_VCP_Windows1 obteniendo la carpeta CP210x_VCP_Windows

  • Se ejecuta la aplicación CP210xVCPInstaller_x64 ó CP210xVCPInstaller_x86 dependiendo de la computadora.

instalacion_windows_1

 

Al abrir el menú de instalación

  • Se dará clic en siguiente.

  • Se aceptara la licencia y se dará en siguiente.

  • En pantalla aparecerá el nombre del Driver
  • Por último se dará clic en finalizar.

instalacion_windows_2

Una vez terminada la instalación se abre el IDE de Arduino para seleccionar la plataforma y ver el nombre del puerto de Arduino Nano.

Se selecciona la plataforma dando un clic en /Herramientas/Tarjeta/ Arduino Nano w/ ATmega328/

instalacion_windows_3

Para ver el puerto COM se tiene que conectar el Arduino Nano, ir a administrador de dispositivos y deslizar la opción de Puertos (COM y LPT) esto nos proporcionara la siguiente leyenda: Silicon Labs CP210x USB to UART Bridge (COMx), siendo x el número del puerto el que se encuentra en el paréntesis.

instalacion_windows_4

Finalmente se selecciona el puerto serial donde esta instalado el Arduino.

instalacion_windows_5

Instalación en Linux

  • Se inicia la descarga del driver para Linux.

linux_1

  • Una vez que se halla descargado el driver, en la carpeta donde se descargó se abrirá la consola y se aplicara el siguiente comando:

chmod +x CP210x_Linux.bin

linux_2

  • Seguido de esto se aplica el siguiente comando:

./CP210x_Linux.bin

linux_3

Esto abrirá el menú de instalación

linux_4

  • Se dará clic en siguiente.

  • Se aceptara la licencia y se dará en siguiente.

  • Se seleccionara una carpeta de instalación o se deja la definida por el sistema y se dará clic en siguiente.

  • Por último se dará clic en instalar.

linux_5

Una vez que halla finalizado la instalación se da clic en el botón DONE.

Es hora de abrir el IDE de arduino para seleccionar la plataforma y ver el nombre del puerto de Arduino Nano.

Se selecciona la plataforma dando un clic en /Herramientas/Tarjeta/ Arduino Nano w/ ATmega328/

para ver el puerto se tiene que ir a /Herramientas/Puerto Serial/dev/ttyUSBx donde la x es el numero de puerto.

BeagleBone con cámara y comunicación con Arduino

publicado en: Tutoriales | 0

En este vídeo se muestra como se puede realizar una fusión entre Beaglebone y Arduino haciendo reconocimiento de imágenes desde una cámara USB y moviendo algunos actuadores (servo motor) desde Arduino. La plataforma Beaglebone utiliza un sistema operativo a 32 Bits (Ubuntu) y el encargado de mover el servo motor y los demás mas actuadores es el Arduino muy popular ya entre los desarrolladores de Hardware, todo esto se logra mediante una comunicación Serial (UART TX y RX) y su respectiva etapa de acoplamiento de tensiones.