Archivo de la etiqueta: atmega

Sensor de nivel de liquido y arduino o pinguino pic


Como estoy metido en un proyecto sobre el control de unos depósitos de agua para la furgoneta vivienda de un amigo mio, me parece interesante hablar aquí de los sensores de nivel de liquido.

Los sensores de nivel de liquido de los que vamos a hablar son de este tipo:

La verdad es que son muy fáciles de usar, ya que cuando están activados puentean los dos cables que traen, así que funcionan como un interruptor. Os dejo las características de los mismos:

El ejemplo que hice para probarlo es muy básico y es el mismo tanto para arduino como para pinguino pic, lo único que cambia son los pines a donde he conectado tanto el sensor como el led de alarma (los podéis ver en el código de pinguino pic), os dejo una imagen del esquema de conexionado:

Aquí podéis ver un vídeo del funcionamiento del sensor (en un improvisado depósito de agua realizado con una botella de refresco):

El código para arduino:

/*Prueba sensor de nivel de liquido*/

int sensor=12;  //Indicamos el pin al que tenemos conectado el sensor de nivel de liquido
int led=11;      //Indicamos el pin al que tenemos conectado el led que indica alarma

void setup()
{                
	//Configuramos los pines correspondientes como entradas o salidas
  pinMode(sensor,INPUT);   //sensor de nivel de liquido
  pinMode(led, OUTPUT); //salida led
}

void loop()
{
  if(digitalRead(sensor)==LOW)
    digitalWrite(led,LOW);
  else
    digitalWrite(led,HIGH);
}

El código para pinguino pic:

/*Prueba sensor de nivel de liquido*/

int sensor=0;  //Indicamos el pin al que tenemos conectado el sensor de nivel de liquido
int led=1;      //Indicamos el pin al que tenemos conectado el led que indica alarma

void setup()
{                
	//Configuramos los pines correspondientes como entradas o salidas
  pinMode(sensor,INPUT);   //sensor de nivel de liquido
  pinMode(led, OUTPUT); //salida led
}

void loop()
{
  if(digitalRead(sensor)==LOW)
    digitalWrite(led,LOW);
  else
    digitalWrite(led,HIGH);
}

Espero que os sirva de ayuda!!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Módulo de Relés


Como en un anterior tutorial hemos visto como usar y montar un circuito de relés para tu arduino/pinguino pic, aquí os dejo un sencillo tutorial para poder conectar módulos de relés que ya se compran montados a nuestros proyectos.

El módulo que voy a emplear es uno muy típico que podéis encontrar por ebay a un precio realmente muy atractivo, se trata de este:

Como podéis ver, en este módulo (que es el que he empleado para el tutorial) trae dos entradas para poder activar dos relés, pero podemos encontrar módulos con más relés e incluso de un solo relé, lo que necesitemos para nuestros proyectos.

Os dejo el esquema de conexión y paso a explicar un poco la conexión para que funcione todo correctamente:

Como podéis ver en la foto del módulo observamos que tenemos dos tiras de pines, una que es en la que esta el jumper, que tiene tres pines y podemos seleccionar alimentar todo el módulo de forma conjunta (es decir seleccionar con el jumper jd-vcc y vcc), o bien alimentar de forma independiente tanto optoacopladores como relés (quitando el jumper), yo he usado la forma de alimentar todo de manera conjunta, ya que me parece la forma más sencillo de hacerlo, así que he dejado el jumper uniendo jd-vcc y vcc. Y la otra tira de pines que es donde nos aparece en el siguiente orden: GND IN1 IN2 VCC, aquí es donde unimos la alimentación con nuestro arduino, es decir, GND del módulo con GND del arduino/pinguino pic, VCC del módulo con 5V del arduino/pinguino pic y las entradas IN1 e IN2 (se activan las bobinas de los relés cuando ponemos a GND dichas entradas) conectados a los pines que deseemos de nuestro arduino/pinguino pic, serán los encargados de activar las bobinas de los relés correspondientes. Como veis es una manera muy sencilla de poder emplear relés en nuestros proyectos sin necesidad de construirnos una pcb para realizar dicha tarea.

Por otro lado tenemos los conectores a los que conectaremos los aparatos eléctricos que queramos activar o desactivar mediante nuestro módulos de relés, como podéis observar en la imagen de arriba, tienen tres conectores cada relé, empezando por abajo observamos en este orden: Conector normalmente cerrado del relé 1 (está activo hasta que se activa la bobina del relé mediante la entrada IN1 poniéndola a LOW), el conector común del relé 1 y el conector normalmente abierto del relé 1 (está desactivado hasta que se activa la bobina del relé mediante la entrada IN1 y permanece activado hasta que se ponga a HIGH dicha entrada).

