Grabado láser de PCB

He realizado un vídeo donde grabo un circuito impreso con un láser.

El circuito impreso (PCB) utilizado es de baquelita , no he probado con uno de fibra de vidrio.

 

 

Espero que les guste este vídeo.

Saludos.

Juan Galaz

pdfposter

  Página principal

pdfposter
 xsetaseta@gmail.com

---

En la necesidad de imprimir una página A3 en mi impresora que solo imprime páginas A4, busque por internet.
Existe bastante programas que permiten transformar 1 página en varias para hacer carteles.
Entre los que me gustaron más, por su simplicidad fue pdfposter.
Funciona en linux en modo consola. Dispone de pocas opciones, pero hace lo que se le pide.
Como entrada debes tener un pdf, en mi caso había transformado una foto en un pdf, imprimiendo en una impresora con salida pdf.
Ejemplo de una transformación con escala ( -s 2 ) al doble:

pdfposter entrada.pdf -s 2 salidan.pdf

Ejemplos de transformación por formato de página:

pdfposter entrada.pdf -pA0 salidan.pdf

pdfposter entrada.pdf -pA1 salidan.pdf

pdfposter entrada.pdf -pA2 salidan.pdf

pdfposter entrada.pdf -pA3 salidan.pdf

pdfposter entrada.pdf -pA4 salidan.pdf

pdfposter entrada.pdf -pA5 salidan.pdf

pdfposter entrada.pdf -pA6 salidan.pdf

pdfposter entrada.pdf -pA3 salidan.pdf

Seguro que haréis vuestros propios poster.


Saludos.
Juan Galaz


Bibliografía:

https://pythonhosted.org/pdftools.pdfposter/
https://github.com/voidus/pdfposter

Z80 Simulador

Página principal

Z80
Simulador
xsetaseta@gmail.com

---

Después de haber programado un ensamblador y un desensamblador de procesador Z80, el siguiente paso era crear un simulador.
El entorno de trabajo es Debian 10, y como base para la representación gráfica la librería SDL, y programación en C.

Para entender lo que es un simulador de un Z80, es un intérprete de cada uno de los códigos de tiene el Z80.
Por ejemplo:
    LD   A,B     Corresponde al opcode 78 en hexadecimal o en decimal 120
El intérprete lo que hace es:
    alu=bc.b.h;
   af.b.h=alu;
Incrementa el contador de programa y vuelve a buscar la siguiente instrucción para ejecutarla.

En este caso la orden es bastante simple, pero existen otros opcode (código de operaciones) que son mas complejas.
En el caso de:
    INC A
Debe comprobar los diferentes flags, como puede ser el Z (si resultado es cero).

Como no quería hacer un emulador perfecto, es bastante complicado, no he incluido el contador de tiempos de cada operación.
Tampoco has he diseñado para que sean rápida la interpretación del código.
No es un simulador bueno, simplemente un simulador para los que empiezan a aprenden con el Z80.





El programa tiene bastantes argumentos de entrada.

./sima file.bin   -t 0   -vi 300  -p1 -p2 -port 0 -nmi -int   -me -sp


El primero y único imprescindible es el fichero binario, fichero de programa.
-t 0 ,tiempo entre operaciones, si no se especifica es cada segundo, pero si se tienen interrupciones puede que se generen interrupciones continuamente sin ejecutar ningún programa. El tiempo mas rápido es -t 0.
-vi 300 , tiempo entre actualizaciones de gráficos, si es pequeño puede que no tenga el ordenador tiempo para el emulador, depende del programa que estemos probando.
-nmi , genera interrupciones no enmascarables cada 1 segundo.
-int , genera interrupciones  enmascarables cada 0.1 segundo.
-me 1000 , visualiza posiciones de memoria en la dirección 1000.
-sp 4000  , visualiza posiciones de memoria de registro SP posición 4000.
-port 0 ,visualiza valor del puerto 0.
-p1 y -p2 , visualiza en consola la secuencia de ejecución de las operaciones, y los valores de los registros. Es muy útil en depuración.

Debemos tener cuidado con la depuración y las interrupciones, pueden entrar en bucle si los tiempos se solapan.

Ejemplo de un programa sencillo.

