miércoles, 29 de diciembre de 2021

Mupen64 Plus Instalación en Debian 10 y 11

  Página principal


Mupen64 Plus
Instalación en Debian 10 y 11



El otro día me entro las ganas de jugar al Mario Kart en el emulador Mupen64 Plus .
Hacia tiempo que no jugaba y he realizado este tutorial para explicar mis experiencias.
He realizado las pruebas tanto en Debian 10 y en Debian 11.

Lo primero es instalar Mupen64 Plus desde sus propios repositorios.
También instalaré mupen64plus-qt que es una aplicación gráfica para configurar y lanzar el emulador.
Se puede instalar desde la línea de comandos todo con apt-get install mupen64plus-qt

Para que se cree un fichero de configuración, desde consola lanzo el emulador con la ROM del Mario Kart con la orden:

mupen64plus MarioK64.v64

Si todo fue bien podremos  jugar con el juego.
En mi caso no fue así, aunque detecto el Joystick no lo supo configurar.

Input: 1 SDL joysticks were found.
Input Error: No auto-config found for joystick named 'Logic3 Controller' in InputAutoConfig.ini
Input: N64 Controller #1: Forcing default keyboard configuration


Incluso en Debian 11 su detección era diferente.

Input: 1 SDL joysticks were found.
Input Error: No auto-config found for joystick named 'PDP Xbox 360 Controller' in InputAutoConfig.ini
Input: N64 Controller #1: Forcing default keyboard configuration


El emulador funcionaba, pero solo con el teclado.
Salimos de emulador y empezamos configurar cosas.

Como superusuario editamos el fichero:
/usr/share/games/mupen64plus/InputAutoCfg.ini

y copiamos una configuración de un mando parecido al que tenemos, en mi caso un Joystick del tipo de la XBOX 360.
Ahora lo pegamos en otro lugar y cambiamos el nombre del fichero de configuración del Joystick.

Añadir nuestro Joystick

[PDP Xbox 360 Controller] 
(para Debian 11)
        o
[Logic3 Controller]  (para Debian 10)
plugged = True
plugin = 2
mouse = False
AnalogDeadzone = 4096,4096
AnalogPeak = 32768,32768
DPad R = hat(0 Right)
DPad L = hat(0 Left)
DPad D = hat(0 Down)
DPad U = hat(0 Up)
Start = button(7)
Z Trig = axis(2+)
B Button = button(2)
A Button = button(0)
C Button R = axis(3+)
C Button L = axis(3-) button(3)
C Button D = axis(4+) button(1)
C Button U = axis(4-)
R Trig = button(5) axis(5+)
L Trig = button(4)
Mempak switch =
Rumblepak switch =
X Axis = axis(0-,0+)
Y Axis = axis(1-,1+)

Lo guardamos y cuando lanzamos el emulador no habrá detectado bien nuestro
Joystick.

Input: 1 SDL joysticks were found.
Input: N64 Controller #1: Using auto-config with SDL joystick 0 ('Logic3 Controller')
Input: 1 controller(s) found, 1 plugged in and usable in the emulator
Input: Rumble activated on N64 joystick #1


En alguna ocasión puede ocurrir que por algún motivo desconocido, el Joystick se ha transformado en ratón, y no se puede jugar.
Como superusuario debemos crear un fichero de configuración para deshabilitar en xorg el Joystick:
    /etc/X11/xorg.conf.d/51-joystick.conf

Y escribimos lo siguiente:

Section "InputClass"
        Identifier "joystick catchall"
        MatchIsJoystick "on"
        MatchDevicePath "/dev/input/event*"
        Driver "joystick"
        Option "StartKeysEnabled" "False"   
        Option "StartMouseEnabled" "False" 
EndSection



Ahora debemos editar el fichero de configuración que se encuentra en :
/home/usuario/.config/mupen64plus/mupen64plus.cfg

En mi caso no funciona muy bien el video, y quiero ver el emulador en pantalla grande.

Cambiar el tipo de apaptador de video en mi caso:

# Filename of video plugin
VideoPlugin = "Video-Glide64mk2.so"
      o
VideoPlugin = "Video-Glide64.so"


El tamaño de la pantalla del emulador lo hago grande

[Video-General]

Fullscreen = False
# If true, prevent frame tearing by waiting for vsync before swapping
VerticalSync = True
# Width of output window or fullscreen width
ScreenWidth = 1024 
# Height of output window or fullscreen height
ScreenHeight = 768
# Rotate screen contents: 0=0 degree, 1=90 degree, 2 = 180 degree, 3=270 degree
Rotate = 0