Os dejo un vídeo de funcionamiento utilizando el módulo con un arduino uno y una bombilla a 220V, donde se apaga/enciende con un intervalo de 5 segundos, empleando el ejemplo blink.

Código:

/*
Ejemplo de encendido/apagado de una bombilla de 220V con un módulo de relés
 */

void setup() 
{                
  // Indicamos el pin que va a activar o desactivar la bobina del relé
  pinMode(13, OUTPUT);     
}

void loop() 
{
  //Ojo las bobinas de los relés se activan cuando a las entradas del módulo tienen GND
  digitalWrite(13, HIGH);   // Desactivamos la bobina del relé
  delay(5000);              // Esperamos 5 segundos
  digitalWrite(13, LOW);    // Activamos la bobina del relé
  delay(5000);              // Esperamos 5 segundos
}

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Relés y Arduino: Encendiendo una bombilla desde tu arduino.


En este nuevo post vamos a hablar de como hacer funcionar un relé con Arduino, en primer lugar necesitamos saber que un relé es un dispositivo que funciona como un interruptor, permitiendo la activación o des-activación de un circuito eléctrico independiente, es decir, podemos activar aparatos electrónicos de mayor voltaje y gran consumo a través de nuestros microcontroladores (como por ejemplo encender una bombilla que funciona a 220V a través de nuestro microcontrolador).

Yo para este tutorial he empleado unos relés de la casa HUI KE que funcionan a 5V y comprados por ebay a un precio muy reducido, en concreto HUI KE HK4100F-DC5V-SHG, os pongo unas imagenes y las conexiones interiores:

Como podéis ver estos relés son de muy reducido tamaño y perfectos para trabajar con nuestro microcontroladores, ya que funcionan a 5V, sin necesidad de disponer de fuentes externas para activar su bobina. Os dejo el esquema de conexión realizado en Fritzing y un esquemático realizado en Eagle:

Como podéis ver los componentes que necesitamos para realizar el circuito de control son muy pocos:

* Relé de 5V (En este caso de la casa HUI KE, vale cualquier otro).
* Transistor BC547.
* Resistencia de 10k.
* Diodo 1N4001.

Como siempre os dejo una foto del montaje del mismo y un vídeo del funcionamiento del circuito, en esta caso la bombilla se enciendo durante un segundo y permanece apagada durante diez segundos:

Y por último os dejo el código (aunque es muy sencillo):

/*Programa realizado por Javier Couto Rego "Regata" para
www.tallerarduino.wordpress.com

Encendiendo una bombilla a 220V con un Arduino y un relé
a 5V*/

int rele=8;

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

void loop()
{
  //Nota tenemos el relé conectado como Normalmente Abierto
  //así solo se activará la carga cuando activemos la bobina
  //del relé, para que funcione al revés cambiaremos el cable
  //a la posición Normalmente Cerrado
  digitalWrite(rele,HIGH);  //Activamos la bobina del relé y encendemos la bombilla
  delay(1000);              //durante 1 segundo
  digitalWrite(rele,LOW);   //Desactivamos la bobina del relé y apagamos la bombilla
  delay(10000);             //durante 10 segundos
}

Espero que os guste y que os sirva de ayuda!!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

led rgb, arduino y processing


Después de ver los videotutoriales de 0xDA_bit sobre Processing, me entró el gusanillo de probar de nuevo este maravilloso software, y decidí hacer el control de un led RGB conectado a Arduino pero modificando sus componentes de color mediante un programa realizado en Processing.

Para realizar dicho cometido me puse a buscar librerias de componentes para añadir a nuestros programas que vayamos realizando en Processing e ir haciendolos más profesionales y más complejos. Dicha librería la podéis descargar desde http://www.mediafire.com/?as8bnrkfk9v8kjf o bien desde la siguiente página web http://www.lagers.org.uk/g4p/.

Os dejo el esquemático de conexión del diodo led RGB a Arduino y también una imagen del software:

Aquí tenéis el video de funcionamiento:

Para el código basta con grabar en el Arduino el ejemplo que trae el IDE de Arduino que está en Firmata y es el StandardFirmata for Uno, y este es el código para processing (acordaros de copiar la librería guicomponents en processing):

//Añadimos las librerias necesarias
import processing.serial.*;
import cc.arduino.*;
import guicomponents.*;

Arduino arduino;
/*Programa simple que crea 3 selectores de color para controlar 
los componentes RGB de un diodo led conectado a Arduino.*/
GKnob knbRed, knbGreen, knbBlue;
int r, g, b; //variables donde guardaremos el valor correspondiente a cada componente de color
int kx, ky;