/ejemplo.asm ;./sima file.bin  -p1      org &0 #empezar     ld a,&4 #bucle        dec a     jr nz,#bucle     jr #empezar     end

./ensam ejemplo.asm Ensamblador corez80 V3 ======================= --- Preprocesador --- --- Fin preprocesador --- Num NEMOS= 698 --- Paser 0 ===Ensamblador=== _FIN__Parser 0 --- Paser 1 ===Ensamblador=== 001 /ejemplo.asm      002 ;./simaV2 file.bin       -me 16384 -t 1   -nmi -vi 100  003 /seta43           004                   005  ORG &0              00000_______ORG_0 006 #EMPEZAR          007  LD A,&4             00000_ 062 004 008 #BUCLE            009  DEC A               00002_ 061 010  JR NZ,#BUCLE        00003_ 032 253 011  JR #EMPEZAR         00005_ 024 249 012  END                 00007__FIN__Parser 1 ==Variables== NUM=1 00-#EMPEZAR=0        01-#BUCLE=2        Salvando codigo en fichero file.bin   SIZE=7

./sima file.bin -p1 00000 062 LD A n          PC=0000 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=04 IX=0000 IY=0000 S0Z0C0P0 00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=03 IX=0000 IY=0000 S0Z0C0P1 00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=03 IX=0000 IY=0000 S0Z0C0P1 00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=02 IX=0000 IY=0000 S0Z0C0P0 00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=02 IX=0000 IY=0000 S0Z0C0P0 00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=01 IX=0000 IY=0000 S0Z0C0P0 00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=01 IX=0000 IY=0000 S0Z0C0P0 00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1 00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1 00005 024 JR -7           PC=0005 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1 00000 062 LD A n          PC=0000 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=04 IX=0000 IY=0000 S0Z1C0P1

Este es el programa mas sencillo que se puede crear, sin interrupciones ni llamadas a rutinas donde no se hace uso de SP.
Para salir de la emulación debemos pulsar ESC en la interface gráfica, parará la emulación, y con la tecla Q saldremos del programa.
La definición de gráficos de las fuentes, las he sacado del Spectrum.
Cuando se esta emulado, si se pulsa cualquier tecla, el emulador coloca el código ASCII en el puerto 0 del emulador.

La representación gráfica se hace en dos modos a la vez:
-modo carácter  2x16 caracteres.
-modo gráfico , gráfico de 128x128 puntos.
La representación gráfica se hace a partir de la dirección 16384.

He creado varios programas de ejemplo para demostrar el funcionamiento del programa.
Se pueden ver su funcionamiento en el siguiente vídeo:

VIDEO



No es el mejor simulador del Z80, pero he de reconocer que me lo he pasado bien.
He tenido que volver aprender ensamblador del Z80, el ensamblador siempre es duro, y tienes que cambiar muchos malos hábitos de otros lenguajes.
Como no estoy habituado al ensamblador, he intentado en algunas funciones guardar todos los registros antes de hacer una llamada CALL , pero esto produce una ralentización del programa.
Existen personas que son muy hábiles en este lenguaje y hacen cosas increíblemente rápidas y buenas, yo no soy de esos ;).
   
Para emular el Spectrum, debemos crear un emulador del Z80, en esta página describen bastantes emuladores:
    https://magazinezx.speccy.org/03/emulacion.html

También para el ordenador Amstrad CPC existen muchos emuladores del Z80
    https://auamstrad.es/software/guia-emuladores-amstrad-cpc/

Los emuladores que me han sorprendido son:

FUSE .- Para muchas plataformas.
ZXBaremulator es el primer emulador del ZX Spectrum para la Raspberry PI.
Bacteria. -El emulador mas pequeño escrito en ensamblador.

Lista de códigos de operación del Z80
opcodes.txt
z80_code.txt

Espero que sea un principio para que realicéis vuestro propio simulador.


PROGRAMAS

Saludos.
Juan Galaz


Bibliografía:

http://www.z80.info/decoding.htm
https://espamatica.com/
http://map.grauw.nl/resources/
https://magazinezx.speccy.org/03/emulacion.html
https://github.com/jsanchezv
https://auamstrad.es/software/guia-emuladores-amstrad-cpc/

 

Crear circuitos impresos (PCB) con KICAD, FlatCAM, Candle, y CNC 3018.

He creado un vídeo de como crear circuitos impresos (PCB) con KICAD, FlatCAM, Candle, y CNC 3018.

Debemos tener cuidado del estado de la broca, que esté bien afilada.

He de confesar que he realizado varias pruebas, debido a que las dos primeras pruebas me salían mal. 

Las tomas de vídeo están alteradas, por lo cual no siguen una secuencia de tiempo real.

Otros vídeos de interes:

https://www.youtube.com/watch?v=rDLayMgCDao&t=1920s
https://www.youtube.com/watch?v=OVI79Wyxb7g
https://www.youtube.com/watch?v=3CxX6W2Vp10
https://www.youtube.com/watch?v=gPt6krMi-pE
 

 

Saludos

Juan

Z80 - Desensamblador

  Página principal

Z80
Desensamblador

---

Después de haber programado un ensamblador de procesador Z80, el siguiente paso era crear un desensamblador.
El fichero de entrada debe ser un fichero binario, código maquina del Z80, la salida será un fichero de texto con formato *.asm .
El formato de entrada es:   
  
     ./disam fichero.bin

Si no se especifica nada el fichero de salida será file.asm
Además permite otros argumentos como:

        -pt Salida por pantalla
        -o nombre fichero asm

La mejor prueba es desemsamblar un fichero binario que antes hemos ensamblado con nuestro ensamblador.

/reloj.asm     org &0     ld a,&0     ld b,a     ld c,a     ld d,a     ld e,a #inicio        ld a,&10     inc b        /incrementar segundos     cp b     jr nz,#salto     ld b,&0     inc c        /incrementar decimales segundo     ld a,&6     cp c     jr nz,#salto     inc d        /incrementar minutos     ld c,&0     ld a,&10     cp d     jr nz,#salto     ld d,&0     inc e        /incrementar decimales minutos     ld a,&6     cp e     jr nz,#salto     ld e,&0     #salto     nop     jp #inicio     nop     nop         end

LD A,&0         / 00000 > 062 000                 LD B,A          / 00002 G 071                     LD C,A          / 00003 O 079                     LD D,A          / 00004 W 087                     LD E,A          / 00005 _ 095                  #salto01    LD A,&10        / 00006 > 062 010          salto01      INC B           / 00008 . 004                     CP B            / 00009 . 184                     JR NZ,#salto00  / 00010   032 026            /GOTO #salto00  *DIR.00038    LD B,&0         / 00012 . 006 000                 INC C           / 00014 . 012                     LD A,&6         / 00015 > 062 006                 CP C            / 00017 . 185                     JR NZ,#salto00  / 00018   032 018            /GOTO #salto00  *DIR.00038    INC D           / 00020 . 020                     LD C,&0         / 00021 . 014 000                 LD A,&10        / 00023 > 062 010                 CP D            / 00025 . 186                     JR NZ,#salto00  / 00026   032 010            /GOTO #salto00  *DIR.00038    LD D,&0         / 00028 . 022 000                 INC E           / 00030 . 028                     LD A,&6         / 00031 > 062 006                 CP E            / 00033 . 187                     JR NZ,#salto00  / 00034   032 002            /GOTO #salto00  *DIR.00038    LD E,&0         / 00036 . 030 000              #salto00    NOP             / 00038 . 000              salto00      JP #salto01     / 00039 . 195 006 000        /GOTO #salto01  *DIR.00006    NOP             / 00042 . 000                     NOP             / 00043 . 000                      END

Como pasaba en el ensamblador, la salida de números está en formato decimal.
El código de desensamblado es igual al fichero en lenguaje ensamblador.
Los salto de programa se representan con #salto**

Para ver todos los nemotécnicos admitidos, se pueden ver en los ficheros :
opcodes.txt
z80_code.txt

Espero que sea un principio para que realicéis vuestro propio desensamblador.


PROGRAMAS

Saludos.
Juan Galaz


Bibliografía:
http://www.z80.info/decoding.htm
https://espamatica.com/
http://map.grauw.nl/resources/