Hasta ahora habíamos lanzado el emulador desde consola, pero existen un par de programas con interface gráfico.
Con el programa antes instalado mupen64plus-qt,  todo se hace mucho más fácil.

En este programa podemos cambiar muchas configuraciones, además tiene guardas muchas configuraciones por defecto para muchas ROMs.

Otro programa con interface gráfico es m64py,
Debemos bajar el paquete de: https://sourceforge.net/projects/m64py/files/
En Debian 10 funciona la versión m64py-0.1.0 , en Debian 11 funciona la versión
m64py_0.2.4-0_all.deb .




A disfrutar....;)

Saludos.
Juan Galaz



Bibliografía:


sábado, 11 de diciembre de 2021

Transistor Tester para Arduino Nano. Representación en PC con Gambas (VB linux)

  Página principal



Transistor Tester para Arduino Nano
Representación en PC con Gambas (VB linux)
 
En un montaje anterior había realizado un analizador de componentes llamado  TransistorTester, cuyo autor era  Karl-Heinz Kübbeler .
Según la configuración del programa se podía utilizar diferentes tipos de visualizadores, en mi caso había utilizado un OLED.
Para los que deseen utilizar un PC a modo de presentación de resultados del téster, he programado una aplicación Gambas para representar los resultados.
Lo único que he hecho en el programa de arduino es modificar algunas líneas de código  que mandan algunas instrucciones por el puerto serie.
Para que no se bloqueara el I2C si no colocaba el OLED, he configurado el programa para que utilice el LCD1602.
También he añadido la línea Serial.println("END"); al final de cada detección de componente.



PROGRAMA


VIDEO DEMOSTRATIVO

Saludos.
Juan Galaz



Bibliografía:

https://github.com/kr4fty/Ardutester
https://www.sysadminsdecuba.com/2020/08/ardutester-tester-de-componentes-con-arduino/
https://create.arduino.cc/projecthub/mircemk/diy-super-simple-electronic-component-tester-234752
https://create.arduino.cc/projecthub/plouc68000/ardutester-v1-13-the-arduino-uno-transistor-tester-dbafb4

martes, 7 de diciembre de 2021

Calculadora CASIO A1 con SDL

Página principal


Calculadora
CASIO A1
 con
SDL


Se había realizado esta calculadora en GAMBAS, y ahora lo realizo con la librería SDL



PROGRAMA

Saludos.
Juan Galaz



 

lunes, 29 de noviembre de 2021

Conversor de formatos de vídeo Gambas (VB-linux) FFMPEG

  Página principal


Conversor de formatos de vídeo
Gambas (VB-linux)
FFMPEG


Este programa es solo una interface del programa ffmpeg .
Sirve para convertir formatos de vídeo.
No se pretende mucho, pero funciona bastante bien.

 

PROGRAMA

Saludos.
Juan Galaz



Calculadora con Gambas (VB-linux) CASIO A1

  Página principal


Calculadora
con
Gambas (VB-linux)
CASIO A1


Continuo con la serie de calculadoras realizadas en GAMBAS (VB-Linux).
Como yo hago colección de calculadoras he comprado la calculadora CASIO A1.
Es tan sencilla que no pude evitar la tentación de programarla.
Fue bastante fácil y se realizo en poco tiempo, este es el resultado.


PROGRAMA

Saludos.
Juan Galaz



miércoles, 17 de noviembre de 2021

Instalar Debian11 y no morir en el intento. 3 videos

Instalar Debian11
y
no morir en el intento


 
HP:  Compaq pro 6305        Disco SSD
    https://youtu.be/5JhZJNQ9Dno
 
 
TOSHIBA:  Satellite pro L450   Disco SSD
    https://youtu.be/X6X0b0v7Kzg

 
P4: Intel Core 2 Quad Q9300    Disco SSD
  https://youtu.be/tV9Gt0f9lT0
 
DEBIAN11
========


apt install autoconf automake build-essential dkms fastjar g++ gawk gcc gcc-multilib gettext gettext-base intltool intltool-debian jarwrapper  linux-headers-$(uname -r) mawk mesa-common-dev minizip nasm perl perl-base pkg-config   subversion wx-common wx3.0-headers x11proto-record-dev zlib1g zlib1g-dev

apt install mc xfe kaffeine w-scan

apt install firmware-misc-nonfree firmware-linux-free 

INTEL :  apt install intel-microcode
AMD  :   apt install firmware-amd-graphics  amd64-microcode 

Instalar impresoras.
    apt install  printer-driver-all  hplip  hplip-data  printer-driver-postscript-hp

/sbin/adduser  seta  vboxusers






 


 

miércoles, 10 de noviembre de 2021

TECLADO ANALÓGICO PARA APLICACIONES CON MICROCONTROLADOR

  Página principal


