Hi good morning, this is another project involving PINGUINO mac and I understand that this is very restrictive, but today with the Hackintosh anyone can have a MAC OSX, I say this from me experience.
This is a very basic application that controls both the digital and the analog gates of a PINGUINO 18fx550, whether we use the serial port option as USB with CDC,and also with the bluetooth module tested in previous posts.

Need two parts, a program for MAC,

DOWNLOAD LINK

and the second a code for the PINGUINO,this code is very comprehensive and provides for communications from any platform, works like code, with two digits (by now we do not need more ), the first digit identifies the door and the second the treatment, to the digital port identifies a 0=LOW and 1=HIGH, but for analog ports I have decided that 3 may give the reading order.
So if we want to read analog port 13 which correspond to “AN0″ and we would execute “03″ us back the digital value between 0 and 1023 of this port.
In the other hand we want to raise the output of the digital port “0″ then we send to turn ON “01″ and “00″ to turn OFF.
Sounds complicate but it is understood when applied
If you want a help, we will sent “9″ with any other number, it returns a help.

/*Project IPHONE, IPAD & MAC talk with PINGUINO walii.es*/
//You need send number port 0 to 7 and status 0 or 1
//for anoalogic port you will check port an0 to an7 and need set status in 3
//for help you need set 9 in the value0
#define LENGTH 3
#define RUNLED PORTAbits.RA4
int rxBuffer[16];
int rxIndex = 0;
int i,value1,value0,value,value0a;
void setup() {
 Serial.begin(9600);
 for (i=0;i<8;i++) { //servos conections
 pinMode(i,OUTPUT);
 digitalWrite(i,LOW); // fixe un niveau 0 sur les sorties
 }
}

void loop (){
 if (Serial.available() > 0) {
//if(rxIndex==0) Serial.printf("Captured first value \n\r");
//if(rxIndex==1) Serial.printf("Captured Second value \n\r");
 rxBuffer[rxIndex]=Serial.read();
rxIndex=rxIndex+1;
 if(rxIndex==LENGTH){
 value0=rxBuffer[0]-48;
 value0a=rxBuffer[0]-35;
 value1=rxBuffer[1]-48;
 if(value1<2)
 {
 Serial.printf("Port: %d,",value0);
 Serial.printf("Status: %d\n\r",value1);
 if( value1==0 ) {
 digitalWrite(value0,LOW);
 } else if (value1==1) {
 digitalWrite(value0,HIGH);
 }
 }
 if(value1==3){
 value=analogRead(value0a);
 Serial.printf("Reading port %d -> An%d value= %d\n\r",value0a,value0,value);
 }
 if(value0==9) Serial.printf("You need send number port 0 to 7 and status 0 or 1\n\r for analogic port you will check port an0 to an7 \n\r and need set status in 3 for help you need set 9 in the value0\r\n");
 rxIndex = 0;
 //if (rxIndex==0) Serial.printf("Waiting ...\n\r");
}

}
 delay(10);
}

Este video es solo una explicación de como debería funcionar PINGUINO en LION, ya que existen diferencias entre la versión de windows y la de mAC.

Tras un largo tiempo de inactividad por diversos proyectos externos a PINGUINO, vuelvo a escribir y ofrecer un aporte que creo puede ayudar a mas de uno… lo que tengo para ofrecer para el bolso de la dama y el bolsillo del caballero es: La versión modificada de PINGUINO GUI 9.05 para ser usada en LION sin necesidad de VMware o Parallel (emuladores de windows).

Esta versión tiene unas librerías nuevas, compiladas  y modificadas para esta versión de LION sin soporte para POWER PC que era en esencia el problema que aparecia en la versión anterior, solo tienen que

1º Crear un nuevo directorio.

2ºPoner el archivo ZIP

3º Descomprimirlo

Luego ya pueden traer sus proyectos a esta nueva versión, cuidado cuando lo descompriman recuerden que MAC sobreescribe las carpeta, asi que si tienen algo debajo seguro se sobre escriba asi que hagan backup de sus proyectos.

el archivo está compartido en fileserver.

LINK    http://www.fileserve.com/file/9jGaMjU/PinguinoBeta905MacLion.zip

Nuevo LINK http://pinguino.walii.es/download/PinguinoBeta905MacLion.zip

Os pongo una captura de mi version funcional.

Cualquier problema me lo dicen y lo vemos puntualmente lo he probado con PYTHON 2.5.4, 2.5.5, 2.6.6 y 2.6.7. Aun no lo he probado en 2.7, pero siempre os recomiendo tener la version ante ultima de cualquier software…

saludos.

Esta es una entrada de pruebas para verificar el funcionamiento del carro de compras recién implantado.

El producto puede ser un microcontrolador PIC 18f4550 programado con el firmware pinguino.

Hoy os mostrare como controlar un coche a radio control pero via bluetooth y ayudando me con PINGUINO.
La idea viene a rais de un MINI controlado por Android que venden en algunas tiendas y pensé, que sería facil de reproducir.

El control es basico pero he puesto un detalle muy interesante, ya que la dirección de este vehículo es exponencial ya que puedes indicarle que gire X grados (a diferencia de los coches de radio control tradicionales que son TOPE IZQUIERDA o TOPE DERECHA), para poder controlarlo finamente he puesto un servo para dirigirlo como si de un conductor se tratase, este puede girar la dirección tantos grados como le indiquemos, ahora en el ejemplo lo he puesto en máximos de ambos extremos, pero fácilmente puede indicarse que gire a la izquierda X grados.

El motor principal es controlado por un PUENTE H basico con BC548, y el pinguino es el tradicional 8bits 18f4550, el modulo bluetooth es el mismo que vengo utilizando en anteriores circuitos y facilmente comprable a traves de EBAY.

La comunicación bluetooth la realizo con un ordenador MAC, pero puede realizarse con cualquier equipo o distribución ya que utiliza los protocolos RS232 sobre Bluetooth, generando una interfaz serie virtual en el equipo cliente.

Tambien el código de PROCESSING es muy fácil y conciso, exportable a java para ser reproducido en cualquier ordenador.
Dejo el código fuente para que cada uno lo reproduzca en su PC de casa sea cual sea la distribución.

Este es el código de PINGUINO

// PCBC v1
// Pinguino Car Bluetooth Control v1
// Walii.es 2011
// pinguino.walii.es
#define RUNLED PORTAbits.RA4
#define PIC18F4550                // control pin of servo
int counter;                    // counter used for interrupt
int position0=50;                //pin0 servo vertical
int previous;
int i;
int key;
int pulseWidth = 20;
void setup()
{
T1CON=0x01;                    // configure timer 1
PIE1bits.TMR1IE=1;                // set interrupt for timer 1
INTCON|=0xA0;                    // enable GIE and PEIE
for (i=1;i<8;i++)     {             //servos conections
pinMode(i,OUTPUT);
digitalWrite(i,LOW);			// fixe un niveau 0 sur les sorties

}
pinMode(0,OUTPUT);
Serial.begin(9600);
}
void UserInterrupt()
{
if (PIR1bits.TMR1IF)
{
TMR1H=0xFF;                // reload value timer 1
TMR1L=0x9C;
PIR1bits.TMR1IF=0;            // clear interrupt flag
if (counter>position0+51) PORTBbits.RB0=0; // position
else PORTBbits.RB0=1;
if (counter==1500) counter=0;    // value for ~20 mS
counter++;
}
}

void stop()
{
	digitalWrite(2,LOW);
	digitalWrite(1,LOW);
	delay(10);
}
void stoptotal()
{
	digitalWrite(2,LOW);
	digitalWrite(1,LOW);
	position0=50;
	delay(10);
}
void w()
{
	digitalWrite(2,HIGH);
	digitalWrite(1,LOW);
}
void s()
{
	digitalWrite(2,LOW);
	digitalWrite(1,HIGH);
}
void a()
{
position0=10;
}
void d()
{
position0=80;
}
void q()
{
position0=10;
digitalWrite(2,HIGH);
digitalWrite(1,LOW);
}
void e()
{
position0=80;
digitalWrite(2,HIGH);
digitalWrite(1,LOW);
}
void z()
{
position0=80;
digitalWrite(2,LOW);
digitalWrite(1,HIGH);
}
void c()
{
position0=10;
digitalWrite(2,LOW);
digitalWrite(1,HIGH);
}

void loop()
{
if (Serial.available())
    {
key=Serial.read();
if (key=='w' && previous!='w') stop(),w();
if (key=='s' && previous!='s') stop(),s();
if (key=='a' && previous!='a') stop(),a();
if (key=='d' && previous!='d') stop(),d();
if (key=='q' && previous!='q') stop(),q();
if (key=='e' && previous!='e') stop(),e();
if (key=='z' && previous!='z') stop(),z();
if (key=='c' && previous!='c') stop(),c();
previous=key;
} else; stoptotal();
Serial.printf(" %d", position0);
}

y Este es el código de processing

/**
PINGUINO CAR CONTROL via BLUETOOTH
Walii & walterleonardo
Pinguino.walii.es
*/
import processing.serial.*;
Serial myPort;
String port[];
int i;

final static int NORTH = 1;
final static int EAST = 2;
final static int SOUTH = 4;
final static int WEST = 8;
final static int STOP = 16;
int result;
float x,y;

void setup() {
  size(512,400);
  frameRate(30);
  result = 0;
  x = width/2;
  y = height/2;
 port=Serial.list();
println(port);
myPort=new Serial(this,port[10],9600);
}

void draw() {
  background(0);
  switch(result) {
    case NORTH: myPort.write("w"); break;
    case EAST: myPort.write("d"); break;
    case SOUTH: myPort.write("s"); break;
    case WEST: myPort.write("a"); break;
    case NORTH|EAST: myPort.write("e"); break;
    case NORTH|WEST: myPort.write("q"); break;
    case SOUTH|EAST: myPort.write("c"); break;
    case SOUTH|WEST: myPort.write("z"); break;
    case STOP: myPort.write("x"); break;
  }
  fill(255);
  rect(x,y,10,10);
}

void keyPressed(){
  switch(key) {
    case('w'):case('W'):result |=NORTH;break;
    case('d'):case('D'):result |=EAST;break;
    case('s'):case('S'):result |=SOUTH;break;
    case('a'):case('A'):result |=WEST;break;
    case('x'):case('X'):result |=STOP;break;
  }
}

void keyReleased(){
  switch(key) {
    case('w'):case('W'):result ^=NORTH;break;
    case('d'):case('D'):result ^=EAST;break;
    case('s'):case('S'):result ^=SOUTH;break;
    case('a'):case('A'):result ^=WEST;break;
    case('x'):case('X'):result ^=STOP;break;
//    case('w'):case('W'):result |=STOP;break;
//    case('d'):case('D'):result |=STOP;break;
//    case('s'):case('S'):result |=STOP;break;
//    case('a'):case('A'):result |=STOP;break;
  }
}

Gracias a la idea de JEAN, y tras el pedido de varias personas que dicen que no entienden el post en ingles… intentaré poner todos los datos para que se puedan seguir y llegar a buen puerto de una forma amena y simple.

lo primero que debemos tener en cuenta es que yo trabajo principalmente con el pic 18f4550… pero tiene que funcionar con el 18f2550.

Teniendo en cuenta que el circuito utilizado y la identificación de PINES es la siguiente.

Equipo grabador, un Pinguino estandart.

el segundo es el circuito del pinguino a grabar, obviamente puede ser un zocalo de, quita y pon, así podremos programar muchos pics.

Los números de pines concuerdan con la imagen superior, dirán ¿porque este orden? y tiene una respuesta muy simple, ya que todo el proyecto viene de mucho mas atrás, y para una consistencia en la identificación de puertas, el PIN1 es por defecto el RB0 sin importar el pin físico donde se encuentre.

El programa que utilizaremos es el siguiente, compilado en la version de IDE 9.05, no muestra indicios de errores y funciona muy bien, digo esto porque si lo compilamos en otra versión de IDE pueden aparecernos problemas.

// This is a tool to program the pinguino bootloader in a new chip
// with your Pinguino, the self replicating machine !!
// Jean-Pierre MANDON 2010
// Fixed bug 02/07/2011 PGM pin is no longer used

#define PGC 1		// connected to the PGC pin of the blank chip
#define PGD 2		// connected to the PGD pin of the blank chip
#define VPP 3		// connected to the VPP pin of the blank chip
#define VCC 6		// connected to the power on transistor
#define redled	 5

uchar bulkerase[48] ={0x00,0x3C,0x0E,0x00,0xF8,0x6E,0x00,0x00,0x0E,0x00,0xF7,0x6E,0x00,0x05,0x0E,0x00,
                      0xF6,0x6E,0x0C,0x3F,0x3F,0x00,0x3C,0x0E,0x00,0xF8,0x6E,0x00,0x00,0x0E,0x00,0xF7,
		              0x6E,0x00,0x04,0x0E,0x00,0xF6,0x6E,0x0C,0x8F,0x8F,0x00,0x00,0x00,0x00,0x00,0x00};

uchar startwrite[24]={0x00,0xA6,0x8E,0x00,0xA6,0x9C,0x00,0x00,0x0E,0x00,0xF8,0x6E,0x00,0x00,0x0E,0x00,
					  0xF7,0x6E,0x00,0x00,0x0E,0x00,0xF6,0x6E};

uchar startwrid[24] ={0x00,0xA6,0x8E,0x00,0xA6,0x8C,0x00,0x30,0x0E,0x00,0xF8,0x6E,0x00,0x00,0x0E,0x00,
					  0xF7,0x6E,0x00,0x00,0x0E,0x00,0xF6,0x6E};
uchar checkmem[32];
uint address=0;

#define pic_on()  digitalWrite(VCC,LOW)
#define pic_off() digitalWrite(VCC,HIGH)

// begin programming mode
// power is on ( VCC and Programing voltage )

void start_pgm()
{
	digitalWrite(VPP,HIGH);
	delayMicroseconds(4);
}

// end programming mode
// power is on ( VCC and Programing voltage )

void stop_pgm()
{
	digitalWrite(PGD,LOW);
	digitalWrite(PGC,LOW);
	digitalWrite(VPP,LOW);
}

// send a command to the chip
// SPI soft

void send_command(uchar command,uchar lowbyte,uchar highbyte)
{
	unsigned char i;
	for (i=0;i<4;i++)
		{
		digitalWrite(PGC,HIGH);
		if ((command&1)==1) digitalWrite(PGD,HIGH);
		else digitalWrite(PGD,LOW);
		digitalWrite(PGC,LOW);
		command=command>>1;
		}
	for (i=0;i<8;i++)
		{
		digitalWrite(PGC,HIGH);
		if ((lowbyte&1)==1) digitalWrite(PGD,HIGH);
		else digitalWrite(PGD,LOW);
		digitalWrite(PGC,LOW);
		lowbyte=lowbyte>>1;
		}
	for (i=0;i<8;i++)
		{
		digitalWrite(PGC,HIGH);
		if ((highbyte&1)==1) digitalWrite(PGD,HIGH);
		else digitalWrite(PGD,LOW);
		digitalWrite(PGC,LOW);
		highbyte=highbyte>>1;
		}
digitalWrite(PGC,LOW);
digitalWrite(PGD,LOW);
}

// special end of command write
// DS39622K Page 20 figure 3.5 (Flash Microcontroller Programming Specification)

void end_writecmd()
{
unsigned char i;
digitalWrite(PGD,LOW);
for (i=0;i<3;i++)
	{
	digitalWrite(PGC,HIGH);
	digitalWrite(PGC,LOW);
	}
digitalWrite(PGC,HIGH);
delay(6);
digitalWrite(PGC,LOW);
delayMicroseconds(500);
for (i=0;i<8;i++)
	{
	digitalWrite(PGC,HIGH);
	digitalWrite(PGC,LOW);
	}
for (i=0;i<8;i++)
	{
	digitalWrite(PGC,HIGH);
	digitalWrite(PGC,LOW);
	}
}	

// Read Flash memory
// Pinguino examples Flash folder

uint ReadFlash(uint address)
{
uchar high8,low8;
TBLPTRU=0;
TBLPTRH=address>>8;
TBLPTRL=address;
__asm tblrd*+ __endasm;
low8=TABLAT;
__asm tblrd*+ __endasm;
high8=TABLAT;
return((high8<<8)+low8);
}

//-----------------------------------------------------------
// begining of the main loop
//-----------------------------------------------------------

void setup()
{
pinMode(PGC,OUTPUT);
digitalWrite(PGC,LOW);
pinMode(PGD,OUTPUT);
digitalWrite(PGD,LOW);
pinMode(VPP,OUTPUT);
digitalWrite(VPP,LOW);
pinMode(redled,OUTPUT);
digitalWrite(redled,LOW);
pinMode(VCC,OUTPUT);
digitalWrite(VCC,HIGH);
}

