Archivo de la etiqueta: software libre

Montaje Prusa Mendel Iteración 2 paso a paso


Si estáis pensando en iniciar el montaje de vuestra RepRap Prusa Mendel aprovechando la llegada del tiempo estival y con ello el tiempo libre en vuestras vidas estáis de enhorabuena. En uno de los primeros post os adjunte 2 guías de montaje paso a paso para la construcción de vuestra impresora 3D, para aquellos que todo lo visual les es más fácil de asimilar aquí os dejo una serie de videos creados por el maestro de las impresoras 3D, el señor Obijuan!

Estos videos son una serie de tutoriales cortos muy útiles tanto para el montaje de la impresora como para el manejo de los programas necesarios para la utilización de la misma.

Como siempre, sin más, os dejo con los videos y recordar que si tenéis alguna duda, no dudéis en preguntar!

 

Enjoy!

 

1er video:

2º video:

3er video:

4º video:

5º video:

6º video:

7º vieo:

8º video:

9º video:

10º video:

11º video:

12º video:

13º video:

14º video:

15º video:

16º video:

17º video:

18º video:

19º video:

20º video:

21º video:

22º video:

23º video:

24º video:

25º video:

26º video:

27º video:

28º video:

29º video:

30º video:

31º video:

32º video:

33º video:

34º video:

35º video:

36º video:

37º vieo:

38º video:

39º video:

40º video:

41º video:

42º video:

43º video:

44º video:

45º video:

46º video:

47º video:

48º video:

49º video:

50º video:

51º video:

52º video:

53º video:

54º video:

55º video:

56º video:

57º video:

58º video:

59º video:

60º video:

61º video:

62º video:

63º video:

Guía de montaje de la Prusa Iteración 2: http://www.iearobotics.com/wiki/index.php?title=Guia_de_montaje_de_la_Prusa_2

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

Arduino Tutorials Cap 6. I2C Comunication


Muy buenas a todos!

Tras varias semanas sin poder llevar al día la tarea de los videotutoriales, hoy os traigo un nuevo capítulo de la serie “Arduino Tutorials”. En este nuevo tutorial, vamos a tratar el uso de la comunicación I2C, como siempre, lo haremos guiado por un documento y tres casos prácticos que espero os ayuden a entender a la perfección como funciona la comunicación I2C.

Informaos que hasta Junio, aproximadamente, los videotutoriales no tendrán la frecuencia prevista en un principio, uno cada dos semanas, debido a motivos estudiantiles y laborales del equipo. De todas formas, estamos en contacto con vosotros para resolver cualquier duda que podáis tener tanto por twitter, facebook y, como no, desde el propio blog.

Aquí os dejo el link de descarga de los archivos requeridos en el tutorial y el video, como siempre, espero vuestros comentarios, críticas, aportaciones,…

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

Arduino tutorials cap 5. Interrupciones internas


Ya llego el 5º capítulo de la serie “Arduino Tutorials”. Hoy os presento las interrupciones internas, como siempre guiadas con tres ejemplos prácticos enfocados a nuestra placa Arduino UNO.

Este capítulo podríamos consideralo como la continuación del capítulo anterior “Cap 4. Interrupciones externas”, ya que también trata del uso de las interrupciones.

Como siempre, aquí os dejo el link para que podáis descargar los documentos adjuntos en el videotutorial para que podáis probarlos en casa.

Sin más aquí os dejo el video, nos vemos en los próximos tutoriales.

Enjoy!

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

Manual de ayuda Processing


Muy buenas a todos de nuevo!

A falta de dos días, aproximadamente, para que subamos el 2º capítulo de la serie “Processing tutorials”, hemos decidido subir este “Manual de ayuda de Processing” realizado por “Juan María Sarrió García”.

En este documento podréis aprender, prácticamente, la totalidad de las funciones a realizar con la IDE de Porcessing. Descargarlo y leerlo ya que considero que es un manual muy completo que os va ayudar muchísimo y sirve de herramienta para poder entender mejor los videotutoriales.

Sin más, aquí os dejo el link y me voy acabar de subir el video….

 

Enjoy!

 

ProcessingTutorials Cap 1. Introducción Processing/Arduino


Muy buenas a todos de nuevo, tras llegar una semana tarde a la entrega del video tutorial hoy traemos una sorpresa! desde taller arduino, hemos creído oportuno realizar este serie de tutoriales que os presentamos hoy “Processing Tutorials”.

Presentamos este primer capítulo de esta mini serie de videotutoriales en los que queremos introducir a todo el mundo en la IDE de Processing. Processing es un programa basado en la programación JAVA, por lo que recomiendo a todo el mundo antes de usarlo mirase un poco como funciona la programación orientada a objetos, el cual nos va a servir para crear interfaces gráficas para trabajar con Arduino, PICguino, MAPLE, o cualquier otra plataforma gráfica, de hecho lo podemos usar sin la necesidad de usar hardware.

Processing nos aporta un gran número de ventajas, a pesar de tener una interface de usuario tan simple como la de Arduino, de hecho la IDE Arduino está inspirada en IDE Processing, es un programa muy potente que nos permite, tal y como podréis ver el tercer ejemplo de este primer tutorial, nos permitirá realizar ejecutables de los programas que realicemos con él.

Sin más aquí os dejo con el video. Como siempre, aquí os dejo el link para que descarguéis los documentos adjuntos usados en el videotutorial!

Enjoy