DISEÑO DE UN TECLADO ANALÓGICO PARA APLICACIONES CON MICROCONTROLADOR

Ing. Alfredo Segura
México, 2011



DISEÑO DE UN TECLADO ANALÓGICO PARA APLICACIONES CON MICROCONTROLADOR

En algunos de nuestros diseños electrónicos con microcontroladores hemos de incluir un teclado para introducir datos o seleccionar opciones. Sin embargo pensar en un teclado matricial nos lleva a tener que elegir un microcontrolador (uC) con un mayor número de terminales para poder realizarlo. Son comunes los teclados matriciales de 4X4 (4 renglones por 4 columnas), para lo cual se requieren 8 pines de I/O en el uC.

Si el diseño requiere un teclado de las dimensiones adecuadas, podemos recurrir a un teclado analógico, el cual se puede lograr usando resistencias en serie y en cada unión de dos resistencias, se coloca el  botón que aterriza ese nodo. El arreglo se muestra en la siguiente figura:



Es conveniente utilizar una fuente de tensión muy estable, como por ejemplo el CI TL-431 o cualquier otro que se encuentre en el mercado. La razón de esto es porque el voltaje Vo a la salida del teclado analógico deberá ser siempre del mismo valor para una tecla específica y así para todas las teclas incorporadas al teclado.

La salida del teclado analógico deberá ser conectada a una entrada analógica en el uC debidamente programado para que haga la lectura o sondeo constante de dicha entrada. Es claro, según el diagrama anterior que, sin oprimir ninguna tecla, el voltaje Vo será el de la fuente estable y por lo tanto el programa en el uC, no hará acción alguna relacionada al teclado, sino que seguirá con sus actividades programadas.

Tan pronto se presiona una de las teclas, el uC recibirá por la entrada analógica la tensión correspondiente que resulta de la división entre Rv y la suma de R1 a Rn:


Vo = Vi(R1 + … + Rn) / [Rv + (R1 + … + Rn)]


Por supuesto que el diseñador podrá elegir libremente el nombre de cada tecla, de acuerdo con las actividades que el uC debe realizar al presionarse una de ellas. En el diagrama se han etiquetado como las típicas de un teclado con 16 posiciones, sin el punto(.):

0, #, D, C, 3, 2, 1, 4, 5, 6, B, A, 7, 8, 9


Así que el módulo ADC (Analog To Digital Converter) o Convertidor Analógico a Digital del microcontrolador podrá entregar un valor digital diferente por cada una de las teclas que se vayan presionando.

Para tener un span mas alto en los valores de cada tecla, Rv podrá elegirse del valor mas adecuado para que Vo sea el valor mas bajo apreciable cuando se presiona la tecla “0”.  Así, para cuando se presione la tecla “7”, la suma de todas las resistencias R1 + … + R15, involucradas en la ecuación de Vo, proporcionen el valor mas alto de tensión.

Hay que aclarar que este modelo de teclado analógico no se puede usar para oprimir varias teclas simultáneamente, porque al oprimir solamente una de ellas, se anulan las mas alejadas a la salida Vo. Sin embargo, se puede crear otro ramal de teclas, que serán exclusivas para usarse en forma simultánea con las primeras, para expandir las funciones. De todos modos, otro ramal de teclas en una misma PCB, no es muy difícil de obtener y el uC destinaría una entrada adicional analógica para recibir esta nueva señal.

A continuación se muestra un ejemplo de programa en Cpp para un microcontrolador PIC 12F675 que tiene únicamente 8 terminales:

/*
Programa con el 12f675 y un HT12E que sirve para leer un teclado analógico
usando una cadena de resistencias de 1k formando un divisor de tensión con otra
de 10K a Una fuente de voltaje regulado (Vi). Dependiendo de la tecla presionada
y del voltaje convertido se traduce en el numero BCD de la tecla que
corresponda.

Alfredo Segura enero de 2011, México.
*/

#include <12f675.h>
#define adc = 10
#fuses INTRC_IO, NOMCLR, NOWDT, PUT, NOBROWNOUT, NOCPD, NOPROTECT
#use delay(clock = 4000000)

#use fast_io(a)

#byte Port_A = 0x05

#bit ra0 = 0x05.0  // Entrada Analógica
#bit ra1 = 0x05.1  // D0
#bit ra2 = 0x05.2  // D1
#bit ra3 = 0x05.3
#bit ra4 = 0x05.4  // D2
#bit ra5 = 0x05.5  // D3

#rom 0x03FF = {0x3438 }  // solo poner si se usa el programador USP 3.0

int i = 0, cod1, cod2, dato, comd;

void enviar(comd) {    // comd viene como 0b000001, 0b0000111
  cod1 = comd << 1;    // Recorre una vez para acomodar D0 en D1 y D1 en D2
  cod2 = cod1 << 1;    // Recorre otra vez para acomodar D2 en D4 y D3 en D5
  cod1 = cod1 & 0x0F;  // Protege nibble bajo
  cod2 = cod2 & 0xF0;  // Protege nibble alto
  comd = cod1 | cod2;  // Reúne ambas partes
  Port_A = comd;       // saca dato por el puerto
  delay_us(200);       // lo exhibe un momento
}

void ini(void) {
  setup_adc(adc_clock_internal);
  setup_adc_ports(san0);
  setup_comparator(nc_nc_nc_nc);
  set_tris_A(0b00001001);
  Port_A = 0x00;
  i = 0;
}

void main(void) {
  ini();
  delay_ms(300);  // Retardo de 300 ms al encender el pic

  while (true) {
    dato = read_adc();
    delay_ms(100);

    if ((dato >= 111) && (dato <= 120)) {  // no hay dato
    }

    if ((dato >= 0) && (dato <= 5)) {  // tecla "1"
      comd = 0x01;                     // Tecla "1"
      enviar(comd);                    // envía dato
    }
    if ((dato >= 18) && (dato <= 30)) {  // tecla "2"
      comd = 0x02;                       // Tecla "2"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 36) && (dato <= 49)) {  // tecla "3"
      comd = 0x03;                       // Tecla "3"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 55) && (dato <= 65)) {  // tecla "4"
      comd = 0x04;                       // Tecla "4"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 68) && (dato <= 78)) {  // tecla "5"
      comd = 0x05;                       // Tecla "5"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 80) && (dato <= 89)) {  // tecla "6"
      comd = 0x06;                       // Tecla "6"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 91) && (dato <= 99)) {  // tecla "7"
      comd = 0x07;                       // Tecla "7"
      enviar(comd);                      // envía dato
    }
    if ((dato >= 101) && (dato <= 108)) {  // tecla "8"
      comd = 0x08;                         // Tecla "8"
      enviar(comd);                        // envía dato
    }
  }
}


Se ha elegido un microcontrolador de 8 terminales, con la finalidad de dejar claro que un teclado analógico es muy recomendable para el ahorro de terminales, pudiendo ser destinadas el resto a otras entradas o salidas.

En la siguiente imagen se muestra la tarjeta PCB únicamente del teclado analógico, en el cual se insertarán y soldarán las resistencias de 1 K y los botones, colocando un conector de 3 pines como interface con la tarjeta donde se instale el microcontrolador PIC12F675:




Ing. Alfredo Segura
México, 2011

TransistorTester para Arduino Nano y OLED SSD1306Z

  Página principal



Transistor Tester para Arduino Nano
OLED SSD1306Z
Traducido por SETA43


Navegando por internet, encontré un analizador de componentes llamado  TransistorTester, el autor era  Karl-Heinz Kübbeler .
Sobre este montaje, que en principio solo se había creado para analizar transistores, existían múltiples versiones.
La versión que he utilizado es 1.08.004, que en este caso no está creada por el autor,  está realizada para arduino.
Me he permitido el atrevimiento de traducir esta versión al español, solo son unas cuantas palabras.
También no se representaba bien los componentes en el OLED, lo he intentado arreglar como he podido.
He de comentar que me ha sorprendido lo sencillo del montaje, y lo útil que es.
Detecta perfectamente si es un transistor NPN o PNP, JFETs, Diodos, Condensadores, Resistencias. Y lo mas curioso es la forma automática de detectar los pin.

La versión original de TransistorTester está realizada sobre un ATMEGA328 y con un interruptor rotativo, no utiliza el arduino, además de existir múltiples versiones comerciales.






Condensador de 3.9nF  y   1uF



Ressistencias de 330 ,1K, 10K




Transistor BC109 y BD681



Detalle del circuito




PROGRAMA

Este es un montaje muy práctico, se lo recomiendo a todos los electrónicos, será muy útil en cualquier momento para chequear componentes.
Puede funcionar con la alimentación del USB del arduino, pero funciona mejor alimentando al pin Vin del arduino, que soporta hasta 12V.

Para una mejor funcionamiento deberíamos quitar la resistencia que está en el pin D13, es la que alimenta el LED de prueba.


Saludos.
Juan Galaz



Bibliografía:

https://github.com/kr4fty/Ardutester
https://www.sysadminsdecuba.com/2020/08/ardutester-tester-de-componentes-con-arduino/
https://create.arduino.cc/projecthub/mircemk/diy-super-simple-electronic-component-tester-234752
https://create.arduino.cc/projecthub/plouc68000/ardutester-v1-13-the-arduino-uno-transistor-tester-dbafb4

domingo, 31 de octubre de 2021

Instalar en la raspberry Pi servidores.

 Comandos para instalar en la raspberry Pi una serie de servidores.

  • WEB
  • SSH
  • FTP
  • VNC


La raspberry utilizada es el modelo 2 con 512 M de memoria RAM.
Debido a la antiguedad de la placa he instalado raspbian 7 (DEBIAN 7) 2014.





https://youtu.be/DA1EaQWcYQU

http://downloads.raspberrypi.org/raspbian/images/
http://downloads.raspberrypi.org/raspbian_lite/images/

RASPBERRY- configuracion /boot/config.txt
=========================================
hdmi_force_hotplug=1

framebuffer_width=1280
framebuffer_height=720


REPOSITORIO
===========

7.0 -- wheezy
echo deb http://legacy.raspbian.org/raspbian/ wheezy main contrib non-free rpi >> /etc/apt/sources.list
apt-get update

IP_STATICA 192.168.1.50
=======================
/etc/network/interfaces

nano /etc/network/interfaces

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
  address 192.168.1.50
  netmask 255.255.255.0
  gateway 192.168.1.1
dns-nameservers 8.8.8.8
post-up echo "Interface eth0 levantada con exito"
post-down echo "Interface eth0 bajada con exito"


SERVIDOR SSH
============

ssh 192.168.1.50 -l seta


SERVIDOR VNC
============

CONTRASEÑA
     x11vnc -storepasswd
    
cd .config
 mkdir autostart
 cd autostart
 nano x11vnc.desktop

Pegar el siguiente texto:

[Desktop Entry]
Encoding=UTF-8
Type=Application
Name=X11VNC
Comment=
Exec=x11vnc -forever -usepw -display :0 -ultrafilexfer
StartupNotify=false
Terminal=false
Hidden=false


    
SERVIDOR FTP
============

apt-get install vsftpd
/etc/init.d/vsftpd status

Editar:
    nano /etc/vsftpd.conf
Cambiar a:
    anonymous_enable=NO
    local_enable=YES
    write_enable=YES


SERVIDOR WEB
============

sudo apt-get install nginx
sudo service nginx status

Editar:
    nano /etc/nginx/sites-enabled/default

Cambiar a:
    root /var/www;
    
SERVIDOR WEB_CONFIGURACION
--------------------------
mkdir  /var/www
chown -R seta:seta   /var/www
chmod  ugo+rx    /var/www

mkdir  /var/www/seta
chown -R seta:seta   /var/www/seta
chmod  ugo+rx    /var/www/seta

mkdir  /home/seta/www
chown -R seta:seta   /home/seta/www
chmod  ugo+rx    /home/seta/www

echo "/home/seta/www     /var/www/seta   none    bind    0    0" >> /etc/fstab

editar:
    nano /etc/nginx/sites-enabled/default
cambiar a:
        root /var/www;
        
Copiar los ficheros de la página principal en:
        /var/www
Los fichero de cada usuarios en;
        /home/usuario/www    

CAMARA
======

sudo modprobe bcm2835-v4l2
sudo sed -i '$a bcm2835-v4l2' /etc/modules

fswebcam -r "800x600" -S 5 --flip h,v  --no-banner  --jpeg 50 d1.jpg

Si error:  failed to open vchiq instance
    sudo chmod 777 /dev/vchiq
        o
    sudo usermod -a -G video seta
    
Configurar tarea:
=================
 nano /home/seta/www/webcam/tareaWeb
 
crontab -e
    */2  * * * * /home/seta/www/webcam/tareaWeb > /dev/null 2>&1
    
De esta forma el script se ejecutara cada 2 minutos.


APAGAR
======
shutdown -h now

REINICIAR
=========
reboot

    
PROGRAMAS RECOMENDADOS
======================

apt-get install mc
apt-get install xfe

martes, 12 de octubre de 2021

Generador de vídeo PAL con ATmega328.

  Página principal


Generador de vídeo  PAL
ATmega328 -> Video
Visualizar  temperatura y humedad en TV
 
Arduino


Cuando el vídeo compuesto PAL/NTSC empieza a  no usarse, incluso algunos televisores no tienen entrada de video compuesto, he encontrado una página donde explica como generarlo con un procesador ATMEGA 328.
Existen otros montajes para generar video compuesto mediante ATMEGA328, pero no son buenos como este.
    http://searle.x10host.com/MonitorKeyboard/index.html
Este montaje solo genera vídeo, y su control se realiza con dos líneas mediante el protocolo I2C.
Los modos de vídeo pueden ser:

40 Character normal
80 Character normal
40 Character bold
80 Character bold
40 Character normal double-height
80 Character normal double-height
40 Character bold double-height
80 Character bold double-height
Modo gráfico 160x100

La conexión al dispositivo maestro en mi montaje se realiza mediante I2C de dos líneas, pero existe la posibilidad de realizarlo mediante 4, y 8 líneas, con lo cual será más rápida su comunicación.
Para mas detalles os recomiendo que visitéis su página, esta muy bien explicado todas su configuraciones.
También tiene otros muchos proyectos interesantes, gracias
Grant Searle .

Para mi proyecto he utilizado un arduino nano que lee el sensor DHT22  (AM2302), para luego mandar los datos de temperatura y humedad al circuito de generación de vídeo.
Como no tenía la versión del 74HC166 he utilizado el modelo 74LS166, existe diferencias en la impedancia de entrada, pero después de probarlo funciona.

Circuito original.


Circuito para interface I2C de dos líneas, y generación de video PAL.

Como quería hacer prácticas con el programa KiCad lo realizado también para este programa.

Esquema con KiCad.



Circuito impreso con KiCad.


Vista 3D con KiCad.

El circuito impreso no lo he probado, por lo que no garantizo que esté bien, lo he realizado a modo de práctica.


 El sensor de temperatura se conecta a un arduino, para luego mandar los datos al generador de vídeo.


Circuito montado y funcionando.


Visualización de la señal de video compuesto en un televisor.

PROGRAMA

Para programar el ATmega328 he utilizado un arduino en modo programador.
En mi anterior artículo (simuld.html) explico como programar el microcontrolador con un arduino.
Una vez montado el circuito programador debemos grabar el programa con la orden:

avrdude -C/usr/share/arduino/hardware/tools/avrdude.conf -v -v -patmega328p -cstk500v1 -P/dev/ttyUSB0 -b19200 -U flash:w:SBCVideo.hex:i -U lfuse:w:0xf7:m -U hfuse:w:0xd9:m -U efuse:w:0xff:m

Este proyecto está realizado en Debian 10.
Espero que disfrutéis haciendo este proyecto.

Saludos.
Juan Galaz


Bibliografía:

simuld.html
http://searle.x10host.com/MonitorKeyboard/index.html

martes, 24 de agosto de 2021

Grabar ATmega328 con ArduinoISP. Record ATmega328 with ArduinoISP

 

SimulIDE


Grabar fichero *.HEX en Atmega328

mediante Arduino utilizando avrdude


 


En anteriores artículos de SimulIDE había realizado una serie de proyectos con el Atmega328.
Había utilizado para programar el ensamblador, C, y Basic.
En el simulador funcionaba perfectamente, pero a los electrónicos nos gusta probar los circuitos físicamente, el ver parpadear un LED físico nos alegra.
El fichero generado es un fichero con extensión  .HEX , que es el código máquina que se carga en el microcontrolador.
En este artículo explico como cargar este código en el Atmega328 mediante un arduino.

Hace unos años cuando empezaba a utilizar los microcontroladores Atmega*** realicé un artículo de como realizar grabadores PROGRAMADOR.
El mas utilizado al final fue el USBASP , se conectaba directamente al puerto USB.
El que quiera puede realizarlo, es fácil, y el que quiera puede comprarlo por internet, es bastante barato.

En este proyecto enseño como programar un microcontrolador tipo Atmega328 mediante un arduino nano, aunque sirve cualquier  arduino.
Para este proyecto he utilizado el entorno Arduino IDE 1.0.5 , es el que viene de serie en Linux Debian 10.

Lo primero es transformarlo en un grabador mediante un programa que viene de ejemplo llamado:  ArduinoISP.


Compilamos el programa y lo cargamos en nuestro arduino.

Conectamos nuestro arduino al Atmega328 que queramos programar, y añadir una serie de componentes.

Esquema eléctrico.


Gráfico de componentes.


Circuito montado.

Para esta demostración he elegido el parpadeo de un LED colocado en la patilla 9 del Atmega328, que corresponde al puerto de salida B1.

hola.c

/*

* blink

* Juan Galaz

* seta43.duckdns.org

* seta43.blogspot.com

* 2021

*/


#define F_CPU 16000000L


#include <avr/io.h>

#include <util/delay.h>



int main (void)

{

DDRB = 0xff;

PORTB = 0x03;


while(1)

{

PORTB = 0x03;

_delay_ms(400);

PORTB = 0x00;

_delay_ms(500);

}

return 0;

}


Makefile

MCU=atmega328

F_CPU=16000000

CC=avr-gcc

OBJCOPY=avr-objcopy

CFLAGS=-std=c99 -Wall -g -Os -mmcu=${MCU} -DF_CPU=${F_CPU} -I.

TARGET=hola

SRCS=hola.c

all:
 ${CC} ${CFLAGS} -o ${TARGET}.bin ${SRCS}

${OBJCOPY} -j .text -j .data -O ihex ${TARGET}.bin ${TARGET}.hex

flash:

avrdude -C/usr/share/arduino/hardware/tools/avrdude.conf -v -patmega328p -cstk500v1 -P/dev/ttyUSB0 -b19200 -Uflash:w:${TARGET}.hex:i

flash2:

avrdude -C/usr/share/arduino/hardware/tools/avrdude.conf -v -patmega328p -cstk500v1 -P/dev/ttyUSB0 -b19200 -U flash:w:${TARGET}.hex:i -U lfuse:w:0xff:m -U hfuse:w:0xd9:m -U efuse:w:0xff:m

clean:

rm -f *.bin *.hex


Podemos observar que he creado dos tipos de grabaciones, flash y flash2.
El flash no modifica los FUSES del Atmega328, si estamos seguros de como están los fuses utiliza esta opción.
El flash2 coloca los fuses para que funcione con el el crystal de cuarzo externo. Esta opción solo es necesaria la primera vez que programemos el Atmega328.
También hemos supuesto que el arduino se encuentra en: /dev/ttyUSB0 , debiís estar seguro que este es vuestro caso.
Después de haber compilado el programa con el simuIDE, pasamos a consola y nos colocamos en el directorio donde se encuentra el fichero hola.hex.
Ahora solo nos queda teclear make flash , o make flash2 dependiendo del caso.

Consola
make flash

avrdude -C/usr/share/arduino/hardware/tools/avrdude.conf -v -patmega328p -cstk500v1 -P/dev/ttyUSB0 -b19200 -Uflash:w:hola.hex:i
.....
....

Writing | ################################################## | 100% 0.31s

avrdude: 182 bytes of flash written
avrdude: verifying flash memory against hola.hex:
avrdude: load data flash data from input file hola.hex:
avrdude: input file hola.hex contains 182 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.20s

avrdude: verifying ...
avrdude: 182 bytes of flash verified

avrdude: safemode: lfuse reads as FF
avrdude: safemode: hfuse reads as D9
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK (E:FF, H:D9, L:FF)

avrdude done.  Thank you.


Si todo fue bien veremos como comienza a parpadear el LED.

Como podemos observar para programar un ATmega328 mediante un arduino con la conexión ISP debemos unir pines entre dos ATmega328. Esto como podéis entender es altamente peligroso, un pin puede estar en estado alto y otro en estado bajo, esto puede generar una avería en alguno de los chip.
Para solucionar este tema he añadido resistencias de 330 ohmios en las líneas de comunicaciones ISP, con lo cual se soluciona este problema.
Para probar está modificación, he realizado un simple semáforo.


He comprobado que al programar con el programa arduinoISP , en la primera programación funciona bien, pero cuando se desconecta físicamente el arduino, y se vuelve a conectar nos daba error.
Solución:
Antes de mandar el fichero HEX , pulsar el botón reset en el arduino, y mientras está pulsado el reset mandar el programa a grabar.
Se suelta el reset, y vemos que se carga correctamente el programa en el ATmega328.
Este problema me ocurre en Linux, no he probado en Windows.


Espero que les guste esta serie de montajes.
Todos estos pasos se pueden ver bien en el vídeo demostrativo.

VIDEO DEMOSTRATIVO.

SOURCE

Saludos.
Juan Galaz





martes, 10 de agosto de 2021

SimulIDE - gcc-avr compiler

 




gcc-avr , GNU C compiler


En este artículo muestro como utilizar el compilador GCC-AVR .
Lo primero que debemos tener instalado el compilador gcc-avr , GNU C compiler (cross compiler for avr) .
Yo trabajo en Debian 10 y es fácil instalarlo de sus repositorios con Synaptic.
Ademas del fichero de simulación, debemos crear el Makefile junto con el programa  blink.c .
Para que se compile el programa debemos compilar el Makefile, que generará el fichero blink.hex , este será el que carguemos en el micro en la simulación.
Todos estos pasos se pueden ver bien en el vídeo demostrativo.


Circuito para blink.

blink.c
/*
 * blink
 * Juan Galaz
 * seta43.duckdns.org
 * seta43.blogspot.com
 * 2021
*/

#define F_CPU 16000000L

#include <avr/io.h>         
#include <util/delay.h>