void loop()
{
int i;

// erase chip

pic_on();
delay(20);
start_pgm();
digitalWrite(redled,HIGH);
delay(10);
for (i=0;i<48;i+=3) send_command(bulkerase[i],bulkerase[i+1],bulkerase[i+2]);
delay(100);
stop_pgm();
delay(20);
pic_off();
delay(1000);

// read bootloader and write it

pic_on();
delay(1000);
start_pgm();
delay(10);
for (i=0;i<24;i+=3) send_command(startwrite[i],startwrite[i+1],startwrite[i+2]);
while (address<0x1FDF)
	{
	for (i=0;i<32;i++) checkmem[i]=ReadFlash(address+i);
	for (i=0;i<30;i+=2) send_command(0b00001101,checkmem[i],checkmem[i+1]);
	send_command(0b00001110,checkmem[30],checkmem[31]);
	end_writecmd();
	address+=32;
	digitalWrite(redled,digitalRead(redled)^1);
	delay(4);
	}
digitalWrite(redled,HIGH);
for (i=0;i<32;i++) checkmem[i]=ReadFlash(address+i);
for (i=0;i<48;i+=3) send_command(startwrite[i],startwrite[i+1],startwrite[i+2]);
for (i=0;i<30;i+=2) send_command(0b00001101,checkmem[i],checkmem[i+1]);
send_command(0b00001111,checkmem[30],checkmem[31]);
end_writecmd();

// ---------- end copying bootloader

// programing configuration bits

for (i=0;i<24;i+=3) send_command(startwrid[i],startwrid[i+1],startwrid[i+2]);
send_command(0b00001111,0x24,0x24);
end_writecmd();
send_command(0,0x01,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x0E,0x0E);
end_writecmd();
send_command(0,0x02,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x3F,0x3F);
end_writecmd();
send_command(0,0x03,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x1E,0x1E);
end_writecmd();
send_command(0,0x05,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x81,0x81);
end_writecmd();
send_command(0,0x06,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x81,0x81);
end_writecmd();
send_command(0,0x08,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x0F,0x0F);
end_writecmd();
send_command(0,0x09,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0xC0,0xC0);
end_writecmd();
send_command(0,0x0A,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x0F,0x0F);
end_writecmd();
send_command(0,0x0B,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0xA0,0xA0);
end_writecmd();
send_command(0,0x0C,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x0F,0x0F);
end_writecmd();
send_command(0,0x0D,0x0E);
send_command(0,0xF6,0x6E);
send_command(0b00001111,0x40,0x40);
end_writecmd();

// ---------- end configuration bits

stop_pgm();
pic_off();

digitalWrite(redled,LOW);

while(1);
}

y lo siguiente es fácil, programaremos el PIC grabador, la imagen nº1, el chip a programar no necesita tener nada… puede ser tal cual viene de fabrica.

Un diseño facil pero muy útil, para probar nuestros servos, y verificar el recorrido de cada uno.

Las conexiones son simples: el servo conectado a la salida 0(cero) RB0

Y el potenciometro de mas de 47k entre positivo y negativo y el centro a la puerta 13…

He incluido dos codigos, uno con la libreria de servo, y otro de la forma tradicional sin libreria.

Con libreria de servos
// Control de servo tradicional con libreria
// Walii.es 2011
//Pinguino.walii.es
//   +-----+
//   |servo|--------- PWM Servo control ---> to pinguino pin.
//   |     |--------- +5V
//   |  o  |--------- GND
//   |     |
//   +-----+

uchar position=1;
int i;
void setup(void)
{
servo.attach(0);
}

void loop(void)
{
i=analogRead(13);
position=i/4;
servo.write(0,position);
delay(100);
}

 Sin libreria de servo, pueden observar que el recorrido es mucho mayor que con la librería, esto es porque de esta forma no tenemos un limite preestablecido en él tamaño de pulso. Y si nos pasamos con esto, puede generar un reset por consumo elevado en el PINGUINO.
// Control de servo tradicional sin libreria
// Walii.es 2011
//Pinguino.walii.es
#define RUNLED PORTAbits.RA4
#define PIC18F4550                // control pin of servo
int counter;                    // counter used for interrupt
int position0;                //pin0 servo vertical
int ir0;//pin 13
int i;
int pulseWidth = 20;
void setup()
{
T1CON=0x01;                    // configure timer 1
PIE1bits.TMR1IE=1;                // set interrupt for timer 1
INTCON|=0xA0;                    // enable GIE and PEIE
pinMode(0,OUTPUT);
Serial.begin(9600);
}
//Con la siguiente rutina controlamos la señal al servo RB0.
//Leemos en cada pasada el valor de position0
void UserInterrupt()
{
if (PIR1bits.TMR1IF)
{
TMR1H=0xFF;                // reload value timer 1
TMR1L=0x9C;
PIR1bits.TMR1IF=0;            // clear interrupt flag
if (counter>position0+51) PORTBbits.RB0=0; // position
else PORTBbits.RB0=1;
if (counter==1500) counter=0;    // value for ~20 mS
counter++;
}
}

void loop()
{
ir0=analogRead(13);
position0=ir0/6;
if (position0<1) position0=1; if (position0>151) position0=151;

}

Aqui algunas capturas mas con relación al funcionamiento del intervalometro.

Hace un par de noches hemos gozado de unas muy bonitas tormentas eléctricas, y he intentado capturar algunas fotos con el invento hecho algunos post detras.
POST INTERVALOMETRO PINGUINO

Capturas:

Hoy les traigo el ultimo artilugio que se me ha ocurrido, ya que ayer mi mujer ha retado a mi niña por dejar la puerta abierta de la nevera, y se me paso por la cabeza “porque nadie ha hecho algo tan practico como un avisador de puerta abierta?” quizas ya lo hay pero la version de frigo que tengo doy gracias que aun enfria…

Y basicamente el cacharro es esto:

un sensor de luz que detecta y promedia el primer valor que coje, y lo guarda como referencia, entonces cuando abrimos la puerta detecta que la incidencia de luz es mayor y comienza el juego, dejando un tiempo prudencial de espera (en este caso 10 segundos me pareció correcto) si la puerta no se ha cerrado dispara una alarma sonora  hasta que dicha puerta no es cerrada, comenzando nuevamente el ciclo.

algo basico pero que no tengo entendido que existiese.

aqui os dejo unas fotos, videos y el código, no he pensado poner el circuito ya que tiene muy poco, creado a partir del 18f2550, y con un buzz conectado al sensor 12 y un LDR en el 13… no tiene mas que eso.

El codigo:

// Alarma de Nevera
// Walter López Pascual (Walii & Walterleonardo) 2011 walii.es

int led1,LDR,MLDR,valor,ovalor;			// Values like integers ( Pin )
int mldr[];						// Array for measures
int debug=0;						// Only with debug "1" we´ll see printed values in serial
int wait=10000;						// Time to wait before BUZZ in MS

promedioldr ()
{
int i;
MLDR=0;
for (i=0;i<9;i++){
mldr[i]=analogRead(LDR);
MLDR=MLDR+mldr[i];
}
MLDR=MLDR/10;
return MLDR;
}

void setup()
{
	led1=11;					// led 1 is connected on pin 1
	LDR=13;
	pinMode(led1,OUTPUT);		// BUZZ & LED
	ovalor=promedioldr();		// Capture initial value to measure
	Serial.begin(9600);
}

void encenderledbuzz ()				//BUZZ & LED active action
{
digitalWrite(led1,HIGH);
delay(250);
digitalWrite(led1,LOW);
delay(250);
}

void esperar ()					//wait time before BUZZ
{
if (debug==1){
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...\r\n");
	delay(wait/10);
	Serial.printf("Wait...BUZZ\r\n");
}
else delay(wait);
}

void loop()
{
valor=promedioldr();
if (valor>=ovalor+100){
	esperar();
	while (analogRead(LDR)>=ovalor+100){
	encenderledbuzz();
	if (debug==1) Serial.printf("Analog Value = %d \r\n", analogRead(LDR));
	}
}
if (debug==1) Serial.printf("Actual LDR value= %d / Previous LDR value= %u\r\n", valor, ovalor);
digitalWrite(led1,LOW);
}

Ya existe un sistema para medir la aceleración y movimiento que tienen las palas de pádel. He encontrado un curioso video donde nos explican cómo han implementado el sistema y en qué consiste.!!!

http://www.padelbarcelona.es/padel/sensor-de-aceleracion-y-movimiento-de-palas-de-padel.html

Bueno hoy al fin pude terminar el proyecto bluetooth, lo tengo parado hace un par de semanas porque estoy en medio de un curso de Manager de Proyectos y otro de Ingles… pero al fin, he podido…

Basicamente estaba intentando dejar de lado XBEE para la comunicación in-alambrica, ya que esos módulos son un poco caros…entre 40 y 60 euros… ahora con los módulos bluetooth que se pueden conseguir por 20euros… puedo hacer todas los proyectos que quiera, además de no necesitar un receptor especial, ya que con cualquier ordenador o PDA con bluetooth, puedo comunicarme tranquilamente.

Aquí un video del funcionamiento.

La idea principal es modificar el Paddle Sensor con uno de estos modulos así consume memos, entre unos 50 a 100mA, a maxima potencia. Adicionalmente otra de las ventajas es la comunicación RS232 UART bi direccional, la cual puede llegar a casi un Mega de transferencia. Aunque la distancia se reduce a 20 metros sin obstáculos y 5 con obstáculos.

Lo primero es el esquema de este adaptador bluetooth.

Con un simple LM 317 y un preset de 5K en su Adj puedes tener un regulador de 3.3Volts 1 Amp…

Básicamente conectamos directamente el módulo BLUETOOTH en nuestra placa PINGUINO… sin nada de intermediario y se entenderán perfectamente, ya que la placa PINGUINO posee unas resistencias de acople que ayudan al dialogo correcto.

El codigo es simple. Escribo como si fuese un puerto serie normalito… y espero respuestas… en este caso, mido la temperatura y la luminosidad mediante entradas analógicas, y como punto adicional, controlo un LED colocado en el puerto 0. Todo esto con retroalimentación a la consola serie.

// Bluetooth comunication v 1
// Walter López (walterleonardo & walii) 2011 pinguino.walii.es

char *string = "Hola mundo bluetooth!!! estoy vivo... soy pinguino";
#define LM35 18
#define LDR 17
#define LED 0

int i=0;

temp(){
int aux=0,buffer[10];
for (i=0;i<9;i++){
buffer[i]=analogRead(LM35);
aux = aux + buffer[i];
}
aux = (aux / 10);
aux = aux/2;
return aux;
}

light(){
int aux=0,buffer[10];
for (i=0;i<9;i++){
buffer[i]=analogRead(LDR);
aux = aux + buffer[i];
}
aux = (aux / 10);
aux = (aux-23)/10;
aux = 100-aux;
return aux;
}

void setup()
{
	Serial.begin(9600);
	pinMode(LED,OUTPUT);
	digitalWrite(LED,LOW);
	Serial.printf("\r\n");
	Serial.printf("****************************************\r\n");
	Serial.printf("*** PRUEBA de comunicacion BLUETOOTH ***\r\n");
	Serial.printf("****************************************\r\n");
	Serial.printf("\r\n");
}
void loop()
{
u8 c;
	Serial.printf("****** %s\r\n", string);
		Serial.printf("\r\n");
			Serial.printf("\r\n");
	Serial.printf("Press t key to receive the temperature ...\r\n");
	Serial.printf("Press l key to receive the Light level ...\r\n");
	Serial.printf("Press x key to change the LED status ...\r\n");
c = Serial.getkey();
Serial.printf("=========================================\r\n");
if (c == 116) Serial.printf("Temperature = %u degrees Celsius\n\r" , temp());
if (c == 108) Serial.printf("Light = %u Percentage\n\r" , light());
if (c == 120) digitalWrite(LED,(digitalRead(LED)^1)), Serial.printf("Changed LED Status \n\r");
Serial.printf("=========================================\r\n");
	Serial.printf("\r\n");

}

Aquí dejo los planos minimos de los dos modelos actuales de PINGUINO… 18f2550 y 18f4550… como verán no necesitan de mucho para funcionar. Pero es necesario saber siempre el numero de PIN a configurar.

18f2550 (si le dan click se hace mas grande)

18f4550 (lo mismo, si le hacen click se hace mas grande)

Siempre me vuelvo loco buscando… y siempre termino con el oraculo (google) por eso he decidido poner aquí las cosas necesarias, siempre que necesiten algo de info, busquen en la Categoría de UTILIDADES.

Tabla de conversión de caracteres ASCII

Hola nuevamente, aunque este es un proyecto vendido a un cliente, por eso no puedo poner los archivos fuente, me interesa compartirlo con vosotros ya que lleva la tecnología pinguino dentro.

Utilizando un sensor de aceleración y movimiento de 5Gs y colocando este en una pala, he podido crear todo el entorno para poder visualizar y grabar (para un posterior análisis) todas los datos de un jugador de padel, fuerza, direccionalidad, firmeza, etc. Capturando toda la información con pinguino, y transfiriendo a un ordenador con un sistema creado con processing…(java en sus entrañas)… y así poder analizar y realizar un TUNNING mas exacto en el tipo de juego de una persona. Algo así como llevar un juego analógico al ámbito digital.

Aqui está el video donde explico que hace el cacharro…

Saludos.

Hola a todos… perdón el titulo en ingles… pero suena como mas importante… ya que para mi este es un invento muy útil… porque ultima-mente estuve tonteando con la reflex y quería hacer un poco de timelapse… y la cámara por si sola no lo hace… necesitando un ordenador conectado… entonces me puse a pensar “pero solo un poquito porque el medico me dijo que no hiciese esfuerzos…  :-) “, y se me ocurrió reutilizar un par de cosillas que tenia en el cajon de los inventos viejos… y me hice este invento… bueno invento no es… porque ya existen… pero por lo menos me he ahorrado unas cuantas pelas.

Este es un prototipo, pero ya estoy construyendo para vender, si alguien esta interesado, solo tiene que contactarme.

El diseño electrónico es simple… por eso solo me decantaré por mostrar el programa.

/*
 * Reflex control timelapse &  long exposure.
 * By Walter López Pascual (Walii & walterleonardo)
 * Pins, Schematics and more info:
 * http://pinguino.walii.es
 */

// Comment line above if you using a pinguino with PIC18F2550.
#define PIC18F4550

#define BOTON1 4
#define BOTON2 5
#define BOTON3 6
#define BOTON4 7
#define BOTON5 10
#define SHOT 28
#define LDR 13
#define VREF 14
#define VMON 15
#define LED 23
#define BUZZ 22
#define LCD 21

//global vars
uchar counter = 0;
int tiempo=0;
int segundos=0;
int i;
int cantidad=1;
int contador=0;
float num;
int pausa;
int cuenta;
int encendida=0;
float oldr,ldr;
float intermedio[];
int ldractivado=0;

void lecturaoldr()
{
for (i=0;i<10;i++)
{
intermedio[i]=analogRead(LDR);
oldr=oldr+intermedio[i];
}
oldr=oldr/10;
}

void lecturaldr()
{
for (i=0;i<10;i++)
{
intermedio[i]=analogRead(LDR);
ldr=ldr+intermedio[i];
}
ldr=ldr/10;
}

void setup(){
	//8 bits mode
	//lcd(8, 9, 0, 1, 2, 3, 4, 5, 6, 7); // RS, E, D0 ~ D7

	//4 bits mode, dont use last four pins ...
	lcd(8, 9, 0, 1, 2, 3, 0, 0, 0, 0); // RS, E, D4 ~ D8

	//LCD format
	lcd.begin(3, 0);

	/* Debug */
	pinMode(BOTON1, INPUT);		// LED on pin 13
	digitalWrite( BOTON1,LOW);
	pinMode(BOTON2, INPUT);		// LED on pin 13
	digitalWrite( BOTON2,LOW);
	pinMode(BOTON3, INPUT);		// LED on pin 13
	digitalWrite( BOTON3,LOW);
	pinMode(BOTON4, INPUT);		// LED on pin 13
	digitalWrite( BOTON4,LOW);
	pinMode(BOTON5, INPUT);		// LED on pin 13
	digitalWrite( BOTON5,LOW);
	pinMode(SHOT, INPUT);		// LED on pin 13
	digitalWrite( SHOT,LOW);
	pinMode(LED,OUTPUT);		// LED on pin 13
	digitalWrite( LED,LOW);
	pinMode(BUZZ,OUTPUT);		// LED on pin 13
	digitalWrite( BUZZ,LOW);
	pinMode(LCD,OUTPUT);		// LED on pin 13
	digitalWrite( LCD,LOW);
	lecturaoldr();
}