void setup() {
  size(400, 220);
  arduino = new Arduino(this,  Arduino.list()[2], 57600);  //Creamos el componente para trabajar con Arduino desde el programa 
  //Arriba donde pone Arduino.list()[], el 2 es donde me reconoce a mi el Arduino, puede ser 1 o 0, depende de las cosas conectadas
  //mediante puerto serie virtual
  r = g = b = 160;  //iniciamos cada componente a un valor de 160 (entre 0 y 255)
  arduino.analogWrite(10,r);  //Escribimos dichos valores en los 3 pines asignados para controlar nuestro diodo led RGB
  arduino.analogWrite(9,g);
  arduino.analogWrite(6,b);
  kx = 20;
  ky = 20;
  
  //Creacción y control del programa en processing, viene todo hecho en los ejemplos de la libreria guicomponents
  G4P.setMouseOverEnabled(true);
  G4P.cursor(HAND, CROSS);

  knbRed = new GKnob(this, kx, ky, 150, 150, 270);
  knbRed.setControlMode(GKnob.CTRL_ANGULAR);
  knbRed.setRotArcOnly(true);
  knbRed.setLimits(r, 0, 255);
  knbRed.setNbrTickMarks(9);
  knbRed.localColor = GCScheme.getColor(this, GCScheme.RED_SCHEME);

  knbGreen = new GKnob(this, kx + 8, ky, 150, 270, 20);
  knbGreen.setControlMode(GKnob.CTRL_ANGULAR);
  knbGreen.setRotArcOnly(true);
  knbGreen.setLimits(g, 0, 255);
  knbGreen.setNbrTickMarks(9);
  knbGreen.localColor = GCScheme.getColor(this, GCScheme.GREEN_SCHEME);

  knbBlue = new GKnob(this, kx + 4, ky + 9, 150, 20, 150);
  knbBlue.setControlMode(GKnob.CTRL_ANGULAR);
  knbBlue.setRotArcOnly(true);
  knbBlue.setLimits(b, 0, 255);
  knbBlue.setNbrTickMarks(9);

  stroke(0);
  strokeWeight(3);
  rectMode(CORNERS);
}

void draw() {
  background(220, 220, 255);
  fill(r, g, b);
  rect(kx + 190, 40, width - 40, height - 40);
  fill(0);
  text("Drag mouse in circular movement around the knobs centre", 10, height-10);
}


//En esta función es donde mando el valor pwm al arduino para cada color del led RGB
void handleKnobEvents(GKnob knob) {
  if (knob == knbRed){ 
    r = knob.getValue();
    arduino.analogWrite(10,r);}
  else if (knob == knbGreen){
    g = knob.getValue();
    arduino.analogWrite(9,g);}
  else if (knob == knbBlue){
    b = knob.getValue();
    arduino.analogWrite(6,b);}
}

Espero que os guste!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Programador USBtinyISP


Me ha llegado a casa un programador para micros Atmel que me he pillado por ebay a un precio de 8.50€ gastos de envío incluidos. Aunque se trata de un programador de libre distribución he preferido comprarmelo, 1º por que tenía que hacerme una placa yo y comprarme todos los componentes a parte, así que me iba a costar más dinero que si lo comprará directamente, y 2º porque tendría que hacerme los cables para la conexión con la placa arduino o con cualquier placa que vaya a realizar para futuros proyectos que tengo en mente, ya que lo conecto por icsp y listo para programar desde el IDE de Arduino (la programación la explicaré en el próximo post). Os enseño una foto para que veais lo pequeño que es:

Perdonad por la calidad de la foto, en cuanto tenga la cámara conmigo actualizo el post y cambio la imagen para que se vea mejor.

Os voy a comentar un poco sobre el programador:

Es un grabado que permite la grabación de micros Atmel mediante el puerto USB del ordenador, tanto con progamas como AVRdude, AVRStudio o desde el IDE de Arduino.

Presenta las siguientes partes:

  • Un led rojo que es led de Power. El cual se enciende cuando lo conectamos al puerto USB del ordenador.
  • Un led verde que indica que el programador está ocupado.
  • Un jumper que si lo tenemos puesto alimentamos el micro a programar desde el programador usb (la corriente máxima es de 100mA), y si lo tenemos quitado el micro a programar se tiene que alimentar de una fuente externa.
  • Conector USB para comunicar el programador con el ordenador.
  • Conector ICSP: Conector de 6 pines para la grabación del micro. Es el que normalmente se usará.
  • Conector JTAG: Conector de 10 pines para la grabación mediante JTAG.

Y como siempre os dejo el esquema, el software y los drivers para windows del programador usbtinyisp:

http://www.mediafire.com/?hjub4me0165dd7c

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal