Taller xD II

Taller xD

Rasti Tecnico !! otro recuerdo de infancia T_T

Motobox45 mi manual!!! T_T que recuerdo....

PicProg

Un programador económico que no funciona muy bien con el adaptador USB-RS232, pero si con un puerto serial nativo, con algunas placas madre tiene problemas para programar bien el uC, las que posean el chip GD75232 no hubo ningún inconvenientes xD...

http://hyvatti.iki.fi/~jaakko/pic/picprog.html

Programador ICD2

El programador FreeICD2 armado y funcionando xD con el adaptador USB-RS232
con el chip PL-2303.

Piklab en accion!!

Piklab es un completo IDE para PIC y DSPIC, podemos programar en ASM (Gputils) o usando compiladores como SDCC, JAL, PICC lite compiler, etc.
Tiene soporte para varios tipos de programadores, como los clasicos por el puerto serial y paralelo, lo mas interesante podemos usar los ICD1 y 2 jeje de lujo xD. "programando un 16F628A"

ktechlab !! un completo simulador de electronica y pic

Aqui lo tienen funcionando, simulamos un viejo amigo16F84, cuando presionamos el pulsador se enciende un LED, sencillo no? pero bueno xD

Datalogger Parte II

El esquematico esta echo con Geda y el codigo de PHP mas abajo, sencillo por cierto xD. Para conectar a la computadora usamos el MAX232, en los pines RC6 y RC7 del pic, cualquier duda pueden bajarse la hoja de datos de ambos o preguntarme ^^.

Datalogger Parte I

Aqui le muestro una mescla de lenguajes, porque una mescla? bueno usamos python, MySQL y PHP para nuestro datalogger.
Funciona de la siguente manera: Python mediante el puerto serial le pide un byte del canal analogico del pic, cada segundo, este byte se guarda en una base de datos en MySQL el cual luego puede ser monitorizada via web.
En la entrada analogica del pic pueden poner cualquier tipo de señal entre 0-5V
como un LDR, potenciometro, sensor de temperatura (LM35) etc:
Le paso el codigo en python, recuerden la identacion:

#! /usr/bin/env python
import pygame, serial, sys, MySQLdb, time
dato = 0
running = 1
muestras = 0

#-----------------------------------------------------------------
def mysql_insertar(dato):
now = time.localtime(time.time())
fechahora = time.strftime("%Y-%m-%d %H:%M:%S", now)
aux = ((dato * 100) / 256)
DataLogger.executemany (
"""INSERT INTO Temperaturas (FechaHora, Temperatura )
VALUES (%s, %s)""",
[
(fechahora, aux)
] )

def mysql_mostrar():
DataLogger.execute("SELECT FechaHora, Temperatura FROM Temperaturas")
rows = DataLogger.fetchall()
for row in rows:
print "%s, %s" % (row[0], row[1])

print "Numero de filas: %d" % DataLogger.rowcount
#------------------------------------------------------------------
RS232 = serial.Serial('/dev/ttyUSB0', 19200, timeout=1, stopbits=1)
print RS232.portstr

db = MySQLdb.connect("localhost","python","python","Datos")
DataLogger = db.cursor()

cantidad = int(raw_input('Cantidad de Muestras:'))

while running:
muestras += 1
RS232.write("AA")
dato = ord(RS232.read())
print dato
mysql_insertar(dato)
pygame.time.wait(1000)
#mysql_mostrar()
if muestras >= cantidad:
running = 0


RS232.close()
db.close()

#Final

La base de datos que deven crear es la siguiente:
la base se llama Datos con una tabla Temperaturas(id,FechaHora,Temperatura)

Python - Juego de la Vida (Automatas Celulares)

Me intereso bastante cuando vi el efecto que producia unas simples leyes dentro de una matriz "Juego de la vida" este codigo lo encontre en un manual de python, el cual lo modifique para usar con pygame aqui se los dejo y modifiquen a su gusto xD.......(Hay partes del codigo que no se usan por que? bueno tambien estoy creando mi universo jajaja en fin ^^)

#! /usr/bin/env python
import pygame, serial, sys, MySQLdb, time
from pygame.locals import *
from random import random
from random import randint

pygame.init()
pygame.font.init()

def MostrarMundo():
for y in range(filas):
for x in range(columnas):
if Mundo[y][x]== 1:
pygame.draw.rect(screen,rojo,(x*10,y*10,10,10))
pygame.display.flip()
elif Mundo[y][x] == 2:
pygame.draw.rect(screen,verde,(x*10,y*10,10,10))
pygame.display.flip()
elif Mundo[y][x] == 3:
pygame.draw.rect(screen,azul,(x*10,y*10,10,10))
pygame.display.flip()
elif Mundo[y][x] == 4:
pygame.draw.rect(screen,blanco,(x*10,y*10,10,10))
pygame.display.flip()
elif Mundo[y][x] == 0:
pygame.draw.rect(screen,negro,(x*10,y*10,10,10))

pygame.time.wait(500)

def LaGranExplosion():
for i in range(randint(1,200)):
a = randint(0,21)
b = randint(0,21)
Mundo[a][b]=4

def Accion():

for y in range(filas):
for x in range(columnas):
n = 0
if y > 0 and x > 0 and Mundo[y-1][x-1]:
n+=1
if x > 0 and Mundo[y][x-1]:
n+=1
if y <> 0 and Mundo[y-1][x]:
n+=1
if y <>0 and Mundo[y+1][x]:
n+=1
if y>0 and x < columnas-1 and Mundo[y-1][x+1]:
n+=1
if x < columnas -1 and Mundo[y][x+1]:
n+=1
if y < filas-1 and x < columnas-1 and Mundo[y+1][x+1]:
n+=1

if Mundo[y][x] and (n==2 or n==3): #Nacimiento
Mundo[y][x]=1
elif not Mundo[y][x] and n==3: #Permanencia
Mundo[y][x]=1
else:
Mundo[y][x]=0 #Expiracion

MostrarMundo()

#---------------------------------------------------------------------
screen = pygame.display.set_mode((240, 240))
pygame.display.set_caption('JMQ')

running = 1

verde = 0 , 255, 0
rojo = 255, 0, 0
azul = 0, 0, 255
negro = 0, 0, 0
blanco = 255, 255, 255

filas = 22
columnas = 22
Mundo=[]
for i in range(filas):
Mundo.append([0]*columnas)

Mundo = [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]

LaGranExplosion()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
#pygame.draw.rect(screen, Color, (x, y, x_size, y_size))
Accion()
screen.fill(negro)
pygame.display.flip()


Tengan en cuenta la identacion......... xD

Osciloscopio en accion xD

Usando Pygame para un Osciloscopio

Pygame no solamente sirve para hacer juegos y demas, lo podemos usar para construir nuestro propio osciloscopio casero de una manera relativamente facil, aqui le paso el codigo .py y asm para que puedan probar modificar a gusto, si bien el programa en pygame le falta es bastante explicativo para que puedan comenzar y mejorar el programa como agregar la base de tiempo por ejemplo, bueno aqui les paso:

* osciloscopio.py

#! /usr/bin/env python
import pygame, serial, sys
from pygame.locals import  *
pygame.init()
pygame.font.init()

amarillo = 255, 255, 0
aux = 0
RS232 = serial.Serial('/dev/ttyUSB0', 19200, timeout=1, stopbits=1)
print RS232.portstr
screen = pygame.display.set_mode((512, 256))
pygame.display.set_caption('Osciloscopio')

running = 1
negro = 0, 0, 0

while running: 
  event = pygame.event.poll() 
  aux = 0
  for x in range(0,512):
    if event.type == pygame.QUIT: sys.exit()
    RS232.write("AA")
    dato = ord(RS232.read()) 
    pygame.draw.line(screen, amarillo, (x, aux), (x+1, dato))
    aux = dato
    pygame.display.flip()
   
  screen.fill(negro)


* interfas.asm PIC16F873A 20Mhz
;JoseMariaQuiroga
;chispilinux@gmail.com

    list p=16f873a
    include "p16f873a.inc"
__config _HS_OSC & _WDT_OFF & _LVP_OFF &_DEBUG_OFF & _CPD_OFF &_PWRTE_ON &_LVP_OFF &_BODEN_ON
;-------------------------------------------
CounterA  equ    10h
buffer      equ    11h
CounterB  equ   12h
;-------------------------------------------
    org        0h
    goto       Inicio
    org        04h        
    btfss      PIR1,RCIF    ;Interrupcion por recepcion?
    goto      Sale_int_rx
    bcf        PIR1,RCIF    
    movf    RCREG,w
    xorlw    'A'        ;Leer el canal AD0 ?
    btfss    STATUS,Z
    goto    opcion_a    ;jeje si no me fijo
    call    Receive
    movf    RCREG,w
    xorlw    'A'        ;q' canal?
    btfss    STATUS,Z
    goto    Sale_int_rx
    movlw   b'01000001' ;FOSC/8 canal 0  ;Lectura de los AD
    movwf   ADCON0
    call    Conversion_ADC        
    movf    buffer,w
    call    Transmit
    goto    Sale_int_rx

    
opcion_a
    movf    RCREG,w
    xorlw    'S'        
    btfss    STATUS,Z
    goto    opcion_b
    call    Receive
    movf    RCREG,w
    xorlw    'A'        ;q' bit?
    btfss    STATUS,Z
    goto    check_sb
    bsf    PORTB,7
    goto    Sale_int_rx

check_sb    
    movf    RCREG,w
    xorlw    'B'        ;q' bit?
    btfss    STATUS,Z
    goto    Sale_int_rx
    bsf    PORTB,6
    goto    Sale_int_rx

opcion_b
    movf    RCREG,w
    xorlw    'C'
    btfss    STATUS,Z
    goto    Sale_int_rx
    call    Receive
    movf    RCREG,w
    xorlw    'A'        ;q' bit?
    btfss    STATUS,Z
    goto    check_cb    
    bcf    PORTB,7
    goto    Sale_int_rx

check_cb    
    movf    RCREG,w
    xorlw    'B'        ;q' bit?
    btfss    STATUS,Z
    goto    Sale_int_rx
    bcf    PORTB,6
    goto    Sale_int_rx

Sale_int_rx
    retfie                
;________________________________________________
;       Configurando en PIC
;________________________________________________
Inicio  bsf    STATUS,RP0     ;Cambiando de banco
    bcf    OPTION_REG,7
    movlw   B'00000000'     ;Todas las entradas analogicas
        movwf   ADCON1    
        movlw    B'00111111'    ;PORTA input adc
        movwf    TRISA    
        movlw    B'00000000'     ;PORTB output 
        movwf    TRISB    
        movlw    B'10000000'     ;PORTC output
        movwf    TRISC    
        movlw    D'15'       ;19200
        movwf    SPBRG    
        movlw    b'00100000' 
        movwf    TXSTA    
        movlw    b'10010000' 
    bsf    PIE1,RCIE    ;Habilitacion interrupcion RX
        bcf    STATUS,RP0        
        movwf    RCSTA    
    movlw    b'11000000'    ;Habilitacion para las 
    movwf    INTCON        ;interrupciones generales
;==========================================
mainloop
    bsf    PORTB,0    
    goto    mainloop
;==========================================
; Subrutinas
;------------------------------------------    
Receive btfss    PIR1,RCIF
        goto    Receive 
        movf    RCREG,w    
        return 
;-------------------------------------------    
Transmit 
    movwf    TXREG
    bsf    STATUS,RP0
WtHere  btfss    TXSTA,TRMT
        goto    WtHere 
        bcf    STATUS,RP0
        return 
;-------------------------------------------
;    Analogico Digital
;B'01000001' ;FOSC/8 canal 0 RA0
;B'01001001' ;FOSC/8 canal 1 RA1
;B'01010001' ;FOSC/8 canal 2 RA2
;B'01011001' ;FOSC/8 canal 3 RA3
;B'01100001' ;FOSC/8 canal 4 RA4

Conversion_ADC        
    movlw     D'5'
    movwf     CounterA
delay_0.00002_sec_loop        ;20 uS
    decfsz     CounterA,1
     goto     delay_0.00002_sec_loop         
    bsf    ADCON0,GO    
wait    btfsc    ADCON0,GO      ;Espera q termine la conversion
    goto    wait
    movf    ADRESH,w    
    movwf    buffer
    return        

    return    
;-------------------------------------------
    end
;-------------------------------------------

Este programita en ASM tambien nos sirve para otros ejemplos como el anterior  (python-serial).

Puerto Serial - Python

El viejo amigo puerto serial RS232 , todavia se sigue usando en la industria xD. Python tiene un modulo para manejarlo bastante facil, bueno vamos a instalarlo:
apt-get install python-serial:

* Veamos que instalo : dpkg -L python-serial, nos vamos a /usr/share/doc/python-serial/examples y veremos varios ejemplos de donde aprender a manejarlo:

Ejemplo:
0#! /usr/bin/env python
1 import serial
2
3 RS232 = serial.Serial('/dev/ttyUSB0', 19200, timeout=1, stopbits=1)
4 print RS232.portstr
5 running = 1
6
7 while running:
8 RS232.write("AA")
9 dato = ord(RS232.read())
10 print dato

Importamos el modulo serial luego lo que hacemos es configurar nuestro puerto serial, en este caso uso un adaptador USB-RS232 (PL2303) que esta trabajando a 19200 bps con un bit de stop. Si todo esta bien en la linea 3 se imprime el dispositivo.
Mandamos una cadena "AA" y esperamos una respuesta donde la convertimos a un valor entero. (en este caso la cadena lo recibe un PIC lee el canal analogico y lo devuelve).

GPSIM en accion

Usando GPSIM

GPSIM es un programa de simulacion bastante completo con respecto a otros GNU, en este caso
le explico con un ejemplo :

*Primero instalamos o buscamos los paquetes que tenemos a disposicion:
apt-cache search gpsim
y nos tirara esto (en ubuntu)

gpsim - Simulator for Microchip's PIC microcontrollers
gpsim-dev - Libraries needed only for building gpsim components
gpsim-doc - Documentation for gpsim
gpsim-lcd - LCD module for gpsim
gpsim-lcd-graphic - LCD module for gpsim
gpsim-led - LED module for gpsim
gpsim-logic - logic module for gpsim

instalamos : apt-get install gpsim gpsim-doc (o todo xD)
tambien instalamos gputils: apt-get install gputils (es una utilidad para los uC de Microchip ensamblador y desemsamblador y otras herramientas)

*Ahora con nuestro editor faborito (nano) escribimos este codigo:

list p=16f84
include "p16f84.inc"
conta equ 10H ;Variables que vamos a usar
i equ 11H

org 0 ;Vector de reset
goto Configurar
org 05h
;------------------------------------------------------------
Configurar ;Configurando el pinout
bsf STATUS,5
movlw B'11111111'
movwf TRISB
movlw B'00000'
movwf TRISA
bcf STATUS,5
;------------------------------------------------------------
doloop
movlw D'32' ;Cargamos el registro conta con 32 en decimal
movwf conta
incf i,f ;Incrementamos el registro i en F
movf i,w
movwf PORTA ;Escribimos el PORTA con el valor incrementado de i
xorlw conta
btfss STATUS,Z ;Nos fijamos si llego a 32
goto doloop ;si no llego
clrf i ;si llego limpiamos los registros y volvemos a empezar
clrf PORTA
goto doloop
end


*guardamos con algun nombre por ejemplo contador.asm, luego: #gpasm contador.asm
nos generara tres archivos: contador.cod contador.hex contador.lst.
El .hex es para programar el pic, el lst una descripcion mas detallada del esamblamiento, nos indica donde nos equivocamos por ejemplo, el .cod lo vamos a usar con el gpsim

*En nuestra consola ponemos:#gpsim
-Arranca el GPSIM y nos vamos FILE->OPEN abrimos el contador.cod
-En el menu WINDOWS le damos un click en SOURCE y BREADBOARD nos saldra:
.el pinout del micro
.y nuestro codigo

*Corremos el programa con STEP o RUN y listo xD hay algo interesante con el gpsim que es el modo
de simulacion donde podemos elegir los ciclos por segundo del uC.
Tambien contamos con un manual en PDF bastante bueno, otra cosa ize que ejecuten el gpsim desde una consola para que? mirenla cuando ejectumos el simulador xD interesante no?
(disculpen la ortografia *_* )

Construyendo nuestro programador FreeICD2

Buscando y buscando encontre un Programador de pic para el puerto serial el cual use con un adaptador USB-Serial (PL2303) y no tube ningun problema, los micros que probe son el 16F628, 16F873, 16F877.
Le paso el link http://www.stolz.de.be/ el esquematico es la imagen que ven:

El firmware lo pueden bajar del mismo sitio, si por alguna razon tienen problemas para bajarlo, me mandan un mail y se los paso.

Este programador funciona sin ningun problema en gnulinux con el programa Piklab http://piklab.sourceforge.net/
Es un IDE bastante completo, soporta varios compiladores y podemos usar en nuestros proyecto el SDCC (Small Device C Compiler) http://sdcc.sourceforge.net/ muy bueno por sierto, tambien podemos usar nuestros viejos programadores por el puerto paralelo.