void dispara(int pausa)
{
tono1();
digitalWrite(LED,HIGH);
delay(pausa);
digitalWrite(LED,LOW);
}

void longexpo()
{
_millis = 0;
while (millis()<=5000)
{
segundos=millis()/1000;
lcd.setCursor(0, 2);
lcd.print("Start-time in  ");
lcd.printNumber(5-segundos,10);
lcd.print("   ");
lcd.setCursor(0, 3);
lcd.print("                    ");
}

contador=1;
while (contador<=cantidad)
{
_millis = 0;
tono2();
	while (millis()<=tiempo*1000)
	{
	digitalWrite(LED,HIGH);
lcd.setCursor(0, 2);
lcd.print("Time to End ");
segundos=millis()/1000;
lcd.printNumber(tiempo-segundos,10);
lcd.print("   ");
lcd.setCursor(0, 3);
lcd.print("Shot to End ");
lcd.printNumber(cantidad-contador,10);
	}
digitalWrite(LED,LOW);
lcd.setCursor(0, 2);
lcd.print("Time to End ");
lcd.printNumber(0,10);
lcd.print("   ");
lcd.setCursor(0, 3);
lcd.print("Shot to End ");
lcd.printNumber(cantidad-contador,10);
delay(2000);
contador++;
}

}

void timelapse()
{
_millis = 0;
contador=1;
while (contador<=cantidad)
{
lcd.setCursor(0, 2);
lcd.print("ShotN ");
lcd.printNumber(cantidad-contador+1,10);
lcd.print(" Wtime ");
lcd.printNumber(tiempo,10);
lcd.setCursor(0, 3);
segundos=millis()/1000;
lcd.print("   Working ...      ");

while (segundos!=tiempo)
{
segundos=millis()/1000;
digitalWrite(LED,LOW);
}
dispara(1000);
_millis = 0;
contador++;

}

}

void tono1()
{
digitalWrite(BUZZ,HIGH);
delay(200);
digitalWrite(BUZZ,LOW);
}

void tono2()
{
digitalWrite(BUZZ,HIGH);
delay(50);
digitalWrite(BUZZ,LOW);
delay(50);
digitalWrite(BUZZ,HIGH);
delay(50);
digitalWrite(BUZZ,LOW);
}

void loop()
{
	lecturaldr();
	lcd.home();
	lcd.print("ShotControl");	// Output char
	lcd.print(" ldr ");	// Output char
	lcd.printNumber(ldr,10);	// Output char
		lcd.print("    ");	// Output char
	lcd.setCursor(0, 1);
if (digitalRead(BOTON4)) lcd.print("Long exposure       ");
else lcd.print("Time Lapse     ");
if(digitalRead(BOTON1) && digitalRead(BOTON4)) longexpo();
else if(digitalRead(BOTON1) && digitalRead(BOTON4)==0) timelapse();
if(digitalRead(BOTON5))
{
if (encendida) encendida=0;
else encendida=1;
delay(200);
}
if(digitalRead(BOTON2)) delay(200), tiempo++;
if(digitalRead(BOTON3)) delay(200), cantidad++;
if(digitalRead(SHOT)) dispara(200);
if(ldr<=oldr-10 && ldractivado==1) dispara(200); if (tiempo >= 1000) tiempo = 1000;
if (tiempo <= 1) tiempo = 1;
if (encendida) digitalWrite(LCD,HIGH);
if (!encendida) digitalWrite(LCD,LOW);
lcd.setCursor(0, 2);
lcd.print("ShotN ");
lcd.printNumber(cantidad,10);
lcd.print(" Wtime ");
lcd.printNumber(tiempo,10);
lcd.print("     ");
lcd.setCursor(0, 3);
segundos=millis()/1000;
lcd.print(" -Esperando comando-");
}

Gracias a la aportación de la gente de PINGUINO Venezuela… que me ha inspirado y me he puesto a realizar un theme a mi gusto y piachere… para los que quieran ver el IDE un poco más “MAC”… os dejo el theme creado en el siguiente link… https://rapidshare.com/files/458709102/walii.zip

hay que descomprimir la carpeta en el directorio THEME dentro de PINGUINO IDE… y luego iniciar el IDE y buscarlo en la opción “Preferences” y “themes”.

Saludos… y nuevamente gracias a Juan Espinoza por la idea.

Como hace tiempo que mi nena me incha con el tema de tener una mascota… y como yo no le pienso cumplir el capricho… se me ocurrió aunar un poco mis conocimientos y hacerle algo para que se distraiga entre tanto.

Este artilugio basicamente hace lo siguiente:

1º No se cae de las mesas

2º Si dibuja un circulo en el suelo no sale de él (utilizando cinta aisladora negra y siendo el suelo de un color claro)

3º Si se encuentra con un objeto en frente retrocede y lo esquiva

4º Si le pasa la mano por el lomo… este se detiene…(mas que nada para mantenerlo controlado, porque he visto que la nena tiene miedo del ruido que hace y no lo toca si escucha algo)

Basado en un PINGUINO “pequeño” 18f2550 ya que me sobrava y tenia poco espacio dentro… además utilizo varios sensores infrarrojos… y no se asusten los que parecen cartuchos de dinamita son baterias de LIPO (extraídas de una bateria de portátil) poseen un rendimiento inmejorable… puede durar varias horas funcionando el bicho.

El código fuente es:

/*
Tema: mascota para la niña
Acciones: detector de objetos y diferencias en el terreno, con sensor de apagado en el lomo.
Autor: walterleonardo
Partes: PINGUINO 18f2550, sensores infrarrojos, servo motores modificados

*/

int stopd=74;//punto quieto de servo modificado
int stopi=72;//punto quieto de servo modificado
int adelantei=250;
int adelanted=1;
int atrasi=1;
int atrasd=250;
int topirdata,frontirdata,bottonirdata,topirdatai,frontirdatai,bottonirdatai;
#define topir 15
#define bottonir 14
#define frontir 13
#define izquierdo 0
#define derecho 1

void lectura() //lectora de sensores
{
topirdata=analogRead(topir);
bottonirdata=analogRead(bottonir);
frontirdata=analogRead(frontir);

}

void caida() //accion ante posible caida o modificacion del terreno
{
//detiene marcha
servo.write(izquierdo,stopi);
servo.write(derecho,stopd);
delay(500);
//atras
servo.write(izquierdo,atrasi);
servo.write(derecho,atrasd);
delay(1000);
//gira derecha
servo.write(izquierdo,adelantei);
servo.write(derecho,atrasd);
delay(1000);
//arranca
lectura();
if (bottonirdatai<=bottonirdata-100) caida(); servo.write(izquierdo,adelantei); servo.write(derecho,adelanted); } void atras() //accion ante obstaculo { //detiene marcha servo.write(izquierdo,stopi); servo.write(derecho,stopd); delay(200); //atras servo.write(izquierdo,atrasi); servo.write(derecho,atrasd); delay(500); //gira derecha servo.write(izquierdo,adelantei); servo.write(derecho,atrasd); delay(1000); //arranca lectura(); if (frontirdatai>=frontirdata+50) atras();
servo.write(izquierdo,adelantei);
servo.write(derecho,adelanted);

}

void detiene() //accion de detenerse
{
//detiene marcha
servo.write(izquierdo,stopi);
servo.write(derecho,stopd);
delay(2000);
lectura();
if (topirdatai>=topirdata+50) detiene();
servo.write(izquierdo,adelantei);
servo.write(derecho,adelanted);

}

void setup()
{
Serial.begin(9600); //serial para debug, puede quitarse
//pero deben quitarse todo lo relacionado
servo.attach(0); //servo izquierdo
servo.attach(1); //servo derecho
//leemos los valores y los guardamos en variables iniciales
//para poder comparar y ademas tener un rendimiento optimo
//en todas las condiciones de luz.
//ya que permite medir la diferencia y no solo una medida x
lectura();
topirdatai=topirdata;
bottonirdatai=bottonirdata;
frontirdatai=frontirdata;
}

void loop()
{
//para debug imprimimos los valores en el serial
Serial.printf("topirdata = %d ", topirdata);
Serial.printf("bottonirdata = %d ", bottonirdata);
Serial.printf("frontirdata = %d\r\n", frontirdata);
//verificamos que las diferencias no sean muy grandes
//para asi evitar que este cambiando de direccion con cualquier
//minima variación.
if (topirdatai>=topirdata+50) detiene(); //detiene si detecta diferencias en el sensor superior
if (frontirdatai>=frontirdata+50) atras(); //atras y cambia de sentido si detecta diferencias en el sensor frontal
if (bottonirdatai<=bottonirdata-100) caida(); //atras y cambia de sentido si detecta diferencias en el sensor de terreno
delay(100);
lectura(); //ordena leer nuevamente los sensores
}

Bueno al final me he presentado en la BarCamp… y la verdad que estuvo muy interesante y he sacado en claro que no soy el unico trastornado de Madrid que le gustan estas cosas…

Edificio del UNED en las Tablas (Madrid)

Mi ponencia sobre pinguino.

Uno de los proyectos mas bonitos que he visto… una bestia!

Uno de los proyectos basados en PINGUINO, muy bonito… inspirador…

Pero sinceramente la he pasado muy bien… y hemos hecho durar la charla mas alla de las 19hrs. He aprendido mucho y me he empapado de toda la info interesante que han hablado los ponentes.

Tambien he realizado una charla de PINGUINO aunque la gente que estaba ya tenia muchos conocimientos se han sorprendido con las peculiaridades de PINGUINO.

La gente de ARDE ha filmado el evento para poder colgarlo de su WEB… y compartir con mucha mas gente esta información.

También he sacado en claro que necesitamos unirnos para poder hacer cosas interesantes… cada uno aporta lo suyo… pero unidos creo que puede salir algo muy importante…

Espero volver a verlos en la proxima reunion…

Este sabado 26 de Marzo se organizará una reunión tipo BARCAMP en el UNED (de las Tablas, Madrid), para los que quieran participar, visitarnos o solo pasarse un rato. Aquí estan los datos.

Intentaré hablar sobre PINGUINO y ayudar a los principiantes a entrar en este mundo.

http://barcamp.org/w/page/38043852/V-Jornadas-Robóticas

Saludos los esperamos.

Aquí, algo que he querido publicar hace tiempo… y por eso lo verán instalado ya en mi coche… ya lleva algún tiempo de pruebas y ha salido victorioso.

Siempre me preguntaba porque un Mercedes CLK puede tener un arranque con código y yo en mi Korando no??? J Por eso me puse manos a la obra y he realizado este proyecto.

Básicamente funciona así: si uno no introduce el código correcto no cierra el circuito y no alimenta al circuito de arranque… algo como un corte de arranque pero en forma de código…

Con un cable muy largo e instalado separadamente el PINGÜINO y el teclado, y así poder tener el teclado en una posición disimulada, por sobre el parasol, entonces si no se baja el parasol es imposible ver la modificación… también he incluido un procedimiento para modificar el código para poder cambiarlo por ejemplo cuando lo dejamos en el taller de reparaciones o cuando lo dejamos en los lava coches. Y así no descubren nuestro verdadero código.

El código funciona utilizando la memoria EEPROM del PINGÜINO para poder grabar de forma permanente el número secreto, y que este no se modifique o se pierda con una falta de energía. Por tal motivo podremos conectarlo en la conexión de contacto de nuestro coche… y así alimentarlo solo mientras se necesite.

El circuito de pruebas fue algo muy básico con dos leds, uno para testigo de cuando presionábamos las teclas y otro led para reemplazar el rele.

El código es algo complicado porque actualmente no poseemos librerías para teclado, pero me las he ingeniado para hacer un ROUNDROBIN para detectar las pulsaciones, quizás no es tan sensible como quisiera, pero manteniendo el botón presionado por medio segundo y verificando que el LED enciende, estamos seguros que detecto la acción.

El código por defecto y luego de restaurar es “1234″, para restaurar un código olvidado o erróneo tenemos la opción de “RESTAURAR” en este punto colocando el valor a 1 limpiaremos la memoria, podremos poner un botón secreto para esto, o el puerto USB accesible y escribir el código nuevo vía USB.(creo que esta es la mejor forma… por eso lo tengo así)

En este caso, cuando presionamos el código y la tecla “E”, estamos intentando “cerrar el rele”, si lo tipeamos mal no nos dejará y por puerto serie aparecerá el mensaje de “error en el código”

Para el caso de cambiar la clave deberemos estar primero ingresados, “con el rele cerrado”, habiendo puesto el código correcto. Luego de esto hay que ingresar el nuevo código y presionar “F” para grabarlo.

Para el caso que no estuviésemos ya registrados con el código correcto e intentemos modificarlo, en el puerto serie obtendremos un mensaje de error.

El código es este:

// KEY LOCK

// Walii 2011

/*teclado conectado al puerto RB, pines pinguino 0 al 7

del 0-3 producen nivel alto en las columnas

del 4-7 hacen el control de activacion de las filas

por ejemplo si tenemos el nivel 3 alto, y detectamos un nivel alto

en el teminal 5, estaremos viendo un nuevo 7 del teclado

para cada caso es diferente.

NOTA: recordemos que aunque el PINGUINO se quede sin energia

guarda en su memoria el codigo. Ya que es guardado en la EEPROM

Todos los PRINT son para debug, pueden quitarse.

*/

//esto es una aplicacion completa y la tengo funcionando en mi auto.

#include <eepromlib.c>

#define PIC18F4550

unsigned char i=0;

unsigned char x=1;

unsigned char c=0;

unsigned char val,result,suma;

unsigned int key[4]={1,2,3,4};//valor de ejemplo

unsigned char verificado=0;//valor de autenticado

unsigned char restaurar=0;//valor para restaurar la config

void setup()

{

   for (i=0;i<4;i++)

{

pinMode(i,OUTPUT);

digitalWrite(i,LOW);

}

pinMode(28,OUTPUT);//rele de apertura de puerta, o en mi caso de arranque del auto.

digitalWrite(28,LOW);

pinMode(27,OUTPUT);//Buzzer para testificar las acciones

Serial.begin(115200);

}

void loop()

{

if (restaurar==1) limpiar();//limpiamos la memoria si restaurar esta en 1

//comenzamos el trabajo

//aqui hacemos rotar el valor X para poder

//realizar ROUNDROBIN en las columnas del teclado.

digitalWrite(x,HIGH);

//delay(200);

if (digitalRead(x)==1)

{

//escuchamos las filas para cada columna activada

if (digitalRead(7)) key1=3-x+1,c=c+1,ping();

if (digitalRead(6)) key1=6-x+1,c=c+1,ping();

if (digitalRead(5)) key1=9-x+1,c=c+1,ping();

//en este ultimo caso es especial, porque tenemos las teclas F/0/E

//y queremos usar F para grabar el codigo y E para entrar el codigo

if (digitalRead(4))

{

result=12-x+1;

if (result==10) formatear();

if (result==11) key1=0,c=c+1,ping();

if (result==12) entrar();

}

delay(100);

}

digitalWrite(x,LOW);

x=x+1;

if (x==4) x=1;

if (c==4) c=0;

//Imprimimos el valor del array de clave (key)

//esta es la clave predeterminada pero NO la guardada en memoria

Serial.print("\n\rLa clave es");

Serial.print("\n\r");

Serial.print("\n\r");

Serial.print(key[0],DEC);

Serial.print(key[1],DEC);

Serial.print(key[2],DEC);

Serial.print(key[3],DEC);

//delay(500);

}

//Aqui tenemos el modulo para grabar una nueva clave...

//deberia estar autenticado para poder modificarla

void formatear()

{

if (verificado==1)

{

  for (i = 0; i < 4; i++){

  val=key[i];

    ee_write(i, val);

    delay(100);

    if (i==3) Serial.print("grabado...\n\r");

    }

}

else

{

Serial.print("NO puede cambiar la clave");

}

}

//este es el modulo de entrada, verifica que el array sea identico

//a los datos grabados en la EEPROM

void entrar()

{

suma=0;

  for (i = 0; i < 4; i++){

    if (ee_read(i)==key[i]) suma++;//verifica con una suma, que todos los valores esten bien.

    //delay(100);

    }

if (suma==4)

{

Serial.print("Codigo correcto --- puedes entrar...\n\r");

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW);

verificado=1;//modifica el valor de verificado, permitiendo modificar la clave

activaRele();//si es correcto cambia el valor de verificado y activa el rele.

c=0;//vuelve a cero el contador de array

}

else

{

Serial.print("error en el codigo...\n\r");

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW);

digitalWrite(28,LOW);

verificado=0;//quita la marca a verificado

c=0;//vuelve a cero el contador de array

}

}

//Activa el rele, subiendo el estado del pin 28

//no me interesa bajar el estado, ya que solo

//se desconectará cuando pierda energia, de la alimentacion el auto

//cuando quite la llave.

void activaRele()

{

beep();

digitalWrite(28,HIGH);

}

//esto restaura los valores a 1,2,3,4 solo si se compila con

//el valor restaurar en 1 (por seguridad lo dejo fuera del acceso del teclado)

//pero se puede poner un boton secreto en algun lado...

void limpiar()

{

for (i = 0; i < 4; i++){

    ee_write(i, i+1);

    delay(100);

    if (i==3) Serial.print("restaurado...\n\r");

    }

restaurar=0;

}

//parpadeo de un ciclo, mejor que sea un LED.

void ping()

{

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW);

}

//parpadeo de 3 ciclos, puede ser un LED o un BUZZER

void beep()

{

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW),delay(100);

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW),delay(100);

digitalWrite(27,HIGH),delay(100),digitalWrite(27,LOW);

}

Nota: estoy muy contento con mi proyecto y sé que puede usarse para infinidad de distintos y nuevos proyectos.

Espero que os agrade.

Esto se me ocurrió tras hablas con JEAN, porque no he encontrado un ejemplo de tal uso, ya que PINGÜINO tiene 250 posiciones de memoria para utilizarlas en lo que uno quiera recordar, aunque nuestro pingüino se quede sin energía. Ya que es una memoria EEPROM puede recordar lo que escribamos en ella por siempre… y ser borradas y re-escritas las veces que necesitemos.

He intentado hacer dos ejemplos muy fáciles y prácticos… uno escribe las 250 posiciones, y el otro las lee… para que veamos que después de apagar y reprogramar nuestro PINGÜINO, esta información sigue estando, ya que utiliza espacios de memoria que no se sobre-escriben si escribimos un nuevo código.

Escritura:

#include <eepromlib.c>
#include 18f4550
int i;

void setup()
{
  for (i = 0; i < 250; i++){
    ee_write(i, i);
    delay(100);
    if (i==250) Serial.print("grabado...\n\r");
    }
}

void loop()
{
}

Y el código de lectura

#include <eepromlib.c>
#include 18f4550
unsigned char answer;
int i;
int a = 0;
int value;

void setup()
{
Serial.begin(9600);
}

void loop()
{
 value = ee_read(a);
  Serial.print(a,DEC);
  Serial.print("\t");
  Serial.print(value,DEC);
  Serial.print("\n\r");

  a = a + 1;

  if (a == 250)
    a = 0;

  delay(100);

}

Hoy me ha ocurrido algo que antes nunca… e instalado una maquina nueva con window xp y he intentado conectar un PINGÜINO, era muy extraño me lo detectaba correctamente como “Microchip Custom USB DEVICE” pero en el programa que trae el LIBUSB no aparecía y si no aparece en el listado el PINGÜINO GUI no lo reconoce tampoco y no podemos escribir en él, recuerden que tenemos que buscar por “04D8 FEAA”, tras dar muchas vueltas por las entrañas de WINDOWS, instalar el LIBUSB varias veces, y reiniciar otras tantas, e buscado en el ORACULO, y encontré que hay una nueva versión de LIBUSB con una interfaz mas manual… ¿Qué quiero decir con manual?… ya lo verán.

Si os ocurre esto, descarguen de la web de LIBUSB o de mi pagina, aquí en la columna de la derecha de la página principal verán la descarga (recuerden que deben estar registrados para descargarla), lo instalan sin quitar nada, así nomas, encima del resto de instalaciones del LIBUSB…

El archivo se llama. libusb-win32-devel-filter-1.2.2.0.exe

http://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/1.2.2.0/

Cuando termina de instalar, les aparece una opción.

Aquí la opcion nueva es el instalador de filtros manual… le decimos que queremos instalar un nuevo “device filter” y seguimos.

Aquí veremos el listado de dispositivos USB con su código de fabricante… buscaremos el antes mencionado. 04D8 FEAA y

Presionando el botón de INSTALL… “tenemos listo el pollo”

Ahora por seguridad, desenchufen el PINGÜINO y vuelvan a conectarlo… LISTO aunque sigue sin aparecer en el listado del TESTLIBUSB,

Aparece correctamente en la nueva aplicación del LIBUSB “INF WIZARD” y es reconocido bien por el PINGÜINO GUI

En principio quería explicar el nombre… porque se me ocurrió exactamente haciendo eso, buscando un nombre… ya que este proyecto se inicia como un control domótico utilizando PINGÜINO para comandar todos los artefactos y censar temperatura y humedad de todos los puntos de la casa. Entonces aunando PINGÜINO y CASA, se me ocurrió el nombre de PROYECTO IGLU CONTROL.

Me he basado en la mezcla de varias tecnologías, como suelo hacer siempre:

1. Cliente grafico (un ordenador o teléfono inteligente con un browser) y conexión a Internet.
2. Un router de borde con Linux “OPENWRT” y un túnel seguro (OPENVPN/PPTP) para recibir la conexión y dejar entrar en mi red privada desde cualquier parte del mundo.
3. Un servidor Linux, para centralizar toda la información recibida de los PINGUINOS, procesarla y presentarla en pantalla, a la vez también es el encargado de enviar las ordenes a cada una de los PINGUINOS (control de domótico de electrodomésticos)
4. Varios módulos XBEE, para la comunicación entre el servidor y los PINGUINOS
5. Algunos routers con Linux “OPENWRT” y puertos USB para la monitorización de la actividad mediante cámaras WEB.
6. Y muchos PINGUINOS con controles de potencia, relés eléctricos y sensores de temperatura, iluminación y humedad.

NOTA: el punto “2″ se puede obviar si solo queremos conectarnos desde nuestra misma red.

COMENZAMOS EL PROYECTO:

Utilizando un cliente grafico (Un teléfono inteligente o un ordenador con WIFI) nos conectamos a nuestro router de borde, este no hace mucho más que recibir la conexión, una vez conectado, el cliente abre una sesión con un servidor WEB, que es el encargado de centralizar toda la información enviada por los PINGUINOS que se sitúan en puntos estratégicos de mi casa, también se encarga de enviar a cada uno las órdenes dictadas por cada cliente conectado al servidor.

*Imagen del control via un browser en WINDOWS.

En este punto nos aparece en el cliente una pantalla de bienvenida que nos ofrece las opciones:

Además he incluido algún detalle personal, por presumir un poco de equipamiento.

Una vez aquí solo tenemos que controlar, las luces, temperatura, censar la humedad, algún que otro electrodomésticos, cortinas, el acuario, seleccionar las configuraciones predeterminadas para la iluminación y las luces, como por ejemplo la configuración CINE, la cual apaga las luces enciende el proyector y baja la pantalla de proyección. Inclusive podríamos controlar la frecuencia de comida de los peces del acuario como su temperatura y configuración diaria de iluminación. También tenemos las opciones de monitorizar el consumo de CPU, las descargar y el trafico en general de la red. Y adicionalmente verificar que canal se está visionando en el televisor y programar cualquier grabación, todo desde fuera de casa, y pudiendo utilizar cualquier dispositivo que posea navegador y conexión a internet.

PROYECTO:

Básicamente utilizo UNIX SHELL, PHP, LUA y JavaScript, no es que sea un bocho (GURU) en todos estos lenguajes, pero en internet hay mucho tutorial y manual que ayuda mucho.

La información de los PINGÜINO las recibo por XBEE, y cada uno informa cada minuto su identificación, la información de todos sus sensores y las puertas activas.

Por ejemplo puedo recibir este mensaje: habitación,1,temp,20,hum,60,luz,12,puertas,00000100.

Nota: los mensajes de sensores se entienden, por eso explico el último dato (00000100) indica que posee la puerta 6 activa, pudiendo referirse a una luz en especial. Para estos casos he resuelto una disposición especial para cada control. Las primeras 3 puertas controlan los electrodomésticos o luces del lado norte de la habitación, los siguiente del lado central y los últimos tres del sur de la habitación. Indicando este mensaje que una luz o electrodoméstico del suroeste de la habitación, se encuentra activo.

Para el caso de corte de luz, guardo esta info en el servidor, para ser enviada al PINGÜINO y restablecer el estado anterior de este controlador.

SCRIPT DE EJECUCION DE COMANDOS VIA SERIE

Esto son algunos de los scripts usados. Los cuales he copiado de mi propio proyecto RGB PINGÜINO http://pinguino.walii.es/?p=18

Con un poco de imaginación y esmero se pueden hacer maravillas.

Por ejemplo este es un script en LUA que envía un carácter “R” por puerto serie.

---# //para rojo envía por puerto serie el carácter "r"
---#! /usr/bin/lua
caracter="echo r > /dev/tts/1";
os.execute(caracter);

Y esta la pagina web que posee el botón para ejecutar el script:

<html>
<head>
<title>control de RGB via web   walii.es</title>
</head>
<body>
<h2>Control remoto RGB via web (<a href="http://blog.walii.es/" target="_new">blog de Walii.es</a>)</h2>
<p>
<b>Presionando el boton activamos la salida para el color ROJO </b>
</p>
<table border="0" cellpadding="0">
<tr>
<td valign="top" width="50%">
<p>
<b>Este es solo para un color, necesita un poco de imaginación y diseño web para hacer el resto</b>
<ul>
<li><a href="/cgi-bin/rojo.lua" target="_new">ROJO</a></li>
</ul>
</body>
</html>

Con esto se supone que ustedes son capaces de hacer la web que quieran… pero para comenzar es más que suficiente, recuerden que el tipo de orden es la misma para PINGUINOS conectados vía serie directo que a través de XBEE.

CIRCUITOS:

No voy a poner todos los circuitos y diagramas de cada punto de control, solo indicare en detalle uno, e incluiré los diferentes controles.

CONTROL ILUMINACION

CONTROL DE CORTINAS

CONTROL DE TEMPERATURA (Hogar)

El tema del control de temperatura, lo resolví más fácilmente, controlando toda la temperatura de la casa, como tengo una caldera electrónica, y utilizando un poco de ingeniería inversa, pude encontrar el control electrónico por PWM que regula la temperatura. Y enviando info desde un PINGÜINO, puedo controlar la temperatura general. (mas adelante y con algunos aditamentos veré si puedo diferencia las temperaturas por zonas).

Utilizo el puerto 16 del PIC, serían el 11 y 12 del pingüino 18f4550, los cuales son PWM.

CONTROL TEMPERATURA ACUARIO

Para esto utilizo el mismo circuito que de iluminación, combinado con un sensor de temperatura, ya que el termostato es puramente eléctrico.

SENSORES DE TEMPERATURA, ILUMINACION Y HUMEDAD

PROGRAMA PINGÜINO:

El programa básico de los pingüinos es algo general, realizando todos más o menos la misma tarea.

/*
*
* IGLU CONTROL PROJECT
*
* Example to home remote control
* With PINGUINO PIC
* And received all the control information
* From a XBEE and WIFI
*/

int key;
int volts=5; //alimentación del micro, o tension de referencia si tendriamos.
int name=1; //nombre del pinguino
int samples[10];
int tempc=0;
int luzc=0;
int humedadc=0;
int i,x,port0,port1,port2,port3,port4,port5,port6,port7;
float val1;

void setup()
{
for ( i=0 ; i <8; i++){
pinMode(i,OUTPUT);
digitalWrite(i,LOW);
}
Serial.begin(9600);
}

void loop  ()
{
//controlamos temperatura, luz y humedad
//Temperatura
for (i=0;i<=9;i++){
val1=analogRead(13);
samples[i]=(volts*val1*100)/1024.0;
tempc=tempc+samples[i];
}
//Dividimos por la misma cantidad de lecturas
tempc=tempc/10.0;

//Humedad
for (i=0;i<=9;i++){
val1=analogRead(14);
samples[i]=val1/10.0;
humedadc=humedadc+samples[i];
}
//Obtenemos el promedio de valores
humedadc=humedadc/10.0;

//Iluminacion
for (i=0;i<=9;i++){
val1=analogRead(15);
samples[i]=val1/10.0;
luzc= luzc+samples[i];
}
//Obtenemos el promedio de valores
luzc=luzc/10.0;

//Ahora vamos a escuchar el puerto serie
if (Serial.available()>0){
key=Serial.read();//leemos la entrada del serie
if (key=='a') digitalWrite(0,digitalRead(0)^1); //Cambia el estado del Puerto 0 por su valor inverso
if (key=='b') digitalWrite(1,digitalRead(1)^1); //Cambia el estado del Puerto 1 por su valor inverso
if (key=='c') digitalWrite(2,digitalRead(2)^1); //Cambia el estado del Puerto 2 por su valor inverso
if (key=='d') digitalWrite(3,digitalRead(3)^1); //Cambia el estado del Puerto 3 por su valor inverso
if (key=='e') digitalWrite(4,digitalRead(4)^1); //Cambia el estado del Puerto 4 por su valor inverso
if (key=='f') digitalWrite(5,digitalRead(5)^1); //Cambia el estado del Puerto 5 por su valor inverso
if (key=='g') digitalWrite(6,digitalRead(6)^1); //Cambia el estado del Puerto 6 por su valor inverso
if (key=='h') digitalWrite(7,digitalRead(7)^1); //Cambia el estado del Puerto 7 por su valor inverso
port0=digitalRead(0);
port1=digitalRead(1);
port2=digitalRead(2);
port3=digitalRead(3);
port4=digitalRead(4);
port5=digitalRead(5);
port6=digitalRead(6);
port7=digitalRead(7);
Serial.print("received... OK!!!"); //debug la respuesta y recepción del mensaje
Serial.print("\n\r");
Serial.print("habitacion,",name,", temp,",tempc,", hum,",humedadc,", luz,",luzc,", puertas,",port0,port1,port2,port3,port4,port5,port6,port7);
Serial.print("\n\r");
Serial.flush();//clear the serial buffer }
}
}

ROUTERs OPENWRT y SERVIDOR LINUX UBUNTU

Básicamente estos tienen varios tipos de Scripts y programas para realizar las tareas correspondientes:

• Los routers están customizados con la última versión “a día de hoy” del OPENWRT Backfire (10.03.1-rc4, r24045), en mi caso utilizo router compatibles con este sistema operativo, varias FONERAS y un router TP_LINK.
• El servidor LINUX, es un UBUNTU versión 10.10, con un servidor web APACHE, PHP y MYSQL, además posee el programa MOTION porque también le he incorporado alguna cámara para monitorizar su zona.
• Publicación de las imágenes vía WEBCAM, utilizo “MOTION“, que funciona muy bien, y tiene infinidad de opciones, como enviar un correo con la fotografía tomada si se detecta movimiento, guardar en un servidor remoto las imágenes para no dejarlas en la red privada, orientación de las imágenes, compresiones, etc.
• La información de consumo de CPU, temperatura de CPU, utilización de la red, etc, la obtengo con el programa MRTG, el cual vía el protocolo SNMP recopila toda la información necesaria para realizar los reportes gráficos que se ven en las capturas.
• Comunicación con PINGÜINO, mediante el puerto serie de estos dispositivos y utilizando algunos script de LUA y LINUX SHELL, también pueden utilizar los programas, MICROCOM y PICOCOM, son muy útiles en el caso de querer debugear un problema.
• Para la comunicación con la red XBEE, es fácil, porque hay en el mercado un adaptador USBtoXBEE (se llama Xbee EXPLORER), y cuando se conecta al ordenador, este lo reconoce como un puerto serie, y utilizando los programas mencionados en el punto anterior, es fácil la comunicación.

APLICACIÓN IPHONE:

Para más complicaciones he realizado una aplicación web (tradicionalmente llamada WEBAPPLICATION) para poder tener el control directo y acceso al servidor, sin tener que buscar el vinculo en el browser, y poder hacerlo todo más fluido. Son las imágenes mostradas en los ejemplos. Este es el acceso desde la propia aplicación.

Esto último se hace muy fácil, luego os indico en otro POST como, así no mesclamos las cosas.

Igual para los que quieran investigar, he utilizado un FRAMEWORK llamado IUI, aquí pueden descargarlo. Una recomendación: para sacarle todo el poder al framework utilizar el navegador de Apple, SAFARI.

http://iui.googlecode.com/files/iui-0.31.tar.gz

Saludos y no duden en consultar lo que deseen.

Este proyecto intenta la reutilización de un vehículo radio controlado, reemplazando toda la electrónica con un micro-controlador PINGUINO, y el medio de transmisión, reemplazarlo con el protocolo de comunicación 802.15.4 ( XBEE/ZigBee), ofreciendo la capacidad de control a una distancia mayor a un kilometro.

