CUCHILLA MULTIUSO CON MATERIAL DE RECICLAJE

Como siempre me daba pena tirar los cepillos de dientes y no saber que hacer con ellos  pues he montado esta herramienta que me sirve para lijar los excesos de pintura en los prototipos de PCB antes de meterlos en acido, sujetar componentes, apalancarlos a la hora de dessoldarlos, sujetar smd para soldarlos, etc..

CUCHILLA MULTIUSO

Anuncios

UN DETECTOR NIVEL LOGICO DE MATERIAL DE RECICLAJE

Bueno siempre es muy util saber que nivel logico tenemos a la patilla de un integrado, pic, puerta, etc..

Como siempre me daba pena tirar los cepillos de dientes y no saber que hacer con ellos me monte este detector de nivel con el mango de un cepillo de dientes y un led, en el video no lo pone pero lleva incorporado un resistencia de 1 kohm para limitar la corriente del Led, pudiendo ver facilmente tensiones de +5 y +12 voltios de los circuitos logicos TTL y CMOS.

Esto no pretende ser ningun tutorial sino una idea mas para aprovechar estos cepilos, en el siguiente video muestro como lo hize.

UN DETECTOR NIVEL LOGICO

 

 

Un panel de control con Gtkdialog y svg

Aqui muestro este panel de control, que llevaba pensando hace tiempo pero gracias a un post de una personal de Puppy al final lo lleve a cabo.

Este panel simple pero que en el futuro se puede ir haciendo todo lo complejo que se quiera, abre un extenso campo para el montaje de frontales de equipos electronicos y control de programas.

El codigo es gracias a la gente del foro de puppy  de “Gtkdialog-tips” en ingles.

Con este panel se puede abrir un amplio abanico de posibilidades.

PANEL

Y el programa no lo podemos bajar desde :

http://murga-linux.com/puppy/viewtopic.php?mode=attach&id=87419

Bajarse el archivo descomprimirlo y para ejecutarlo meterse dentro del directorio /PANEL y ejecutar desde terminal

#  ./panel.sh

Puede que sea necesario darle permisos en tal caso:

 

# chmod 777 panel.sh

 

Bueno para ver como funciona picar con el raton sobre los botones.

En breve intentare hacer paneles mas complejos.

Espero resulte interesante nos vemos.

 

 

PROGRAMACION PUERTO SERIE EN C

Al igual que python podemos usar un control del puerto serie mediante el envio y recepcion de bytes y tambien control individual de cada una de sus patitas.

Para poder compilar estos programas deberemos  tener instalado el compilador en C   gcc que cada uno podra instalar desde su distribucion de Linux que este usando.

Para Puppy bastara con tener instalado el paquete devx_xxxx.sfs correspondiente a version de Puppy que este utilizando.

Primero vamos a ver un porgrama en el que podemos ver el control de las patitas de salida DTR y RTS mediante el programa que viene a continuacion:

Decir que siguiente codio lo adapte de la pagina web:

http://www.embeddedlinux.org.cn/EmbLinux/ch06lev1sec2.htm

Para el manejo de este programa hacemos uso de la estructura termios.

Para compilar este programa deberemos copiar el siguiente codigo en un archivo  y llamarlo  controlbits

y luego compilarlo mediante:

gcc -o controlbits controlbits.c

 

/*archivo controlbits.c

Para compilara el programa
gcc -o controlbits controlbits.c
*/

#include <stdio.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <termios.h>

struct termios tio;

int main(int argc, char *argv[])
{
int fd;
int status;

if (argc != 4)
   {

   printf(“Para ejecutar el programa  controlbits /dev/ttyS0 \n”);

   printf(“Para ejecutar el programa  controlbits /dev/ttyUSB0 \n”);
  return 1 ;
   }

if ((fd = open(argv[1],O_RDWR)) < 0)
   {
    printf(“No se puede abri el perto \n”,argv[1]);
   return 1;
   }
tcgetattr(fd, &tio);                           /*Consigue informacion del puerto*/
tio.c_cflag &= ~HUPCL;                /* Resetea el bit HUPCL */
tcsetattr(fd, TCSANOW, &tio);  /* set the termio information */

ioctl(fd, TIOCMGET, &status); /* Consigue el status del puerto serie */

if ( argv[2][0] == ‘1’ )      /* Pon a uno la linea  DTR  */
           status &= ~TIOCM_DTR;
      else
          status |= TIOCM_DTR; /* Si no a cero  */

if ( argv[3][0] == ‘1’ )      /* pon a uno la linea RTS */
          status &= ~TIOCM_RTS;
     else
          status |= TIOCM_RTS;  /* Si no a cero  */

ioctl(fd, TIOCMSET, &status); /* Varia al nuevo status las lineas del puerto serie */

close(fd);                    /* Cierra el puerto serie */
}

 

Bueno una vez  ya tenemos el archivo copiado y copilado vemos que nos aparece un fichero ejecutable que es controlbits.

Bueno vamos a tener en cuenta las siguiente imagen antes de ejecutar nada.

pines

En esta diagrama de pines de salida del puerto serie vemos que las lineas DTR y RTS corresponden a las lineas 4 y 7 respectivamente del puerto serie.

Asi que al igual que lo que haciamos en la programacion en python podemos coger un conector hembra DB9 al que tengamos acceso a los pines donde se sueldan los cables, conectaremos este conector al conector de salida del puerto serie del ordenador o en mi caso a un cable convertidor de USB-RS232, con las conexiones accesible de soldar por el otro lado.

Bueno ponemos con un polimetro midiendo tension en escala de 20 V en continua, la punta de masa a la masa del conector hembra o pin 5 de Signal Ground. y la otra punta positiva al pin 4 de DTR.

 

Y ejecutaremos desde el terminal el programa de la siguiente forma:

# controlbits /dev/ttyUSB0 0 0

Veremos que si los las tensiones del los pines para valores negativos oscilan entre  -3 y -15 voltios que corresponderia al valor True o alto y para tensiones positivas entre +3 y +15 voltios que corresponden al valor bajo o False.

En la anterior orden como le hemos dado la orden se ponga a cero o False la tension en el pin 4 de DTR estara en valor positivo osea entre +3 y +15 voltios, y lo mismo para el pin 7 o RTS.

Si ahora volvemos a ejecutar la orden:

# controlbits /dev/ttyUSB0 1 1

Veremos que la tension en ambas patas 4 y 7 basculan a tensiones negativas. y asi podemos hacer un control de las dos o individualmente  altenando los valors 0 0 , 0 1 ,  1 0 , 1 1.

Bueno al igual que la programacion en python , alguien podria estar preguntandose ahora para que programar las lineas individuales del puerto serie y la contestacion es la misma, bueno pues se pueden hacer circuitos muy interesantes y sencillos a niveles de pines, sin necesidad de utilizar el famoso max232, y ningun microcontrolador posterior.

Aunque si efectivamente se tiene mucho mas control y mucha mas versatilidad utilizando el puerto serie con un microcontrolador.

No obstante ahora mas adelante vamos a ver como enviar y recibir datos enteros o bytes atraves del puerto serie.

Pero por ejemplo utilizando de esta forma y mediante registros de desplazamiento podriamos crear buffer de datos  a transmitir o recibir por el puerto serie del tamaño que queramos,  8, 16 o mas bits.

Sin necesidad de crear una circuiteria muy compleja.

Yo tenia un articulo antiguo que mediante este metodo hacia contadores, capacimetro etc… si bien era mediante Visual Basic de Windows.

Hacer notar que yo utilizo un cable  USB convertidor de USB a RS232, aunque el ordenador que trabajo tiene puerto serie hoy en dia los ordenadores modernos ya no lo traen, con lo cual es necesario disponer de un cable de esto que por otro lado son muy baratos.

Si nos metemos en el directorio  /dev  veremos que nada mas conectar el cable  USB-RS232 al ordenador se nos aparece un archivo  ttyUSB0  y este archivo corresponde a este dispositivo, recordar que Linux utiliza todo como si fueran archivos.

Si conectaramos otro cable USB-RS232  nos apareceria otro archivo ttyUSB1 y asi sucesivamente.

Decir que los puertos serie de los ordenadores antiguos corresponden a los archivos  ttyS0 , ttyS1 , ttyS0  , o lo que corresponderia en windows los puertos Com0, Com1, Com2 etc..

Vamos a ver a hora la forma de leer los pines de entrada con el siguiente programa, que fue sacado del enlace que se muestra arriba:
/*
 Para compilarlo
gcc -o leer leer.c
 */

#include <stdio.h>
#include <sys/ioctl.h>
#include <fcntl.h>

#define DSR ‘D’+’S’+’R’
#define CTS ‘C’+’T’+’S’
#define DCD ‘D’+’C’+’D’
#define RI  ‘R’+’I’

int main(int argc, char *argv[])
{
  int fd;
  int status;
  unsigned int whichSignal;

  if (argc != 3)
    {

   printf(“Para ejecutar el programa  lee /dev/ttyS0 DSR  ò CTS ó DCD ò RI  \n”);

   printf(“Para ejecutar el programa  lee /dev/ttyUSB0  DSR  ò CTS ó DCD ò RI  \n”);

    return 1;
    }

/* Abre el puerto serie */
  if ((fd = open(argv[1],O_RDONLY)) < 0) {
    printf(“No puedo abrir el puerto  %s\n”,argv[1]);
    return 1;
  }

/* Consigue el estado del puerto */
  ioctl(fd, TIOCMGET, &status);

  whichSignal = argv[2][0]  + argv[2][1] +  argv[2][2];
 
  status &= ~TIOCM_DTR;         /* Estas dos lineas hacen que la linea DTR se ponga a 1   */
  ioctl(fd, TIOCMSET, &status);    /* Esto es que haya una tension negativa.   */

  switch (whichSignal) {
    case  DSR:
      status&TIOCM_DSR ? printf(“0”):printf(“1”);
      break;
    case  CTS:
      status&TIOCM_CTS ? printf(“0”):printf(“1”);
      break;
    case  DCD:
      status&TIOCM_CAR ? printf(“0”):printf(“1”);
      break;
    case  RI:
      status&TIOCM_RNG ? printf(“0”):printf(“1”);
      break;
    default:
      printf(“valor  %s desconocido, utilice DSR, CTS, DCD o RI”,argv[2]);
      break;
  }
  printf(“\n”);

/* Cierra el puerto */
  close(fd);
}

Una vez copiado este programa en un archivo de texteo y llamado  lee.c lo compilaremos mediante

# gcc -o lee lee.c

Antes de ello la que haremos en en nuestro conector hembra lo sacararemos del puerto serie y soldaremos un cablecito entre el pin DTR y pin DSR, el pin DTR es salida y lo hemos puesto a uno o valor negativo de tension y el pint DSR es entrada.

Bueno si ahora ejecutamos desde el terminal el programa

# lee /dev/tttyUSB0 DSR

Veremos que nos da una entrada de DSR un valor  TRue o  “1”

Si variamos la la linea del codigo de programa y en ve de la linea    status &= ~TIOCM_DTR;     ponemos la linea:

status |= TIOCM_DTR;

Esto hace que la linea DTR se ponga a cero valor negativo de tension, salvamos el programa y lo volvemos a compilar:

# gcc -o lee lee.c

Volvemos a ejecutar el programa:

# lee /dev/tttyUSB0 DSR

Bueno ahora podemos ver que nos da una entrada de DSR un valor  False o  “0”

En la proxima entrega veremos como mandar y enviar bytes por el puerto serie.

 

Bueno esto es todo hasta ahora continuare:

 

 

 

 

 

 

 

 

 

PROGRAMACION DEL PUERTO SERIE CON PYTHON

Para poder programar el puerto serie por python evidentemente tenemos que tener instalado python, que segun la distribucion de Linux que tengamos, Debian, Ubuntu, Mandriva lo instalaremos con el gestor de instalacion que tengamos.

En el caso de Puppy lo que tendremos que tener instalado es el archivo de  devx_xxxx.sfs cargado que nos permite no solamente programar en python, asi como en C, ensamblador, c++, perl, y un largo etc..