int main (void)
{
   DDRB  = 0xff;            
   PORTB = 0x03;            

    while(1)
        {
             PORTB = 0x01;
            _delay_ms(500);
             PORTB = 0x00;
            _delay_ms(500);
        }
    return 0;           
}

Makefile
MCU=atmega328
#F_CPU=16000000
CC=avr-gcc
OBJCOPY=avr-objcopy
#CFLAGS=-std=c99 -Wall -g -Os -mmcu=${MCU} -DF_CPU=${F_CPU} -I.
CFLAGS=-std=c99 -Wall -g -Os -mmcu=${MCU}  -I.
TARGET=blink
SRCS=blink.c

all:
    ${CC} ${CFLAGS} -o ${TARGET}.bin ${SRCS}
    ${OBJCOPY} -j .text -j .data -O ihex ${TARGET}.bin ${TARGET}.hex

flash:
    avrdude -p ${MCU} -c usbasp -U flash:w:${TARGET}.hex:i -F -P usb

clean:
    rm -f *.bin *.hex

He creado dos blink, el segundo llamado hola2.c , donde la funcion de delay las creo yo mediante un código en ensamblador insertado en el código C.


Programa que genera una serie de pulso con diferentes frecuencias, dependiendo del pulsador seleccionado.


Un contador automático que muestra la cuenta en un LCD.
Además dispone de un pulsador para poner el contador a cero.
He de comentar que en la utilización del LCD he tenido que cambiar la inicialización del desplazamiento.
//SENDI(0x04);    //modo decremento para el 1602
SENDI(0x06);     //modo incremento para el Hd44780
Aún tengo la duda si son diferentes o el simulador funciona mal.


Un contador que cuenta las pulsaciones en un pulsador.
Mediante otro pulsador ponemos el contador a cero.


Un simple semáforo


Espero que les guste esta serie de montajes.

PROGRAMAS FUENTE

VIDEO DEMOSTRATIVO.


Saludos.
Juan Galaz





lunes, 2 de agosto de 2021

SimulIDE Avra asm compiler

 




Avra  Avr asm compiler.


Después de varios artículos sobre el programa simulIDE, nos ponemos a programar en ensamblador con Avra  Avr asm compiler.
Hace unos años había programado en ensamblador para el microcontrolador ATmega88, y ahora que quiero probar simulIDE es un buen comienzo.
miATa2.html
miATa1.html
Trabajo en un entorno de Linux con Debian 10, por lo cual tengo instalado el ensamblador avra que es el que utilizo para ensamblar el código máquina.
En primer lugar realizo un programa que hace parpadear un LED , es el hola mundo en cuanto a programación.

Es un programa sencillo que permite probar el entorno de simulIDE junto con avra.



El siguiente programa es el clásico de utilizar un pulsador para encender un LED




El siguiente es un contador automático. Sirve para probar un LCD.


En este contador cuenta las pulsaciones de un botón.
También tenemos otro botón para contar, pero en este caso utiliza las interrupciones.


En este montaje realizo un reloj con fecha.

Utilizo el reloj interno de 8Mhz y coloco en el contador-2 el cristal de 32768 Hz.
Este cristal de cuarzo (32768) se debe colocar entre los pins B6-B7, en el simulador no lo he podido representar.
En un circuito real deberíamos programar los FUSES para que se emplee el reloj interno de 8MHz.

Para terminar con estas prácticas realizaré un semáforo simple.



Espero que les guste esta serie de montajes.

PROGRAMAS FUENTE

VIDEO DEMOSTRATIVO.


Saludos.
Juan Galaz





jueves, 29 de julio de 2021

simulIDE , gcBasic, atmega328,avr

 

SimulIDE




El programa simuIDE  está bastante conseguido, y una de sus posibilidades es utilizar el programa GcBasic .
El programa GcBasic es un compilador de Basic para poder programar microcontroladores PIC y AVR.
En principio el GcBasic estaba pensada para PIC pero posteriormente se realizó para AVR, por lo cual la mayoría de los ejemplos son para PIC.
Lo curioso de este programa es que esta realizado en Basic, y para obtener los binarios debemos compilarlos con FreeBasic.
En mi caso utilizo Debian 10, y antes debo bajar las fuentes de FreeBasic y compilar.
    https://www.freebasic.net/
Después de compilar FreeBasic nos toca bajar las fuentes de GcBasic y compilar.
    http://gcbasic.sourceforge.net/Typesetter/index.php/Home
Terminado este proceso tenemos el fichero binario que se ejecutará en Linux, y a la vez poderse utilizar en SimulIDE.




He creado un video de como programo en Basic el Atmega328.

https://youtu.be/7r6W4W6KElU



Saludos.
Juan Galaz