Adicionando a esta mejora, y entendiendo que a esta altura se podría controlar el vehículo con cualquier ordenador con un módulo XBEE conectado por USB… podríamos agregar la facilidad de controlarlo mediante un teléfono móvil o ipad “IPHONE/ANDROID”, mediante la utilización de PROCESSING y con la librería de comunicación OSCnet (para el caso de los dispositivos móviles se utiliza el programa TouchOSC).

Nota: la versión de touchOSC para ANDROID es 100% gratis y de libre distribución.

La de IPHONE tiene un precio de $5.- dólares por única vez en la tienda de APPELSTORE

Video del proyecto finalizado.

Video de funcionamiento

.

HERRAMIENTAS NECESARIAS PARA ESTA APLICACIÓN:

PROCESSING _ link general http://processing.org/

Link de descarga http://processing.org/download/

LIBRERÍA OSC incluida en el paquete original (OSC OpenSoundControl)

Pensada principalmente para controlar equipos de música profesionales de forma remota.

LIBRERÍA SERIAL incluida en el paquete original

TOUCH OSC _ link general y link de descarga http://hexler.net/software/touchosc

Touch OSC versión de prueba para IPHONE desde el APPLE STORE ($5 dolares)

http://itunes.apple.com/us/app/touchosc/id288120394?mt=8

Touch OSC versión para ANDROID (totalmente gratis)

http://hexler.net/software/touchosc-android

PINGUINOPIC

Se utiliza un pingüino modelo 18f4550 adquirido en el KIT armado de la web http://pinguino.walii.es

GUI PINGUINO PIC

Utilizamos la versión de PINGÜINO en este momento la 9.04

http://www.hackinglab.org/pinguino/download/latestpinguino/

XBEE pro & XBEE explorer USB

Se utilizan dos XBEEs PRO de 60mW y un adaptador USB “XBEE Explorer” adquiridos en sparkfun.com

http://www.sparkfun.com/products/8742

http://www.sparkfun.com/products/8687

IDEA DEL PROYECTO:

Lo primero que debemos tener en cuenta es: ¿qué es lo que queremos controlar?…

En principio son dos motores uno de dirección izquierda/derecha y otro de movimiento delante/atrás. Ambos necesitan una inversión de tensión en sus extremos y encontrarse sin energía en su punto de reposo. Al mismo tiempo necesitamos 2 tipos de luces, una blanca para la iluminación general y otra infrarroja para la adición futura de una cámara wifi.

También se nos ocurrió agregarle un Buzzer tipo bocina o alarma…

En total deberíamos tener 2 puertos digitales para los motores, más otros 3 para luces y buzzer.

5 puertas digitales comandadas vía serie. Por ejemplo con teclas identificadas para cada acción.

NOTA: también es posible reenviar vía serie, parámetros como temperatura, posición GPS, nivel de señal wifi, iluminación y humedad. Para esto utilizaríamos los puertos analógicos, esto lo he dejado para más adelante…

INICIO PROYECTO (COMUNICACIÓN SERIE)

El proyecto comienza con el kit PINGUINO programándolo para ser controlado vía Puerto serie, esto se genera fácilmente, utilizando el siguiente código. En modo de prueba puede ser comandado con un adaptador RS232 a TTL conectado en nuestro ordenador y con cualquier programa de consola… para verificar que enviamos y recibimos los datos.

Nota: cabe la aclaración que esto no funciona con un adaptador USB/SERIE, necesitamos un puerto serie propietario para que funcione… si no poseemos un puerto serie propietario deberíamos tener un adaptador directo USB/TTL

El programa de PINGÜINO que creamos a tal efecto es el siguiente:

/*
*
* IPHONE+TouchOSC+PROCESSING+XBEE+PINGUINO
*
* Example to control a remote control card
* with all the PINGUINO PIC electronic
* And received all the control information
* from a XBEE
*/

uchar key;
int i;
void setup()
{
for ( i=0 ; i <8; i++){
pinMode(i,OUTPUT);
digitalWrite(i,LOW);
}
Serial.begin(9600);
}

void loop()
{
if (Serial.available()>0) //only apply if we have information into the serial port { key=Serial.read();
if (key=='l') digitalWrite(4,digitalRead(4)^1);//change the status of port 4 to invert value
if (key=='i') digitalWrite(5,digitalRead(5)^1);//change the status of port 4 to invert value
if (key=='b') digitalWrite(7,digitalRead(7)^1);//change the status of port 4 to invert value
if (key=='a') digitalWrite(0,HIGH); //go a head
if (key=='s') digitalWrite(1,HIGH); //go back
if (key=='d') digitalWrite(2,HIGH); //left
if (key=='f') digitalWrite(3,HIGH); //right
if (key=='z') digitalWrite(0,LOW);  //stop move a head
if (key=='x') digitalWrite(1,LOW);  //stop move back
if (key=='c') digitalWrite(2,LOW);  //stop turn left
if (key=='v') digitalWrite(3,LOW);  //stop turn right

Serial.print("received... OK!!!"); //debug serial answer
Serial.print("\n\r");
Serial.flush();//clear the serial buffer }

}

NOTA: AL ser una comunicación serie, tenemos que entender que recibiríamos carácter tras carácter a una velocidad de 9600, para convertir esta comunicación en multitarea para nuestro pinguino, entonces se nos ocurrió cambiar el estado de las puertas digitales con diferentes teclas, por tal motivo si presionamos la tecla “a” elevaríamos el estado de la puerta “0”, y este no bajaría hasta no recibir un carácter “x”.

¿Por qué hacemos esto? Básicamente si elevaríamos el estado de alguna puerta “solo al recibir un carácter “a” ”, cuando querremos ir recto y girar al mismo tiempo, no podríamos, ya que cuando recibimos el carácter “a” el vehículo circularía hacia delante, pero en el siguiente siclo si recibiéramos un carácter “d” (para girar la dirección), al no recibir más el carácter “a” el motor se detendría y no giraríamos.

Esto lo podremos probar mediante una consola serie (RS232 to TTL) conectada directamente con el pingüino.

Verificando que cada vez que enviamos un comando, nos responde la consola con el mensaje “received…OK!!!”, y al mismo tiempo verificamos la activación de las salidas digitales, esto se puede hacer con LEDs colocados en cada puerta.

Tras verificar que todo funciona utilizando la comunicación serie tradicional, pasaremos a transformar esta comunicación a protocolo 802.15.4, para convertir la comunicación serie vía cable, en una conexión inalámbrica.

¿COMO PROGRAMAMOS LOS MÓDULOS XBEE?

Cuando reseteamos o conectamos un modulo XBEE, si dentro de los primeros 10 segundos este reciben por su RX tres signos de sumar “+++” ingresaremos en el modo de configuración, y podremos escribir lo que deseemos en nuestro modulo.

Básicamente el único parámetro que necesitamos configurar es el PAN ID, ya que todos los módulos dentro del mismo PanID se hablaría y escucharían, sin necesidad de hacer nada mas, quizás más adelante podríamos configurarlo con mayor seguridad, indicando las direcciones MAC para los interlocutores, pero con esta modificación ya tendríamos funcionando nuestros módulos.

NOTA: también existe una opción de configurarlos en Windows con el programa XCTU, el cual es gratuito y se descarga del siguiente vínculo. http://www.digi.com/support/productdetl.jsp?pid=3352&osvid=57&s=316&tp=5&tp2=0

Hay que escribirle el mismo PanID a los dos módulos, y automáticamente funcionarían como un BRIDGE (PUENTE) “todo lo que recibo en el puerto serie lo envío por mi conexión inalámbrica, y de la forma inversa, todo lo que recibo en la conexión inalámbrica lo transmito a mi puerto serie”.

Para escribir la configuración deberemos conectar cada modulo al adaptador serie (Xbee Explorer USB), en la consola serie configuraremos el puerto en cuestión… y antes que pasen los 10 segundos presionaremos tres veces seguidas el signo de sumar “+++”

Entrando en el modo de configuración.

Para ver el PanID actualmente configurado haremos lo siguiente.

“ATID [enter]” lo que nos devolverá el PanID original de fabrica siempre es “1111”

Para modificar el PanID:

“ATID1234 [enter]” por ejemplo en este caso el PanID será “1234”

Para verificar que lo ha cogido deberemos hacer nuevamente:

“ATID” con resultado “1234”, si lo ha configurado correctamente.

Para finalmente escribir la configuración en la memoria del modulo haremos:

“ATWR”

Y por último para salir del modo de configuración, podremos esperar 10 segundos o escribir:

“ATCN”

Comandos de consola del modulo XBEE

Ahora conectaremos ambos módulos, uno en el pinguino y otro en el ordenador mediante el adaptador “XBEE EXPLORER USB”

Procederemos a verifica la comunicación, con un programa de consola y pulsando caracteres en la consola, deberíamos recibir el mensaje de respuesta “received… OK”

Imagen ilustrativa.

En este momento tenemos una comunicación inalámbrica entre el ordenador y el PINGÜINO, lo bueno de esta comunicación es su distancia de alcance y su fiabilidad a la hora de interrupciones e interferencias, ya que es un protocolo de comunicación.

Llegados a este punto podríamos encender LEDs remotamente desde un ordenador hasta un PINGÜINO a casi un kilometro de distancia, en este momento continuaremos realizando el nivel de electrónica de potencia para poder comandar los motores y luces en cuestión.

CIRCUITOS ELECTRÓNICOS DE POTENCIA

Los siguientes circuitos pueden ayudarnos a realizar la tarea. Ya sea para comandar RELES como para encender luces y buzzer, sin exceder el nivel de potencia de salida del micro controlador.

Circuito para comandar RELES

Circuito para encender LUCES y el BUZZ

Tras construir el circuito propuesto, podremos comandar a distancia las funciones de nuestro vehículo remoto.

Esto con solo presionar unas teclas en una consola serie en nuestro ordenador, y sin ningún cable de por medio, gracias a XBEE.

TOUCHOSC

Ahora vamos un paso más allá, intentando controlar el vehículo mediante un teléfono o tablet (IPHONE o ANDROID), conectada en la misma red WIFI en la cual tendremos nuestro ordenador con el XBEE conectado.

Lo primero será crear una plantilla para controlar nuestro vehículo en formato táctil. Esto lo hacemos con el programa TouchOSC editor.

Se descargar desde el siguiente link. http://hexler.net/software/touchosc

Configurando en cada caso, que es lo que necesitaríamos recibir en cada botón y plantilla.

El archivo de configuración de TouchOSC que hemos creado se puede descargar del siguiente vínculo. (Hay que estar registrado y logeado)

http://pinguino.walii.es/download/TouchOSC-CAR-drone.touchosc

Con esto obtendremos las siguientes plantillas en el teléfono.

Una para el control via teclado y para el control vía acelerómetros.

Con esto ya instalado en el teléfono, procederemos a realizar la interfaz de enlace entre TouchOSC (el teléfono o IPAD) con el ordenador, esto lo hacemos con PROCESSING, ya que actualmente posee las librerías necesarias para realizar el trabajo, por un lado posee las librerías de OSC (OpenSoundControl), la cual interpreta los mensajes del TouchOSC enviados al puerto TCP 8000 de nuestro ordenador, y por otro lado la librería de comunicación SERIE “librería ProcessingSerial” para convertir los datos recibidos en el puerto 8000 en información entendible por el puerto serie, en este caso el modulo XBEE (que más tarde transmitirá esta información al PINGÜINO).

PROCESSING

Código de Processing para realizar la interlocución de la información.

/**
 * IPHONE+TouchOSC+PROCESSING+XBEE+PINGUINO
 *
 * Example displaying a way to modify a remote toy
 * and used it with IPHONE
 * http://pinguino.walii.es
 * pinguino@walii.es  walii@walii.es walterleonardo@gmail.com
 */

import oscP5.*;
import netP5.*;
OscP5 oscP5;
import processing.serial.*;
Serial port; // The serial port object

float xrot = 0;
float zrot = 0;
float xrot_targ = 0;
float zrot_targ = 0;
float orientation = 0;
float v_up = 0.0f;
float v_down = 0.0f;
float v_left = 0.0f;
float v_right = 0.0f;
float v_light = 0.0f;
float v_ir = 0.0f;
float v_buzz = 0.0f;
float vl_up = 0.0f;
float vl_down = 0.0f;
float vl_left = 0.0f;
float vl_right = 0.0f;
float vl_light = 0.0f;
float vl_ir = 0.0f;
float vl_buzz = 0.0f;
float valor= 0.0f;
float calx;
float calz;
String serial;

void setup() {
  size(500,500);
  frameRate(25);
  /* start oscP5, listening for incoming messages at port 8000 */
  oscP5 = new OscP5(this,8000);
  /* start Serial, sending messages to PINGUINO port via XBEE */
  port = new Serial(this, Serial.list()[2], 9600);
  serial = Serial.list()[2];//force to connect with XBEE
  println(Serial.list()); //debug serial ports
  println(serial);//serial port selected
}
//Messages from OSCTOUCH=IPHONE
void oscEvent(OscMessage theOscMessage) {

    String addr = theOscMessage.addrPattern();
    float  val  = theOscMessage.get(0).floatValue();

//detect buttons from screen "CONTROL TACTIL" value /1
if(addr.equals("/1/up"))  { v_up = val; }
    else if(addr.equals("/1/down"))  { v_down = val; }
    else if(addr.equals("/1/left"))  { v_left = val; }
    else if(addr.equals("/1/rigth"))  { v_right = val; }
    else if(addr.equals("/1/ligth"))  { v_light = val; }
    else if(addr.equals("/1/ir"))  { v_ir = val; }
    else if(addr.equals("/1/buzz"))  { v_buzz = val; }

//data from IPHONE's accelerometer screen "Accelerometro" velue /2
//only receive data if press the button into this screen
if(addr.equals("/2/activate")){ valor = val;}
if(valor==1.0f){
  if(theOscMessage.checkAddrPattern("/accxyz")==true) {
      xrot_targ = (theOscMessage.get(0).floatValue()*90)-calx;
      zrot_targ = ((theOscMessage.get(1).floatValue()*90)*-1)-calz;
      orientation = theOscMessage.get(2).floatValue();
  print("x= " + xrot_targ + " z= " + zrot_targ + " Rot= " + orientation +"\n\r");
  }
}
//calibration button for accelerometer
if(addr.equals("/1/info")){calx=xrot_targ;calz=zrot_targ;}

//debug for accelerometer from IPHONE
//if (addr=="/accxyz"){}else{print(addr);print(" "+ val);print("\n\r");}
//debug for buttons of the IPHONE
print("val_up" + v_up + " val_down" + v_down + " val_left" + v_left + " val_right" + v_right + "\n\r");
print("val_light" + v_light + " val_ir" + v_ir + " val_buzz" + v_buzz + "\n\r");
}