Pero ademas de una vez instalado pytho  debemos instalar el paquete.  pyserial que en mi caso me baje la version pyserial-2.7

Bajarse el paquete : pyserial-2.7.tar.gz  del enlace:

https://pypi.python.org/pypi/pyserial

Descomprimirlo y del directorio que se crea  el directorio  pyserial-2.7 meterse dentro
y dentro de este directorio ejecutar la orden :

python setup.py install

Con esto hace la instalacion del modulo  serial para python.
Si queremos comprobar como funciona hacemos lo siguiente:
Nos metemos dentro del terminal de python tecleando :

# python

una vez dentro:

# import serial

# s = serial.Serial(‘/dev/ttyUSB0’, 115200 )

Hacer notar que yo utilizo un cable  USB convertidor de USB a RS232, aunque el ordenador que trabajo tiene puerto serie hoy en dia los ordenadores modernos ya no lo traen, con lo cual es necesario disponer de un cable de esto que por otro lado son muy baratos.

Si nos metemos en el directorio  /dev  veremos que nada mas conectar el cable  USB-RS232 al ordenador se nos aparece un archivo  ttyUSB0  y este archivo corresponde a este dispositivo, recordar que Linux utiliza todo como si fueran archivos.

Si conectaramos otro cable USB-RS232  nos apareceria otro archivo ttyUSB1 y asi sucesivamente.

Decir que los puertos serie de los ordenadores antiguos corresponden a los archivos  ttyS0 , ttyS1 , ttyS0  , o lo que corresponderia en linux los puertos Com0, Com1, Com2 etc..

Bueno contiuando con lo anterior al ejecutar la orden: s = serial.Serial(‘/dev/ttyUSB0’, 115200 )

Esto nos abre el puerto serie de cable USB0 a RS232 y con una velocidad de 115200

Cogemos el polimetro y medimos entre masa y la patita 4 correspondiente a DTR y tecleamos:

# s.setDTR(False)

y veremos que la tension en la patita es de -6 v aproximadamente y luego tecleamos

# s.setDTR(True)

y veremos que la tension en la patita es de +6 v aproximadamente y luego tecleamos

Buen pues con todo esto ya tenemos un control total sobre el puerto serie por que podemos
enviar y recibir bytes enteros, y tener control individual sobre las lineas:

DTR, CTS, RTS, DSR , RI y CD

pines

Mediante la orden  getCTS(), getDSR(), getRI() y getCD() conseguimos los estados  de las entradas.

Si por ejemplo cogemos un conector hembra para de puerto Serie y soldamos un cablecito fino entre la patita 4 que es la salida DTR y la patita 6 que es una entrada DSR, conectamos el conector hembra al conector macho del cable USB-RS232 y tecleamos las siguientes ordenes:

# s.setDTR(False)

Esto hara que nos aparezca una tension positiva entre la patita 4 y masa que puede oscilar entre +3 y +12 V aproximadamente, esta tension como tenemos echo el puente con la patita 6 se nos mete en esta entrada, si ahora tecleamos la orden:

# s.getDSR()     Veremos que nos responde:

# False 

Por que considera que este estado es falso.

Si ahora tecleamos la orden:

# s.setDTR(True)

Y de nuevo ejecutamos seguido la orden:

# s.getDSR()     Veremos que nos responde:

# True 

Por que si ahora medimos la tension entre  la patita 4 y masa aparece una tension negativa que puede oscilar entre -3 y -12 V que es lo que considera que es un valor alto.

Y algunos se pueden estar preguntando para que quiero yo controlar el puerto serie a nivel de pines, bueno pues se pueden hacer circuitos muy interesantes y sencillos a niveles de pines, sin necesidad de utilizar el famoso max232, y ningun microcontrolador posterior.

Aunque si efectivamente se tiene mucho mas control y mucha mas versatilidad utilizando el puerto serie con un microcontrolador.

No obstante ahora mas adelante vamos a ver como enviar y recibir datos enteros o bytes atraves del puerto serie.