//paint
void draw() {
    background(0);
    fill(0, 196, 168);
    stroke(0, 196, 250);
    //up arrow
    if(v_up == 1.0f) {triangle(200,100,250,50,300,100);rect(225,100,50,50);}
    fill(168);
    //down arrow
    if(v_down == 1.0f) {triangle(200,150,250,200,300,150);rect(225,100,50,50);}
    fill(0,0,255);
    //left arrow
    if(v_left == 1.0f) {triangle(175,125,225,75,225,175);rect(225,100,50,50);}
    fill(255,0,0);
    //right arrow
    if(v_right == 1.0f) {triangle(275,75,325,125,275,175);rect(225,100,50,50);}
    fill(0,168,0);
    //buzz indicator
    if(v_buzz == 1.0f) {
    triangle(250,300,270,345,250,390);
    triangle(260,290,300,345,260,400);
    rect(225,300,20,5);
    rect(225,320,20,5);
    rect(225,340,20,5);
    rect(225,360,20,5);
    rect(225,380,20,5);
    }
    fill(0,0,255);
    stroke(255,0,0);
    //ir light indicator
    if(v_ir == 1.0f) {
    line(110,400,170,350);
    line(170,350,160,340);
    line(160,340,220,300);
    line(220,300,190,340);
    line(190,340,200,350);
    line(200,350,110,400);
    }
    fill(0,0,0);
    stroke(0,0,255);
    //light indicator
    if(v_light == 1.0f) {
    line(10,400,70,350);
    line(70,350,60,340);
    line(60,340,120,300);
    line(120,300,90,340);
    line(90,340,100,350);
    line(100,350,10,400);
    }
    //paint with accelerometers's values
    stroke(0);
    fill(0);
    if(valor==1.0f){
    if(xrot_targ>=40) {
    v_up=1.0f;
    }else{
    v_up=0.0f;
    };
    if(xrot_targ<=-40) {
    v_down=1.0f;
    }else{
    v_down=0.0f;
    };
    if(zrot_targ<=-20) {
    v_left=1.0f;
    }else{
    v_left=0.0f;
    };
    if(zrot_targ>=20) {
    v_right=1.0f;
    }else{
    v_right=0.0f;
    };
    if(zrot_targ<=20 && zrot_targ>=-20) {
    v_right=0.0f;
    v_left=0.0f;
    };
    if(xrot_targ<=20 && xrot_targ>=-20) {
    v_up=0.0f;
    v_down=0.0f;
    };
    }
 //write serial port from the information obtain with TOUCHOSC
  if(v_up==1.0f && vl_up==0.0f){port.write("a");delay(100);port.write("a");vl_up=1.0f;}
  if(v_up==0.0f && vl_up==1.0f){port.write("z");delay(100);port.write("z");vl_up=0.0f;}
  if(v_down==1.0f && vl_down==0.0f){port.write("s");delay(100);port.write("s");vl_down=1.0f;}
  if(v_down==0.0f && vl_down==1.0f){port.write("x");delay(100);port.write("x");vl_down=0.0f;}
  if(v_left==1.0f && vl_left==0.0f){port.write("f");delay(100);port.write("f");vl_left=1.0f;}
  if(v_left==0.0f && vl_left==1.0f){port.write("v");delay(100);port.write("v");vl_left=0.0f;}
  if(v_right==1.0f && vl_right==0.0f){port.write("d");delay(100);port.write("d");vl_right=1.0f;}
  if(v_right==0.0f && vl_right==1.0f){port.write("c");delay(100);port.write("c");vl_right=0.0f;}

  if(v_light==1.0f && vl_light==0.0f){port.write("l");delay(100);vl_light=1.0f;}
  if(v_light==0.0f && vl_light==1.0f){port.write("l");delay(100);vl_light=0.0f;}
  if(v_ir==1.0f && vl_ir==0.0f){port.write("i");delay(100);vl_ir=1.0f;}
  if(v_ir==0.0f && vl_ir==1.0f){port.write("i");delay(100);vl_ir=0.0f;}
  if(v_buzz==1.0f && vl_buzz==0.0f){port.write("b");delay(100);vl_buzz=1.0f;}
  if(v_buzz==0.0f && vl_buzz==1.0f){port.write("b");delay(100);vl_buzz=0.0f;}
port.clear();//clear serial port, to clean the buffer.
}

 

He agregado un poco de grafica al interlocutor, en este caso PROCESSING, para indicarnos que es lo que recibe y como lo interpreta, esto es más que nada como debug, no es necesario ni siquiera mirarlo…

En donde observaremos las flechas de dirección, y el encendido de las luces y el buzzer.

Identificando delante y atrás.

Izquierda y derecha

Bueno, con esto ya tendríamos control de nuestro vehículo remoto. Y lo bueno es que no necesitamos estar delante del ordenador para controlarlo, aunque sí con el teléfono dentro del rango del WIFI.

Video demostrativo.

http://www.youtube.com/watch?v=2ja9bCb-puU

FUTURO

Más adelante procederemos a instalarle algunos sensores y una cámara wifi, lo cual nos reduce el rango de distancia a una red WIFI tradicional, pero nos otorga una característica muy particular a nuestro invento.

Nota: para mantener el rango de distancia de nuestro vehículo (mayor a 1 kilómetros), podríamos colocarle en vez de una cámara wifi, un teléfono móvil con cámara y realizando en tiempo real una video conferencia 3g.

DIAGRAMA COMPLETO DEL CIRCUITO PROPUESTO

Con este post quiero agradecer a FURRI por incluir uno de nuestros KITS en su proyecto tan interesante de comunicacion via laser, me parecio algo muy practico y con muchas aplicaciones en el futuro…

Este es el link a la WEB de FURRI…
http://www.tarribot.com/tallerdunas/

Saludos y a seguir en el tema.

Ya en mis manos, la ultima version de GUI de PINGUINO la version 9.05 para MAC, tambien he descargado la version para linux, y estoy en proceso de prueba, una genialidad y un look muy diferente…ya lo verán…
Por lo que puede probar, funciona perfectamente, aunque en la versión de PYTHON 2.5.2 no inicia… pero en cualquier otra 2.5.4 y 2.6.0 funciona al 100%.

gracias JEAN.

Bueno siguiendo el tema de chorradas, y luego del burbujometro se me ocurrió montar el belén navideño, pero al terminarlo lo vi medio fofo… y pensé que quedaria bonito si automatizamos un poco la cosa y ponemos alguna que otra luz.
El tema de tener que darle a un interruptor me molestaba, así que he realizado una especie de interruptor infrarrojo, para activar con solo pasar la mano delante de la estrella, y durante un tiempo de cerca de un minuto las luces y algunos cambios de color…
Espero os guste, es una tontería pero facil de hacer y de replicar.

Las lineas marcadas con //debug son para ir corrigiendo en tiempo real la respuesta del PINGUINO.

/*
 * Walii PINGUINO PIC
 * http://pinguino.walii.es
*
*Español
* Un sensor para el BELEN, para que cuando pasas la mano por delante
* se enciendan las luces de decoración, durante un minuto aproximadamente
*English
* A sensor for BELEN, so that when you pass your hand in front of this
* the lights decoration ON, these for about a minute.
 */

int redPin = 2; 	// R petal on RGB LED module connected to digital pin 2
int greenPin = 1; 	// G petal on RGB LED module connected to digital pin 1
int bluePin = 0; 	// B petal on RGB LED module connected to digital pin 0
int valueir;		//IR SENSOR
int i;
int timer=0;

void setup()
{
   for (i=0;i<8;i++)
	{
	pinMode(i,OUTPUT);		// Config all the port like OUTPUT
	digitalWrite(i,LOW);		// fixed all exit to LOW
	}
Serial.begin(9600);		//debug
}
void color (uchar red, uchar green, uchar blue)     // the color generating function
{
          digitalWrite(redPin,red);
          digitalWrite(bluePin,blue);
          digitalWrite(greenPin,green);
}

void loop() 	// run over and over again
{
valueir=analogRead(13); //Read analog port
//Serial.print("valor ir ");	//debug
//Serial.print(valueir,DEC);	//debug
//Serial.print("\n\r");		//debug
if (valueir<100) timer=50;		//Control IR SENSOR
//Serial.print("valor timer ");	//debug
//Serial.print(timer,DEC);		//debug
//Serial.print("\n\r");		//debug

while (timer>1) //Make this only if timer is > 1
{
//Serial.print("valor timer ");	//debug
//Serial.print(timer,DEC); 	//debug
//Serial.print("\n\r"); 		//debug
analogWrite(11,1000);	// 99% pwm 11
color(HIGH, LOW, LOW); 	// turn the RGB LED red
		delay(500); 	// delay for 1/2 second
analogWrite(11,500);		// 50% pwm 11
color(LOW, HIGH, LOW); 	// turn the RGB LED green
		delay(500);	// delay for 1/2 second
analogWrite(11,1000);	// 99% pwm 11
color(LOW, LOW, HIGH); 	// turn the RGB LED blue
		delay(500); 	// delay for 1/2 second
analogWrite(11,800);		// 80% pwm 11
timer--;
}
analogWrite(11,0);		//Off the PWM pin
color(LOW, LOW, LOW); 	//Off all the ligths
delay(100);			// Wait 100ms
}

Hola… buenas, hoy con una tontería que se me ocurrió hace tiempo y nunca tuve el tiempo para hacerlo, hoy dedique un ratillo a ello, aunque hecho con prisas y con poca paciencia. Pero funciona…

Quizas mi mezcla no sea la ideal, por eso las burbujas no salen como debería.

El programa es basico, controlando el servo y deteniendo un segundo arriba para poder soplar y medio segundo abajo para poder humectar bien el aro.

También el ventilador se controla con una salida PWM y controlando esta con dos botones… para subir y bajar la velocidad, ya que las burbujas necesitan un viento de velocidad “X” para hacerse, si es muy débil el viento, no se hace la burbuja y si este es muy fuerte la rompe.

El control del ventilador es un transistor BC337 corto circuitando la tierra del cooler.

EL código es:

int value;
int i;
int valueservo;
int valuemotor=2;
uchar position=1;

void setup(void)
{
servo.attach(0);
pinMode(1,INPUT);
pinMode(2,INPUT);

}

void loop(void)
{
servo.write(0,230);
delay(500);
servo.write(0,90);
delay(1000);
analogWrite(11,valuemotor);	// 50% square wave on output 11
//analogWrite(12,102);	// 10% square wave on output 12
if (digitalRead(1)==LOW) valuemotor=valuemotor+10;
if (digitalRead(2)==LOW) valuemotor=valuemotor-10;
if (valuemotor>=1023) valuemotor=1023;
if (valuemotor<=2) valuemotor=2;

}

    Se me ocurrió hacer un par de pedidos de gorras, tazas y camisetas con un logo que he creado de PINGUINO… con el permiso de JEAN, me gustaría ofrecerlas por si alguien más quiere…

Por ahora quise hacer solo estos diseños… pero cualquiera puede pedirme alguno especial… de otro color o tamaños, estos son para mí… y me gusta el blanco…

Las Camisetas mangas cortas salen por €19 euros

Las Camisetas mangas largas salen por €30 euros

Las tazas salen por €19 euros

Las gorras salen por €26 euros

Estos precios son más el envió… que es €6 euros nacional o €12 euros internacional.

Si pedimos más de 5 unidades el envío es gratis, y si piden más de 10, un descuento en el total de 10%.

    Estuve esperando a que JEAN me pasara la ultima versión de PINGUINO… pero parece que lleva mucho más trabajo de lo que pensábamos… así que mientras, os ofrezco la versión 9.04… hasta que tenga en mis manos la 9.05…

Jean me ha ofrecido la BETA…BETA del 9. 05… pero prefiero que este bien fina antes de ponerme a hacer el paquete…

Ahora he refinado un poco más el paquete de instalación… y tienen de donde elegir…

Para quienes nunca han instalado PINGÜINO y necesitan todas las aplicaciones previas… tenemos la versión “A” la cual trae he instala todo lo necesario para hacer funcionar PINGÜINO en una maquina nueva… o a la que nunca se le ha instalado esta aplicación… trae PYTHON, WXPYTHON, LibUSB y PyUSB.

http://rapidshare.com/files/432813687/Pinguino_Setup_9.04_A.exe

Para la gente que ya tiene instalado y funcionando cualquier versión previa de pingüino… y solo necesita instalar la nueva versión… para ello es el paquete “B”, con tamaño reducido y sin paquetes extras.

http://rapidshare.com/files/432812456/Pinguino_Setup_9.04_B.exe

Saludos.

Hola buenos dias, esta es una solucion rapida a un probelma de compilación en la version 9.04 de MAC OSX, cuando queremos complilar el modulo de ejemplo de CDC en una MAC… nos aparecen muchos errores… existe un error en el codigo del archivo usb_config.h y el .c, gracias JEAN

Al final de este documento pongo un enlace a dichos archivos que deberán ser copiados a la carpeta

/tools/share/sdcc/include/pic16/usb    reemplazando los existentes… esta solucion tambien es factible para la nueva version 9.05

El error visto es algo asi:

__CODE

__DATA

El link de descarga es el siguiente.

http://rapidshare.com/files/432256020/uso_CONFIG.zip

Para los que usen la version de macOSX existe tambien un problema con la version del teclado de ESPAÑOL ISO que hace que no aparezcan la llave abierta y el corchete abierto… eso no pasa si tenemos la configuración del teclado en ingles… según lo comentado con JEAN lo solucionara en la version 9.05

saludos.

Aqui os enseño el ultimo proyecto que he creado, basandome en el famoso ARDRONE, quice intentar reproducir el control utilizando un IPHONE, conectado por WIFI, y asi dar ordenes via TOUCHOSC al PROCESSING y este via puerto USB enviar la informacion recibida a un PINGUINO el cual tiene como tarea mover el motor BRUSHLESS…

La tarea es sensilla.

[IPHONE (+TouchOSC)]—wifi—>[OSx(+PROCESSING)]—usb—>[PINGUINO(+brushless)]

Siento lo del audio, pero sin querer capture el video con el microfono de la webcam, por ende “Horrible”

Esto es una muestra de lo que podemos hacer con las herramientas y el tiempo necesario.

En cuanto tenga un segundo, subo el perfil de TOUCHOSC, el codigo del PROCESSING y el de PINGUINO.

Saludos.

Gracias el consejo de varias personas que han utilizado la tienda, he visto que tiene problemas de visualizacion en OPERA y CHROME…

Se recomienda el uso de Internet Explorer y Safari.

Igualmente he incluido los productos en una nueva web que tengo ONline… la cual para quien quiera visitarla ya estan activos los productos PINGUINO…

el link es:
http://echollos.com/category.php?id_category=7

Basicamente son los mismos productos pero esta web es compatible con todos los Exploradores.Pronto incluire el link en la propia pagina.

    Esto es más que nada una ayuda memoria, para no tener que buscar en internet o en el oráculo. Estos circuitos están probados y si se sigue el esquema correctamente se obtienen buenos resultados.

Aquí vemos como conectar pulsadores o botones, ya sea para obtener una rampa positiva o negativa.

También vemos como conectar un termostato LM35.

Recordemos que este transistor posee un rango de medición muy grande, con una definición de 10mVolts por grado.

Pudiendo medir desde los -55º a los 150ºC operando en tensiones de 4 a 30Volts. Con solo 4 Volts puede medir su máximo que sería 150ºC.

Si obtenemos por ejemplo:

En la salida 1,5volts nuestra lectura es de +150ºC

Si tenemos 0,25Volts la lectura seria de +25ºC

Y el siguiente extremo es del -0,55Volts que representaría a -55ºC

Aquí vemos un sensor infrarrojo, el cual funciona a la perfección.

Verifiquen en su construcción que el diodo de receptor tiene que tener la patilla negativa hacia el positivo, o sea, conectada al resistor de 47K.

Por último tenemos como conectar un simple LED (pensando en una alimentación de 5 Volts).

También un LDR el cual nos ofrece una salida con positiva con pulsos invertidos, o rampa negativa.

Más adelante pondré los programas para utilizar cada uno.

    Gracias a muchas recomendaciones y búsquedas, he podido reducir el coste de producción del PIC y su programación. Así que lo tenemos con nuevo precio… ahora 14euros programado con la última versión del firmware.

También he conseguido precios orientativos para los kits completos (sin soldar), con el PCB, MICROCONTROLADOR y componentes básicos, por 39euros. Comparado con el precio de productos similares ARDUINOS, creo que estamos en el rango normal de precios.

Para los que quieran el PINGÜINO armado y soldado, listo para funcionar, creo que el precio orientativo puede ser de 50euros.

Actualmente con el número de ventas no es factible bajar el coste, mas adelante si el volumen de ventas aumenta, quizás podríamos reducir en 10 o 15% el valor de kits y componentes.

También para los que quieran comprar cantidad ( +5 kits, PICs o PCB), os recuerdo que tienen un descuento de un 5%.

Saludos.

Bueno hoy estoy con un proyecto fácil, pero que al principio de mis tiempos con PICs, me costó su trabajo.

Básicamente el proyecto toma 10 lecturas de temperatura con el sensor LM35 y 10 lecturas del LDR, luego realizamos el promedio de estas y lo imprimimos por el puerto serie, para más tarde hacer lo que queramos con estos valores. Graficarlos en una página web o simplemente en PROCESSING

El código es simple.

<blockquote>
/*
=============
Sensor de temperatura y luz
walii
Octubre 2010
*/
#define PIC18F4550
#define RUNLED PORTAbits.RA4
int samples[10];
int max=0;
int min=100;
int tempc=0;
int tempf=0;
int lux=0;
int i,x;
float val1;
float val2;

void setup() {
//Solo el serial es necesario para enviar los datos.
Serial.begin(9600);
}
void loop() {
//Realizamos un ARRAY para hacer un promedio de 10 mediciones
for (i=0;i<=9;i++){
val1=analogRead(13);
samples[i]=(4.65*val1*100)/1024.0;
tempc=tempc+samples[i];
delay(100);
}
//Dividimos por la misma cantidad de lecturas
tempc=tempc/10.0;
//Convertimos en Farhenheit
tempf=(tempc*9)/5+32;
//Capturamos los valores de minimos y maximos.
if(tempc>max){max=tempc;}
if(tempc<min){min=tempc;}

//Ahora le toca el turno a la luz, tomamos 10 lecturas
for (x=0;x<=9;x++){
val2=analogRead(16);
samples[x]=val2*100/1024.0;
lux=lux+samples[x];
delay(100);
}
//Dividimos el resultado por el mismo numero de lecturas
lux=100-(lux/10.0);
//Controlamos que las lecturas no sobrepasen los valores de 0-100.
if(lux>=100)lux=100;
if(lux<=0)lux=0;
//Imprimimos todo en el serial
Serial.print("Pinguino.walii.es");
Serial.print("\n\r");
Serial.print("#####################");
Serial.print("\n\r");
Serial.print("Temperatura: ");
Serial.print(tempc,DEC);
Serial.print(" C");
Serial.print("\n\r");
Serial.print("#####################");
Serial.print("\n\r");
Serial.print("Temp maxima: ");
Serial.print(max,DEC);
Serial.print(" C");
Serial.print("\n\r");
Serial.print("Temp minima: ");
Serial.print(min,DEC);
Serial.print(" C");
Serial.print("\n\r");
Serial.print("Temp fahrenheit: ");
Serial.print(tempf,DEC);
Serial.print(" F");
Serial.print("\n\r");
Serial.print("#####################");
Serial.print("\n\r");
Serial.print("Nivel de Luz: ");
Serial.print(lux,DEC);
Serial.print("%");
Serial.print("\n\r");
Serial.print("#####################");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
Serial.print("\n\r");
//indentificacion que todo funciona bien, el runled parpadea.
RUNLED=1;
delay(50);
RUNLED=0;
delay(50);
}

El sensor LM35 lo conectaremos en la puerta AN0, patilla numero2 o puerta 13 de nuestro PINGUINO 18f4550 (recordemos que por algún motivo JeanPear a cambiado los números de las patillas, pero viendo el diagrama nos ubicamos bien.)

El LDR para medir la incidencia de luz lo conectaremos en la puerta AN3, patilla numero 5 o puerta 16 de nuestro PINGÜINO 18f4550

Hola buenos días… hoy cumplo con una de las promesas y proyectos de mi tintero… un juego con detección de infrarrojos en los 360grados… con 4 sectores y uno adicional arriba.

Básicamente se compone de 5 sensores de infrarrojo que detectan cualquier obstáculo a menos de 30 centímetros, y lo traduce en un color diferente dependiendo de donde provenga el objeto… por ejemplo si ponemos un objeto o interceptamos el as del norte… el cubo cambiaría a rojo… si incidimos desde arriba cambiaría a blanco… y si incidimos desde cualquier otro lado, el cubo cambiaría de color.

Un ejemplo fotográfico de lo que he realizado… aunque no es un cubo en cuanto pueda conseguir un tooper que se adecue a las dimensiones… lo clono.

Un vídeo al respecto para que se entienda un poco más.

El circuito es fácil.

Los cuatro sensores infrarrojos se conectan en las 4 entradas analógicas 13, 14, 15 y 16, y las salidas digitales se conectan en los puertos 0, 1 y 2.

NOTA a mi: PONER CIRCUITO…

Un poco de código para condimentar y listo.

// Infrared sensors and RGB pinguino.walii.es
/** Vamos a tomar dos lecturas de cada infrarrojo, guardando la anterior en proxSenlast
para asi comparar luego cual es la diferencia, y si esta es mayor al diferencial es que
un objeto se interpuso en dicho sensor. Y ordena encender el color correspondiente.
**/
#define 18f4550
unsigned  int i;
// aqui configuramos cuanta es la diferencia de valores
unsigned int diferencial=20;
unsigned int finalproxSen;
unsigned int proxSenlast;
unsigned int proxSen1;
unsigned int finalproxSen1;
unsigned int proxSenlast1;
unsigned int proxSen2;
unsigned int finalproxSen2;
unsigned int proxSenlast2;
unsigned int proxSen3;
unsigned int finalproxSen3;
unsigned int proxSenlast3;
unsigned int proxSen4;
unsigned int finalproxSen4;
unsigned int proxSenlast4;
unsigned int proxSen;

void setup()
{
for (i=0;i<4;i++)     {
 pinMode(i,OUTPUT);
 digitalWrite(i,LOW);
 }
Serial.begin(9600); //opcional
}

void loop()
{
//tomamos la primer lectura
 proxSen=analogRead(13);
 proxSen1=analogRead(14);
 proxSen2=analogRead(15);
 proxSen3=analogRead(16);
 proxSen4=analogRead(17);
//si desean pueden excluir del codigo lo referente al serial.
//yo uso para debug.
/**
if (Serial.available())
 {
Serial.print("\n\r");
Serial.print("Distancia en digital: ");
Serial.print("\n\r");
Serial.print(proxSen,DEC);
Serial.print("\n\r");
Serial.print(proxSen1,DEC);
Serial.print("\n\r");
Serial.print(proxSen2,DEC);
Serial.print("\n\r");
Serial.print(proxSen3,DEC);
Serial.print("\n\r");
Serial.print(proxSen4,DEC);
Serial.print("\n\r");
 }
**/
//guardamos la lectura en "LAST" y esperamos 10 milisegundos
// para volver a leer la puerta
proxSenlast=proxSen;
delay(10);
proxSen=analogRead(13);
proxSenlast1=proxSen1;
delay(10);
proxSen1=analogRead(14);
proxSenlast2=proxSen2;
delay(10);
proxSen2=analogRead(15);
proxSenlast3=proxSen3;
delay(10);
proxSen3=analogRead(16);
proxSenlast4=proxSen4;
delay(10);
proxSen4=analogRead(17);

//restamos los valores obtenidos y obtenemos el diferencial en cada caso
if (proxSen>=proxSenlast) {
finalproxSen=proxSen-proxSenlast;
}else{
finalproxSen=proxSenlast-proxSen;
}
if (proxSen1>=proxSenlast1) {
finalproxSen1=proxSen1-proxSenlast1;
}else{
finalproxSen1=proxSenlast1-proxSen1;
}
if (proxSen2>=proxSenlast2) {
finalproxSen2=proxSen2-proxSenlast2;
}else{
finalproxSen2=proxSenlast2-proxSen2;
}
if (proxSen3>=proxSenlast3) {
finalproxSen3=proxSen3-proxSenlast3;
}else{
finalproxSen3=proxSenlast3-proxSen3;
}
if (proxSen4>=proxSenlast4) {
finalproxSen4=proxSen4-proxSenlast4;
}else{
finalproxSen4=proxSenlast4-proxSen4;
}

//Con el diferencia u la lectura sabemos si un objeto se interpuso.
if(finalproxSen>diferencial) {
digitalWrite(0,HIGH);
digitalWrite(1,HIGH);
digitalWrite(2,HIGH);
};
if(finalproxSen1>diferencial) {
digitalWrite(0,LOW);
digitalWrite(1,HIGH);
digitalWrite(2,LOW);
};
if(finalproxSen2>diferencial) {
digitalWrite(0,LOW);
digitalWrite(1,LOW);
digitalWrite(2,HIGH);
};
if(finalproxSen3>diferencial) {
digitalWrite(0,HIGH);
digitalWrite(1,LOW);
digitalWrite(2,HIGH);
};
if(finalproxSen4>diferencial) {
digitalWrite(0,HIGH);
digitalWrite(1,LOW);
digitalWrite(2,LOW);
};
}

Aquí el invento por dentro.

Izquierda los 3 leds RGB con tres transistores para descargar de trabajo al PIC, y a la derecha el cacharo con los sensores infrarrojos.

aquí se pueden observar los sensores infrarrojos.

En cuanto pueda os subo los circuitos, porque siempre es bueno tener circuito de sensores y fase de potencia RGB

Como mucha gente me lo ha solicitado, dispongo una lista de los componentes necesarios para hacernos una placa de PINGUINO… Obviamente no incluyo el programador o los cables… pero son cosas que se necesitan… por lo menos la primera vez…

También os dejo a su gusto la elección, ya que cada uno puede hacerlo como más os guste, en su propia PCB o en un PROTOBOARD, o en el aire… como quieran… por ejemplo en un PROTOBOARD ya no necesitarían el conector USB, ya que con un cable viejo de un RATON USB, podrían construirse el adaptador a tal efecto. Fuente en realidad no se necesita, porque sacamos la energía del puerto USB, pero recordar que los puertos USB de ordenadores ofrecen solo una corriente de 500mA y esto puede no ser suficiente para algunos casos.

    Los componentes necesarios son:

    1x Placa PCB (preferiblemente la comprada en PINGÜINO.WALII.ES ) J

1x PIC 18f4550*(Programado, la mejor forma comprarlo en PINGÜINO.walii.es) J

1x Zócalo 40 pines para PIC*

1x Cristal 20Mhz*

1x Capacitor 470nf tantalio (tiene que ser lo más exacto y estable posible)*

2x Capacitor de 22pf cerámico para el oscilador*

2x Capacitor de 100nf para el filtrado de la fuente*

1x Capacitor de 10uf para el botón de reset*

2x Leds del color que queramos

2x Resistencia de 470ohm 1/4watts*

2x Resistencia de 330ohm 1/4watts*

1x Resistencia de 10Kohm 1/4watts*

1x Conector USB Hembra clase B (el de las impresoras)*

1x Botón pulsador para el reset, recordar que tiene que ser de dos patillas, para que encastre perfectamente en el diseño del PCB*

Y todos los conectores y pines que queramos poner, según gustos, hay gente que no pone nada y suelda los cables directamente al PCB.

(120 pines machos, para la imagen de la web, para por ejemplo, control de sensores o servomotores)

(60 pines hembras, si queremos utilizar nuestro pingüino como si fuese de un protoboard, recomendado para pruebas y comenzar)

(sin pines, para el que desee soldar los cables directamente en la placa, y dejar nuestro PINGÜINO definitivo en su sitio)

Componentes opcionales:

Si utilizaremos fuente de alimentación de 12 volts:

1x 7805 (regulador de 5volts 1Amp)

1x diodo de 1Amp por ejemplo 1n4001

1x capacitor de 10uf de 5 volts o más, solo para estabilizar la salida del 7805.

Si queremos utilizar el puerto serie con un router tipo fonera:

2x diodos zener 3,3volts 1/4watts

Si utilizaremos panel solar para alimentar el PINGÜINO:

1x diodo de 1Amp por ejemplo 1n4001

Saludos.

Hola Buenos días a todos, hoy tras una promesa a RAFAEL, os traigo la nueva versión del instalador de pingüino.

No solo he incluido todo el materia nuevo desde la versión 9.02 con todo lo nuevo que trae consigo, sino también el ultimo MAIN.C el cual soluciona un problema con el puerto serie (fresquito fresquito, de ayer mismo), también he incluido para la gente que no tiene instalado PINGÜINO y/o quiere hacerlo desde cero, todos los paquetes necesarios (esto último como recomendación especial de JEAN).

PASOS A SEGUIR:

Cuando iniciemos la instalación, nos pedirá toda la info necesaria para instalar PINGÜINO (directorios y nombres de programa), y antes de finalizar con la instalación de PINGUINO, comienza la instalación de los paquetes necesarios para que este funcione (omitir estos pasos para lo que ya tengan un PINGÜINO funcionando) de PYTHON, WXPYTHON, PYUSB y LIBUSB, en ese orden, dejando todo perfectamente atado para que alguien que nunca uso PINGÜINO tenga una instalación funcional en pocos pasos y sin necesidad de descargar nada.

Para quien ya tenga una instalación funcional de pingüino, os recomiendo cancelar los 4 instaladores, y luego proseguir con la instalación de pingüino propiamente dicha. Más que nada para no tener aplicaciones duplicadas en su Windows. Por ejemplo, por necesidad extras, yo tengo instalado el PYTHON 2.6 y no necesito el PYTHON 2.5 que trae el instalador, entonces le doy “CANCEL” cuando comienza la instalación de dicho programa, y salto este paso…. Lo mismo con todos los demás, y dejamos que finalice la instalación de pingüino.

Otro punto adicional y que siempre me ha gustado, es que ahora tenemos links directos a todos los diagramas necesarios, Pingüino 18f2550, pingüino 18f4550, diagramas DCE y DTE y conexión de serie a FONERA. Uso a diario estos diagramas y me gusta tenerlos a golpe de ratón. (TENGO MUY MALA MEMORIA)

NOTA: Tras un problema en la ultima version, ahora he corregido la nueva y solucionado los problemas de instalacion de PYTHON.

LINK DE DESCARGA MEGAUPLOAD

LINK DE DESCARGA RAPIDSHARE

Saludos y espero que os guste la nueva versión.

    Para los más prolijos, he creado un instalador automático de la beta 9.01, el cual instala la versión en “Archivos de programas” si tenemos la versión de Windows en español, o en su defecto en “Program Files” si tenemos otras versiones.

También se sitúa tanto en el directorio de instalación como en el grupo de programas con el nombre “hackingLab” y dentro de este en un vínculo con el nombre de la versión, para que todas las nuevas versiones puedan convivir sin sobre-escribirse.

El vínculo de descarga es el siguiente:

http://rapidshare.com/files/414840511/PinguinoPic_beta9.01_Setup.exe.html

Y Aquí algunas capturas del instalador:

Una vez dentro del instalador nos pedirá el directorio donde queremos instalarlo, por defecto le he puesto el comentado anteriormente.

Luego nos pregunta el grupo de programas, en este caso el por defecto es “HackinLab”

y también nos da la opción de agregar o no iconos en el escritorio o en el lanzador rápido de Windows.

En el siguiente paso nos muestra lo que va a ocurrir y donde instalará todo y luego el progreso de instalación.

Por último el instalador ofrece la opción de visitar la página web y/o iniciar el programa.

Y a la derecha vemos el icono que se instala en el escritorio. (No os preocupéis, mas adelante lo embelleceré).

Saludos.

Aquí un diseño rápido y educativo de PINGUINO, utilizando las librerías de servos he realizado este seguidor de sol, para nuestros proyectos solares….

// Seguidor solar con libreria de servo beta9
// Walii walterleonardo@gmail.com 2010
#define PIC18F4550
uchar pos = 0; // Variable to store the servo position.
int inputPhotoLeft = 13; //LDR left sensor
int inputPhotoRight = 14; //LDR right sensor
int Left = 0; // Store readings from the photoresistors.
int Right = 0; // Store readings from the photoresistors.
int servo1 = 0; // Attach servo to pin 0.
void setup()
{
servo.attach(servo1);
}
void loop()
{
// Reads the values from the photoresistors to the Left and Right variables.
Left = analogRead(inputPhotoLeft);
Right = analogRead(inputPhotoRight);
// Checks if right is greater than left, if so move to right.
if (Left > (Right +10))
// +10 is the deadzone, so it won't jiggle back and forth.
{
if (pos < 179) pos++; servo.write(servo1,pos); } // Checks if left is greater than right, if so move to //left. if (Right > (Left +10))
// +10 is the deadzone, so it won't jiggle back and forth.
{
if (pos > 1)
pos -= 1;
servo.write(servo1,pos);
}
// Added ALOT of delay, increase or decrease if you want less or more speed.
delay(70);
}

Saludos

Me puse a pensar en reconstruir mi fuente de alimentación y se me ocurrió que porque no hacerla con PINGÜINO…

Tenía un LCD de 2×16… y pensé, es suficiente para poder ver el voltaje y la corriente consumida… además más adelante puedo hacer un control para subir o bajar la tensión de salida…

El circuito lo estoy terminando, en cuanto lo tenga lo subo.

Pero por ahora lo dejamos en el display…

En este caso mide la tensión (voltaje) que le llega a PINGÜINO y utilizando la ley de OHM y una resistencia de 1 OHM 1Watt … he realizado una medición del consumo del LCD…

He utilizando la idea del display de 4bits… para mi suficiente. El código está en la web… modificando un poco este código y agregando parametrizaciones de valores digitales, he podido llegar a una lectura casi real del voltaje leído.

Ya que nuestro puerto analógico lee el voltaje en su conector, con una división digital de 10bits. O sea “en criollo”, que donde dice 1023 en realidad quiere decir 5volts… y donde lee 512 quiere decir 2,5volts. Con estos datos y una regla de tres simple… se obtiene.

volt0=analogRead(16) /16*78;
obteniendo de las lecturas por ejemplo:
1023 = 4980mVolts = 4,98Volts
512 = 2490mVolts = 2,49Volts
256 = 1240mVolts = 1,24Volts
128 = 0640mvolts = 0,64Volts

Y obtenemos un valor muy similar a la realidad, claro en milivolts. Y con un problema de lectura, porque la librería (FLOW) no nos permite el punto decimal.

Para la corriente (Consumo) he realizado el archi-conocido como diferencia de potenciales a través de una resistencia de 1 OHM, no es exacto y en cuanto pueda lo modifico pero para ver el resultado en pantalla es perfecto…