Pero por ejemplo utilizando de esta forma y mediante registros de desplazamiento podriamos crear buffer de datos  a transmitir o recibir por el puerto serie del tamaño que queramos,  8, 16 o mas bits.

Sin necesidad de crear una circuiteria muy compleja.

Yo tenia un articulo antiguo que mediante este metodo hacia contadores, capacimetro etc… si bien era mediante Visual Basic de Windows.

Bueno ahora vamos a probar el envio de bytes completos atraves del puerto serie, para ello sin salirnos del terminal de python que tenemos abierto, le quitamos al conector DB9 el puente que teniamos echo entre la patita 4 y la 6.

Teniendo puesto el conector hembra enchuado sobre la salida del conector macho del cable USB-DB9 tecleamos en una sola linea y digo que solo en una sola linea continua la siguiente orden:

>>>  s.timeout = 2 ;  text = “Hola” ;  s.write(text) ;  val = s.read(4) ;  print “Enviado:     ” +  val  ;

Apretamos Enter y nos tarda dos segundos en darnos la respuesta

4

Enviado

Pero de la cadena enviada nada,  pero si ahora apretamos la tecla de la flechita hacia arriba nos aparece la misma orden sin que la tengamos que escribir, pero esta vez con la punta del destornillador hacemos un cortocircuito entre la patitas 2 y 3 que asoman por detras del conector hembra DB9 , (comprobar que efectivamente son las patitas 2 y 3 ) y como digo con la tecla de flecha arriba volvemos a sacar la orden:

>>>  s.timeout = 2 ;  text = “Hola” ;  s.write(text) ;  val = s.read(4) ;  print “Enviado:     ” +  val  ;

Apretamos de nuevo enter y con el cortocircuito mantenido sobre las patitas 2 y 3 vemos.

4

Enviado Hola

Como se puede comprender hemos  conectado la salida del puerto serie a la entrada de datos y ahora si los recibe claramente, la explicacion a la funcion:

>>>  s.timeout = 2 ;  text = “Hola” ;  s.write(text) ;  val = s.read(4) ;  print “Enviado:     ” +  val  ;

es la siguiente:

s.timeout =2        Hace un t imeout de 2 segundos si  a los dos segundos no llega ningun dato entonces se sale de la recepcion de datos por el puerto serie, si no hicieramos esto se quedaria en espera todo el rato y entonces tendriamos que hacer un   Ctr + C para poder salir de esa situacion engorrosa.

text=”Hola”   asigna un texto de cuatro letras a la variable text

hl  Envia el texto por el puerto serie.

val=s.read(4)  Recibe el texto enviado y le decimos que ese texto tiene 4 bytes esto es interesante para que no espere mas.

print “Enviado:    ” + val        Prensenta en el terminal el texto recibido.

Bueno hasta aqui es todo con python mas adelante pondre mas adelante, aunque yo uso de forma mas habitual para el puerto C programacion en C por cuestion unicamente de costrumbre.

saludos

PROGRAMACION DEL PUERTO SERIE

Inicio aqui un apasionante tema que es la programacion del puerto serie que nos puede servir para infinidad de aplicaciones como es comunicarnos con los equipos que montamos.

Asi yo lo utilizo con multiples equipos como voltimetros, amperimetros, capacimetros, generador, el PWM y una infinidad de equipos.

El puerto serie lo podemos programarlos mediante python, lenguaje C, script, Java, Delphi, y un largo etc..

Yo voy a mostrar la forma de programarlo, primero por python, luego por C y luego mediante script.

Entre los proyectos que estoy intantando hacer ahora inmediatamente son un comunicador por infarrojo por el puerto serie para comunicarme con distintos equipos y asi de esta forma evitarse los cableados tan molestos para comunicacion de equipos.

Bueno pues vamos a empezar:

PROGRAMACION DEL PUERTO SERIE EN PYTHON

https://misterelectronico.wordpress.com/2015/05/02/programacion-del-puerto-serie-con-python/

 

PROGRAMACION DEL PUERTO SERIE EN C


https://misterelectronico.wordpress.com/2015/05/03/programacion-puerto-serie-en-c/