Lo que hago es tomar dos mediciones, una en cada pata de una resistencia de 1 OHM, la cual se encuentra en serie con la fuente de alimentación, por ende la diferencia en la caída de tensión en esta resistencia, es proporcional a la corriente suministrada.

amp1=analogRead(13);
amp2=analogRead(15);
amp1=amp1/16*78;
amp2=amp2/16*78;
if (amp1>amp2){
amp0 = amp1-amp2;
}
else{
amp0 = 0;
}

También he utilizado un machete que he encontrado en la web de hackinglab para convertir los datos.

El código completo es:

// POWER SUPPLY LCD
//
// Author: walii.es walterleonardo@gmail.com
//
#define LCD_RS 8
#define LCD_E 9
uchar text1;
uchar text2;
void lcdPulseEnable() {
digitalWrite(LCD_E, HIGH);
delayMicroseconds(1);
digitalWrite(LCD_E, LOW);
delayMicroseconds(1);
}
void lcdWriteNibble(uchar c){
int i;
for(i=0; i<4; i++){
digitalWrite(4+i, (c >> i) & 0x01);
}
lcdPulseEnable();
}
void lcdWriteByte(uchar c, int mode) {
digitalWrite(LCD_RS, mode);
lcdWriteNibble(c >> 4);
lcdWriteNibble(c);
}
void lcdSendControl(uchar c) {
lcdWriteByte(c, LOW);
}
void lcdSendData(uchar c) {
lcdWriteByte(c, HIGH);
}
void lcdSetAddress(uchar line, uchar column) {
lcdSendControl( 0x80 + 0x40 * (line - 1) + (column - 1));
}
void lcdPrint(char *string) {
int i;
for( i=0; string[i]; i++) {
lcdSendData(string[i]);
}
}
void Int2Char(char *Result, unsigned int ToConvert)
{
uchar Digit[5];
int c;
unsigned int H1,H2,H3;
H1=ToConvert;
H2=0;
H3=10000;
for (c=4;c>=0;c--)
{
Digit

1

= H1/H3;
H1=ToConvert-Digit

1

*H3-H2;
H2=H2+Digit

1

*H3;
H3=H3/10;
Result[4-c]=Digit

1

+48;
}
}
void lcdInit() {
int i;
pinMode(LCD_E, OUTPUT);
digitalWrite(LCD_E, LOW);
pinMode(LCD_RS, OUTPUT);
digitalWrite(LCD_RS, LOW);
for(i = 4; i < 8; i++) {
pinMode(i, OUTPUT);
}
delay(20);
lcdWriteNibble(0x03);
delayMicroseconds(1);
lcdWriteNibble(0x03);
delayMicroseconds(1);
lcdWriteNibble(0x02);
delayMicroseconds(200);
lcdSendControl(0x28); // 4 Bit, 2 Lines
delayMicroseconds(1);
lcdSendControl(0x0C); // Display On
delayMicroseconds(1);
lcdSendControl(0x01); // Clear display
delay(2);
lcdSendControl(0x02); // Cursor home
delay(2);
}
uchar line1[] = "Pinguino MADRID";
uchar line2[] = "Voltimetro walii.es";
uchar line3[] = "walii.es";
uchar line4[] = "Voltaje Consumo";
uchar volts[] = "mV ";
uchar amper[] = "mA ";
uchar Amp[5];
uchar Volt[5];
void setup() {
lcdInit();
}
void loop() {
int amp1;
int amp2;
unsigned int amp0;
unsigned int volt1;
amp1=analogRead(13);
amp2=analogRead(15);
amp1=amp1/16*78;
amp2=amp2/16*78;
if (amp1>amp2){
amp0 = amp1-amp2;
}
else{
amp0 = 0;
}
Int2Char(Amp,amp0);
volt1=(float)analogRead(16); //QUITAR ESTE FLOAT SI SE QUIERE COMPILAR EN B9.01
volt1=volt1/16*78;
Int2Char(Volt,volt1);
lcdSendControl(0x01);
delay(2);
lcdSendControl(0x02);
delay(2);
lcdSetAddress(1, 1);
lcdPrint(line1);
lcdSetAddress(2, 1);
lcdPrint(Volt);
lcdSetAddress(2, 6);
lcdPrint(volts);
lcdSetAddress(2, 9);
lcdPrint(Amp);
lcdSetAddress(2, 14);
lcdPrint(amper);
delay(1000);
lcdSendControl(0x01);
delay(2);
lcdSendControl(0x02);
delay(2);
lcdSetAddress(1, 1);
lcdPrint(line4);
lcdSetAddress(2, 1);
lcdPrint(Volt);
lcdSetAddress(2, 6);
lcdPrint(volts);
lcdSetAddress(2, 9);
lcdPrint(Amp);
lcdSetAddress(2, 14);
lcdPrint(amper);
delay(1000);
}

NOTA: para que el código funcione en la ultima version de PINGUINO la beta9.01 
necesitamos quitar el (float) de la linea 111, utilizada para el analogRead... 
que parece que hay un problema en la nueva version con las variables... 
lo voy a estudiar... esta version la había compilado en el IDE 8 por eso 
no vi el inconveniente... lo siento.

Lo primero de todo es agradecer a JEAN… gracias a él estoy probando desde ayer la nueva versión de interfaz gráfica de PINGÜINO la versión BETA9… que a diferencia de otros proveedores cada versión tiene un millón de cosas nuevas…

Según JEAN, la tendrá lista para salir a la calle en un par de días. Pero la beta que he probado yo la veo bien madura… J

Tenemos una nueva interfaz gráfica, que aunque parecida a la anterior, ahora mucho más flexible… pudiendo re dimensionar las ventanas de debug y código y cambiarlas de posición… una hermosura.

Después también tenemos posibilidad de poner nuevas librerías, propias, creadas o prestadas… de una forma muy práctica y flexible.

Entre los adelantos son:

La inclusión de una librería de servos… para facilitarnos la vida con los robots.

Librerías matemáticas

Librerías para control de puerto SPI, para dialogo con el chip de microchip ZIGBEE.

Hola…buenas noticias, tengo en mi poder las placas PCB de PINGÜINO….

Muy bonitas y al ser las primeras, con muy pocos fallos… por suerte.

Según tengo entendido salieron de china el 1 de julio así que tardaron 15 días en llegar.

El lunes comenzaré su distribución, por orden de pedido, quien desee alguna mas es ahora el momento de solicitarla.

Estoy meditando el tema de KITs armados, porque la verdad que me ha llevado mucho tiempo soldar todos los componentes y si calculo el coste por hora de trabajo, me parece que debería venderlas como mínimo 50euros… me parece que solo hare alguna para que me quede de recuerdo armada y como un pingüino de colección.

Igual ya he pedido presupuesto para los KITs para armar, y vender la placa y sus componentes sin soldar, así me quito ese tema y me dedico directamente a inventar que es lo que me gusta.

Mucha gente me ha solicitado el listado de componentes, así que aquí os lo indico.

Listado de componentes.

Mínimos necesarios para que funcione PINGUINO:

1x PIC 18f4550

1x Zócalo 40 pines para PIC

1x Cristal 20Mhz

1x Capacitor 470nf tantalio (tiene que ser lo más exacto y estable posible)

2x Capacitor de 22pf cerámico para el oscilador

1x Capacitor de 100nf para el filtrado de la fuente

1x Capacitor de 10uf para el botón de reset

2x Leds del color que queramos

2x Resistencia de 470ohm 1/4watts

2x Resistencia de 330ohm 1/4watts

1x Resistencia de 10Kohm 1/4watts

1x Conector USB Hembra clase B (el de las impresoras)

1x Botón pulsador para el reset, recordar que tiene que ser de dos patillas, para que encastre perfectamente en el diseño del PCB

Y todos los conectores y pines que queramos poner, según gustos, hay gente que no pone nada y suelda los cables directamente al PCB.

Componentes opcionales:

Si utilizaremos fuente de alimentación de 12 volts:

1x 7805 (regulador de 5volts 1Amp)

1x diodo de 1amp por ejemplo 1n4001

1x capacitor de 47uf o de menor valor, solo para estabilizar la salida del 7805.

Si queremos utilizar el puerto serie con un router tipo fonera:

2x diodos zener 3,3volts 1/4watts

Si utilizaremos panel solar para alimentar el PINGÜINO:

1x diodo de 1amp por ejemplo 1n4001

Aquí las fotos… y el primer kit armado.

Paso a paso

1º Deberemos soldar los componentes que se encuentran debajo del PIC.

2º ahora podemos colocar el zocalo del PIC y verificar que los componentes no molesten, quizas debamos mover un poco la resistencia de 330r de debajo, porque depende la distancia que dejemos a la placa puede elevar el zocalo o no.

3º En este punto ya podemos instalar todos los demás componentes y pines de conexión, no es necesario poner algunas cosas pero al ser el primero me gusto llenarlo de tonterías.

Quizás la fuente de 12 volts no sea necesaria y la parte del ISCP no la utilicemos nunca, o quizás la salida serie para routers del estilo fonera no nos interese.

4ºCuando tenemos todo menos el PIC, deberemos probar que funciona, conectando el cable usb, y verificando que enciende correctamente el led mas cercano a este conector.

5º Si el led se enciende deberemos comprobar que la alimentación del PIC en sus conexiones centrales es correcta en cuanto a valor y polaridad.

6º Ahora sí, con el pic programado con el último boot procederemos a conectarlo y verificar que todo sigue funcionando y que nuestro Windows/mac/Linux detecta el PINGÜINO conectado a un puerto USB

NOTA: Existen algunos errores que he cometido por inexperiencia, al ser mi primer placa fabricada en serie, que aunque he verificado mucho el diseño y lo he puesto ONLINE para que me echen una mano, con la emoción del momento se me han pasado algunas cosillas.

1º El capacitor de 220uf que aparece cerca de la palabra pingüino, en realidad es un Tantalio de 470nf sin polaridad (no sé que me paso!!!).

2º Más que error esta es una recomendación, el capacitor de 470uf que filtra la fuente de 12volts al pasar por el 7805, quizás debería ser más pequeño porque uno de ese valor puede ser muy voluminoso, en la foto le he puesto uno de 47uf, así que deberíamos quitarle un cero.

3º El ICSP no funciona porque se me ha pasado colocar un JUMPER en la patilla 1 del PIC. Pero la verdad que esto no lo utilizaríamos para mucho, ya que solo pondremos el HEX del boot una vez por PIC.

Para todos los interesados, la gente de MakePCB nos ha respondido con algo bueno, según ellos, el producto ha salido de la fábrica y dispone a ser enviado…

Se supone que a corto plazo tendremos las placas para ser distribuidas.

Por el tema de envíos para quienes me han consultado tengo valores aproximados que pueden ser:

R.Moreira (Portugal) tanto para Portugal como para Canarias, estoy haciendo el mismo coste de envío que para España, asumiendo la diferencia.

6.- euros. (Con código de seguimiento y seguro)

J.Fernandez (Peru)  &  F.Lopez (Argentina)  &  E.Sanchez (Argentina)  &     J.Sancristobal (Chile) debajo indico el coste Internacional.

Para envíos Internacionales

El precio por unidad es el que aparece en la web (11 euros) puede incluir un chip y una placa PCB. Pero para pedidos superiores a 1 unidad necesito saber exactamente el número, porque dependiendo el peso y destino el coste de envío es diferente.
saludos y a esperar las dichosas PCBs.

Hoy voy a compartir una herramienta que ya es difícil conseguir (por lo menos en mi caso, quise repetir el modelo que tenia, y solo lo he encontrado entre mis backups), un programador USB, para quienes como yo, se les complica programar micro controladores en los ordenadores modernos, sin puertos SERIE.

Es un programador basado en el GTP-USB, pero en este caso, libre (OPENSOURCE).

El único inconveniente es que solo puede ser utilizado por la versión de WINPIC800 3.55b, lo cual no es un problema si tenemos de donde conseguir esta versión.

El circuito es el siguiente:

El código a programar el PIC 18f2550, el programa winpic800 y varios diagramas electrónicos están aquí: LINK

NOTA: RECORDEMOS QUE NECESITAMOS que algún amigo o conocido o desconocido nos facilite UN PROGRAMADOR QUE FUNCIONE PARA PODER ESCRIBIR EL .HEX EN EL 18F2550.

TRUCO NECESARIO: NO OLVIDEN EL CAPACITOR DE 100NF TIENE QUE ESTAR LO MAS CERCA POSIBLE AL CHIP PARA EVITAR INTERFERENCIAS, SINO PUEDE QUE NUESTRO PROGRAMADOR SOLO LEA Y NO ESCRIBA LOS MICRO CONTROLADORES.

Pasos a seguir.

1. Descargamos todo lo necesario del link anterior.

2. construimos el programador y conectamos el PIC 18f2550 programado con el HEX que se incluye en el link.

Conectamos todo el circuito en el USB del ordenador, tenemos que ver como detecta un dispositivo y nos informa que no posee controlador para este.

Seleccionamos “No, no this time”, click “Next”

3. En la próxima ventana seleccionamos “Install from a list or specific location (Advanced)” , click “Next”

4. Cuando veamos que nos solicita un controlador, podemos ofrecerle el driver que nos aparece en el link, o bien dentro de la carpeta del WINPIC800(v3.55b), tendremos un directorio que se llama “winXP Driver”, en donde se encuentra el mismo controlador.

Ok… perfecto ya tenemos todos los pasos hechos y el programador detectado.

PROBAREMOS EL SOFTWARE DEL PROGRAMADOR, iniciamos el WINPIC800.

vamos a : Device > Hardware Test

Nos debería informar que todo está bien “Hardware OK!”

Luego conectamos el ICSP o un micro controlador en el zócalo para programarlo y vamos a la opción, “detectar PIC”

En este caso tengo conectado un 16f877 el cual identifica correctamente.

NOTA: OS RECOMIENDO HACER UN PROGRAMADOR CON SALIDA ICSP (PROGRAMACION SERIE DE IC) lo cual es muy útil para todo tipo de microcontroladores.

La salida ICSP es muy fácil y sencilla solo arman un conector de 5 pines, los cuales tienen estas conexiones (las cuales son las indicadas en todos los proyectos con microcontroladores):

Hay gente que lo ha hecho de diferentes formas y colores, pero tú puedes elegir… J

    Bueno… tras unas vacaciones reparadoras, vuelvo con ideas frescas…

Veamos como iniciamos nuevamente la marcha…

Proyectos ideados bajo el sol de Mallorca… J

1º entretenimiento para mi niña, así me deja pensar en otros proyectos… un generador de pompas de jabón… robótico… con un servo y un ventilador de ordenador… as ver que podemos hacer…

2º Finalizar el proyecto de robot seguidor de líneas y detector de obstáculos…

3º Finalizar proyecto de auto a control remoto vía wifi con el IPHONE

4º Comenzar el nuevo proyecto de control de jardines y espacios verdes con PINGÜINO (humedad, luminosidad, temperatura, etc. y si puedo, control de riego dependiendo el reporte del tiempo “si llueve en breve, no regar”)

5º Comenzar a rentabilizar la inversión en Zigbee… y darle algún uso… J

Veremos con que comenzamos primero…

Cualquier idea será bienvenida.

Gracias a joseluis ya tenemos otra cosa para ocupar el tiempo libre… J

NOTA IMPORTANTE

Para los que compraron placas PCB, quiero hacerles llegar mis disculpas, ya que según Niels de MakePCB (en mi última comunicación la semana pasada), la producción de las placas está retrasada porque no dan abasto en su construcción, gracias a un número muy grande de órdenes… les daré tiempo a contestar mi último correo del día de hoy, a ver qué novedades tienen, y si no me responden algo bueno, cancelare la orden y la realizare con otra compañía.

Al final lo barato sale caro.

    Navegando por el mar de internet, me encuentro con algo muy interesante, un osciloscopio de 6 canales tomando muestra de una resolución de 10bits de los puertos RA de un Arduino, me pregunte ¿porque no tenemos algo similar para pingüino? y me puse a ello.

En principio he cogido la versión creada por la web http://accrochages.drone.ws/ , la he modificado lo suficiente como para que pueda utilizarse con PINGÜINO en sus dos modalidades por puerto SERIE o también por USB, esta última es más recomendable por el ancho debanda y la practicidad de un solo conector.

El resultado es esto:

El código no lo he posteado porque es demasiado largo, pero he puesto las dos modalidades en internet para que puedan descargarlas.

Este es el vínculo para la versión USB

Y este otro es el vínculo de la versión por puerto Serie

Nota: al final de cada código de PROCESSING encontraran comentado el código para PINGuINO.