De editor a IDE, o lo que es lo mismo: VIM con esteroides.

Normalmente suelo usar un IDE como Eclipse, Netbeans o cualquier otro para tirar código por que son cómodos, estan enfocados al desarrollo y bla, bla, bla... Pero estos IDE's hechos en java, en ruby en lo que sea, algunos pueden ser muy pesados y otros no tantos, pero consumen más recursos de los editores como sublime, atom, note++ (Si, muchos lo siguen usando por... Por que no sé...) es que son editores con algunas ventajas muy cómodas a la hora de escribir código, sacrificando otras, pero que son EDITORES de código (Hacen y no hay punto de comparación con un IDE, así que ni lo intente pensar en sus cabesitas locas.)

Hace unos meses me enfrente a un problema en la oficina, y no es el café, si no los recursos de la maquina que tengo para poder hacer lo que debo. Así que hice lo que debía, pero tener la IDE, el cliente de base de datos (Si, ya sé que aman phmMyAdmin sobre todas las cosas... yo no) docenas de pestañas en el browser y alguna otra cosa en extra... hacían que la maquina fuera por lo suelos en rendimiento. Cambiamos algunas cosas, entorno gráfico, menos pestañas en el browser, ya no mas reproductor de audio en la maquina... usamos en pool data del IDE y dejamos ir al workbrench un rato, pero el IDE seguía consumiendo tantos recursos, hasta el punto de ser molesto.

Así negando a usar un editor de código popular, elegí entre todos los males, el peor, ¿por qué escoger la opción menos malvada? Tomamos vim como el equipo de GEx y lo pusimos bello para editar las necesidades del día al día.

Para lograr esto, usaremos plugins y para hacerlo de la manera mas rápida, usaremos Vundle, un gestor de paquetes para vim que nos permite manejar los paquetes desde el vimrc, lo cual para empezar, debemos clonar el proyecto en nuestra carpeta .vim/bundle/

$ git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim

y crear (en caso de no tenerlo) nuestro .vimrc en el home de nuestro con el siguiente esqueleto, donde poco a poco iremos armando para poder incluir los paquetes (plugins) necesarios o que necesitemos según los gustos de cada quien. Y para ello, les recomiendo la pagina de vimawesome.com donde encontraremos todo lo que necesitemos para convertir a nuestro editor en una pequeña IDE.

set rtp+=~/.vim/bundle/Vundle.vim
" alternatively, pass a path where Vundle should install plugins
" "call vundle#begin('~/some/path/here')
call vundle#begin()
" " let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'
call vundle#end()            " required
filetype plugin indent on    " required
" " Brief help
" " :PluginList       - lists configured plugins
" " :PluginInstall    - installs plugins; append `!` to update or just
" :PluginUpdate
" " :PluginSearch foo - searches for foo; append `!` to refresh local cache
" " :PluginClean      - confirms removal of unused plugins; append `!` to
" auto-approve removal
" " see :h vundle for more details or wiki for FAQ

Vim por si solo nos da muchas ayudas de forma nativa para poder editar código, como resaltado de sintaxis, autoidentado, tamaño del espacio en tabulador, etc, que si bien son una gran ayuda, no son los suficiente para ayudarnos al trabajo del día a día, para ello, les recomiendo Syntastic que nos ayudara a checar errores en la sintaxis y que soporta una gran cantidad de lenguajes.

Otra necesidad, es poder navegar por el proyecto sin tener que salir de vim, para lo cual tenemos la ayuda de NERDTree, un explorador de filesystem desplegado en un árbol, el cual nos permite ver carpetas y abrir los archivos necesarios sin salir del editor.

La necesidad de hoy en día, nos obliga a tener una manera de poder navegar en nuestro código teniendo a la mano las variables y funciones para poder navegar mejor entre tantas lineas de código y evitar la perdida de estar buscando de forma manual, por ello existe Tagbar que requiere que tengamos instalado ctag, el cual podemos compilarlo o descargarlo desde nuestro gestor de dependencias favorito.

Los IDE's modernos nos permiten el autocompletado de código, lo cual es una gran ayuda a la hora de escribir de una forma mas rápida y no cometer errores de sintaxis, en lo personal, uso YouCompleteMe, el cual requiere que clones el proyecto en tu carpeta de Bundles y compiles.

cd ~/.vim/bundle/YouCompleteMe
./install.sh --clang-completer

Para poder hacer de YouCompleteMe una experiencia totalmente agradable, usaremos SuperTab que nos ayudara a todos aquellos que estamos muy acostumbrados al autocomplete por medio del tabulador.

Otro paquete que no nos puede faltar para nuestro adorado vim, es el uso de snippets que lo encontramos en IDE's y editores como sublime o atom, y para ello, nada mejor que ultisnips, un paquete que nos ayudara a crearlos de una forma tan simple y que hará las delicias de chicos y grandes.

Y aunque existen muchas otras opciones para diferentes lenguajes como ruby, php, javascript, java o integrarlo con git creo que esto es lo básico para poder hacer de vim algo mas que un simple editor de textos.

Les dejo mi vimrc que esta adaptado para php, es lo que por el momento uso, no sin antes decirles que si gustan de tener estadísticas y datos de su forma de programar, se den una vuelta por wakatime, el cual tiene diferentes plugins para distintas IDE's, editores y si, también para nuestro adorado y amado vim.

Happy hacking.

Java y su paso de valor "Referenciado"

Hace un tiempo, en mi paso por #GEx, se presentó una duda razonable en cuanto a #java.

Si tu creas un objeto y lo pasas a una variable, que es lo que pasa?? Mi respuesta inmediata fue: se referencia, por lo cual no se reserva memoria para este paso.

supongamos que tenemos una clase Algo y un código así.

Algo a = new Algo();
Algo b = a;
a = null;

Y esto causo realmente la duda, si a es ahora nula, por que b no? Y es que aunque a y b estén referenciados al mismo objeto, no están relacionados de ninguna otra forma, por lo que una asignación como en este caso, al objeto a, lo desenganchará del objeto original, pero no afectara a b en lo mínimo. Por lo cual, a es nulo, pero b sigue apuntando al objeto original, pero no es realmente asi.

Si bien, la VM relaciona la variable a y b por medio del id, a y b son una copia del objeto creado (Si, al ser copia, se hace la asignación de este en memoria). Así que si hacemos algo como esto (disculpen que use la imprudencia de #Groovy, pero es que si soy un poco flojo).

class Algo{
  def name;
}

Algo a = new Algo(name:"basura")
Algo b = a

println "Esto contiene la variable a: ${a.getName()}"
println "Esto contiene la variable b: ${b.getName()}"
println "Este es el id del objeto a: ${a.hashCode()}"
println "Este es el id del Objeto b: ${b.hashCode()}"

En este punto, la variable name va a tener el mismo valor tanto para a como para b, y los id de cada uno serán idénticos, lo cual nos haría pensar que si, el paso es por referencia y no por valor. Y si seguimos jugando con esto, mas nos hará pensar lo mismo!

b.setName("Random");
println "Esto contiene la variable a: ${a.getName()}"
println "Esto contiene la variable b: ${b.getName()}"
println "Este es el id del objeto a: ${a.hashCode()}"
println "Este es el id del Objeto b: ${b.hashCode()}"
a.setName("Uetiko")
println "Esto contiene la variable a: ${a.getName()}"
println "Esto contiene la variable b: ${b.getName()}"
println "Este es el id del objeto a: ${a.hashCode()}"
println "Este es el id del Objeto b: ${b.hashCode()}"

Y si, sigue cambiando y cambiando y no deja de ser el mismo id, pero como bien se ha mencionado antes, todo cambia cuando haces a una de las dos nula:

a = null
try{
  println "Esto contiene la variable a: ${a.getName()}"
}catch(Exception e){
  println e.getMessage()
}
println "Esto contiene la variable b: ${b.getName()}"
println "Este es el id del Objeto b: ${b.hashCode()}"

Aquí vemos como la variable 'a' la hacemos nula y la marcamos para que sea procesada por el GC, y esperanzados a que b, que era una referencia, pues muera de igual forma, por desgracia no es así como funciona, ya que si recordamos las sabias palabras de Ken Arnold y James Gosling, nos damos cuenta que si, la VM al estar pensada para que corra en diferentes arquitecturas, lo mas lógico es que la única forma de pasar valores en java, es por valor, ya que esto ayuda a la simpleza.

Con amor, Random.

Como recuperar sectores dañandos del disco duro dese la linea de comados de linux

Los discos duros no son eternos y a menos de que sean de estado sólido, están sujetos a errores de escritura por una mala imantación o por otras causas que son ajenas a uno como usuario. Así que siempre es bueno hacer un backup de nuestros datos en una unidad externa, ya sea en un storage en la red o en una usb que este bien oculta bajo la almohada.

Una buena práctica es hacerlo cuando el sistema operativo empiece a decirnos este tipo de cosas, que si no lo hacemos, a la larga nos sea más difícil o tardado este tipo de cosas. Así que hagan caso, hagan un back up y denle a esos sectores.

¿Cómo lo hacemos?

Abrimos nuestra tan amada consola para los que somos "consoleros" de corazón, para los que no, igual, abran la consola y cambien a super usuario.

Lo más recomendable es que si como yo, tienen más de una partición o de plano no se acuerdan del nombre de la partición, ejecuten fdisk

[root@uetiko]# fdisk -l
Disposit. Inicio Comienzo Fin Bloques Id Sistema
/dev/sda1 * 1 10947 87931746 5 Extendida
/dev/sda2 10948 19092 65424712+ 83 Linux
/dev/sda3 19093 19457 2931862+ 82 Linux swap / Solaris
/dev/sda5 1 10947 87931714+ 83 Linux

Y es así como ya teniendo nuestro listado de particiones, podremos reparar los sectores. Es importante que la partición ese desmontada o nos dará dolores de cabeza cuando nos salga que el dispositivo está siendo ocupado.

Para esto, basta un unmount podremos resolver el problema

[root@uetiko]# unmount /deb/sda1

Y ahora si, viene el momento de la verdad, y es aquí donde radica la magia para poder un disco duro guapo y en forma. Para ello usamos un comando que se llama badblocks, el cual tiene muchas chunchitas para que podamos analizar y reparar sectores y demás, pero por ahora nos limitaremos a jalar del gatillo y esperar que el disparo de en el blanco. Si no lo tienen, solo bájenlo de los repositorios con su gestos de paquetes preferido según su diestro.

[root@uetiko]# badblocks -s -v -f /dev/sda1

Y esperen a que el programa haga su trabajo. Claro, esto les causara un infarto cuando termine y vean que algunos de sus datos han... como decirlo, desaparecido extrañamente, para evitar esto y que en lo personal, no recomiendo, es agregar la opción -n para que así, no borre ningún dato cuando repare los sectores dañados, claro, esto les llevara mucho, pero mucho tiempo, así que si lo hacen, recomiendo que salgan al cine con la novia/amiga, la lleven a cenar y después regresen haciendo paradas en cualquier bar/cafetería que encuentren.

Programando pic's desde linux. (config.inc)

Creo que la chamba mas fácil siempre es la de configurar el pic, ponerle las entradas, salidas y activar una que otra bandera de interrupción.

Básicamente diremos lo siguiente.

• Puerto A fue usado para el convertidor analógico digital RA0, RA1, RA2 (Valores de referencia), RA3 (Valores de referencia), RA4 y RA5.
• Puerto B para uso de teclado por su patita RB0/INT Que genera interrupción, y por que se puede programar las patitas RB4-RB7 como interrupción por cambio de estado.
• Puerto C, uso de Led's o cualquier otra cosa que le quieran colgar.
• Puerto D, bus de datos para la pantalla LCD.
• Puerto E, lineas de control para LCD.
  

;************************************************
;Libreria de configuración general del pic.

;***************************************************
;Configura la direccionalidad de los puertos del PIC

Init_Config
bcf STATUS,RP0
bcf STATUS,RP0
clrf PORTA

movlw b'11110000' ;Configiración del puerto B para el teclado
movwf PORTB
call Init_interrup

bsf STATUS,RP0
bcf STATUS,RP1
clrf TRISC

clrf TRISD
clrf TRISE
call Init_ADC
bcf STATUS,RP0

return

;******************************************
;Habilitando interrupciones
Init_interrup
movlw b'11111000'
movwf INTCON

return

;******************************************
;Rutina de configuración del ADC
Init_ADC
;bsf STATUS,RP0
;bcf STATUS,RP1
movlw b'10001100' ;configuramos las entradas del ADC para abrir 3 canales

movwf ADCON1 ;y tener dos valores de referencia.
bcf STATUS,RP0
movlw b'01000000'

movwf ADCON0
return

;******************************************
;Rutina de configuración del Timer1
TMR1_Config
clrf T1CON

bsf STATUS,RP0
bcf STATUS,RP1
bcf PIE1,TMR1IE ;Inhabilitando el desbodamiento del TMR1

bcf STATUS,RP0
clrf TMR1L
clrf TMR1H
bsf PIE1,TMR1IE

movlw 0x36
movwf T1CON
return

Lo basico e indispensable.

Me das la hora?

La verdad es que eso lo hice de rápido y pero la idea es mostrar un while en ensamblador de una forma básica. Espero les pueda servir y bueno, ya luego les pongo el método principal.


__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF

list p=pic16f877
include <p16f877.inc>

;Variables
Cont equ 0x20

Hrs equ 0x21
Min equ 0x22
Seg equ 0x23
ContadorC equ 0x24

Temp0 equ 0x25
Temp1 equ 0x26
ContadorB equ 0x27
ContadorA equ 0x28

org 0
goto Principal
org 4
retfie

org 5

Un_Min
movlw d'60'
movwf Temp0

decfsz Temp0,1 ;Este es mi while. Temp0 == 0?
goto retraso_1_seg ;No...
return ;Si!

retraso_1_seg
movlw D'6'
movwf ContadorC

retraso_1_seg_bucle
call sub_delay_1_seg

decfsz ContadorC,1 ; Aquí otro; ContadorC == 0?
goto retraso_1_seg_bucle ;No...
return ;Si!!1

sub_delay_1_seg
movlw D'217'
movwf ContadorB
movlw D'111'

movwf ContadorA

sub_delay_1_seg_bucle
decfsz ContadorA,1
goto sub_delay_1_seg_bucle

decfsz ContadorB,1
goto sub_delay_1_seg_bucle
return

Programando pic's desde linux. (ADC)

Ayer se descubrió mientras la lluvia caía, que el error el cual trate de encontrar desde el lunes, fue simplemente el un cambio de memoria... Suele pasar y eso que ni qué... El mundo del debuggeo es muy entretenido y te deja cosas muy buenas.

Así que hoy para variar, me he puesto a darle duro a esto para poder partir en mas fragmentos y mejor documentados, por lo que la configuración quedo dividida en los una rutina mas para la configuración del ADC y una para la configuración general del PIC.


org 0
call Init
call ADC_Config
goto Principal
org 4
retfie

Y con esto tenemos un mejor panorama de la configuración del modulo de ADC del PIC. Basta señalar que Init solo configura los puertos de entrada y salida. Pero ADC_Config se limita a configurar el modulo como esta a continuación.


ADC_Config
;Cambiando al banco 1 para configuracion del ADC
bsf STATUS,RP0
bcf STATUS,RP1

;Desactivando las interrupciones
clrf INTCON
clrf PIE1
;Configurando las patitas del puerto A
movlw 0x8F

movwf ADCON1
;Cambiando de banco. Y con esta linea arreglamos el problema que teniamos con el mal funcionamiento del pic.
bcf STATUS,RP0
;Seleccionando la frecuencia de reloj para la conversión. Fosc/8

;ADCS1=0
;ADCS0=1
;ADON=1
movlw 0x41
movwf ADCON0

;Configurando el bit de estado de la conversión.
;GO=1. Iniciandoce la conversión.
bsf ADCON0,GO
return

Y con esto resolvemos el problema de sobre escritura de ADCON1. y podremos seguir. Ya les ire poniendo mas cosas para que podamos seguir experimentando.

Programando pic's desde linux. (código)

El viernes paso algo muy curioso, el programa no jalo ni hizo lo que tenia. Es mas, ni siquiera hizo algo. Pero como a la par también revisaba el código para el LCD, no me quedo tiempo para debuggear en MPLAB. Y siendo sinceros, no tenia ni idea de algunas partes del código.

Así que valientemente iremos a cazar leones con una varita.

Así que antes de que podamos hacer algo en cuanto al código, hay que saber que hace y por que lo hace.

Primero vamos a configurar el pic.

Código:

Init
bcf STATUS,RP0
bcf STATUS,RP1
clrf PORTA

clrf PORTB
clrf PORTC
clrf PORTE
clrf PORTD

bsf STATUS,RP0
;Desactivando las interrupciones
clrf INTCON
clrf PIE1

;Configurando las patitas del puerto A
movlw 0x8F
movwf ADCON1
;---------------------------
clrf TRISB

clrf TRISE
bsf STATUS,RP0
;Seleccionando la frecuencia de reloj para la conversión. Fosc/8
;ADCS1=0

;ADCS0=1
;ADON=1
movlw 0x41
movwf ADCON0
;Configurando el bit de estado de la conversión.

;GO=1. Iniciandoce la conversión.
bsf ADCON0,GO
bcf STATUS,RP0
return

Ahora veremos que hace la función de leer.

Leer_ADC
;Se concatena IRP con FSR para seleccionar el banco de RAM
;0=Banco 0 y 1 (00h-FFh)
bcf STATUS,IRP
movwf FSR

movf INDF,w
movwf LSB
movlw 0x1E
movwf FSR

movf INDF,w
movwf MSB
bsf ADCON0,GO
return

Programando pic's desde linux. (código)

En este punto, aún puedo escuchar un viejo reclamo de una amiga muy querida que solía decirnos a su novio y a mi: 'Estas como medio obsesionado con la programación. Me das miedo...'

Y siguiendo esa línea y en el mismo mood, se me ha dado la idea de hacer y poner todo un programa comentado para compartirlo con la comunidad estudiantil que lo necesite.

Espero que les pueda servir de algo.

; Programa de muestra hecho para el estudio de mi enanisima!!!

;Bits de configuración.
;LVD_OFF=Programa de voltaje bajo apagado. 

;CP_OFF=Protección de código
;PWRTE_ON=habilita el reset mediante power up timer
;XT_OSC=Se utiliza un cristal de cuarzo
;BODEN_OFF=desabilita el reset por caida de tención.
;WDT_OFF= DESABILITA EL PERRO GUARDIAN.

__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF

;Generador de archivos list y llamada a librerias.

 list p=pic16f877
 ;RADIX HEX
 include<p16f877.inc>

;Declaración de variables
 ;b'00000111' Este valor pasa al registro OPTION_REG para configurar el divisor de frecuencia.
 Prescaler equ d'256'
 TMR_50ms equ d'56'

 Cont  equ 0x20
 Cont1  equ 0x21
 Temp  equ 0x22

 
;indicadores del pic16f877

 org 0x00
;Llamando a la rutina de configuración del pic.
 call Init

;Llamando a la rutina principal del programa.
 goto Principal 
 org 4
 retfie
 org 5

;rutinas

Init
 ;Cambiando al banco0.
 bcf STATUS,RP0
 bcf STATUS,RP1

 ;limpiando los puertos
 clrf PORTA
 clrf PORTB
 clrf PORTC

 clrf PORTE
 ;Cambiando al  banco1
 bsf STATUS,RP0
 ;Cambiando puertos de entrada a salida

 ;clrf TRISA
 clrf TRISB
 clrf TRISC
 clrf TRISD

 clrf TRISE
 ;Cambiando al banco0
 bcf STATUS,RP0
 return

confPrescaler
 bcf STATUS,RP1
 bcf STATUS,RP0
 movlw b'00000001'

 movwf OPTION_REG

;Algoritmo proporcionado por Labra Porthela Victor Manuel 
;Lazo anidado.
delay10mS
 movlw d'21'

 call dmS
 return

dmS
 movwf Cont

ciclo
 decfsz Cont,F
 goto dmS1
 return

dmS1

 call d500uS
 nop
 goto ciclo

d500uS
 movlw d'163'

 call duS
 return

duS
 movwf Cont1
 

ciclo1
 decfsz Cont1,F
 goto ciclo1
 return

;Programa principal.

Principal
;Usaremos el puerto A como entrada y el puesto B como salida.
 movlw PORTA
 movf PORTB
 call delay10mS
 goto Principal 
 end

Números primos vía ensamblador

Después de pelearme un poco con este programa debido a los errores de dedo que tengo, ya quedo mi programa de numeros primos escrito en ensamblador para el procesador 8051. Así que sin mas demoras, les presentamos al código!!!

clr A;
clr C;

mov DPTR, #TablaPrimos ;

mov r3, #00h ;
mov r4, #02h ;
mov r5, #0FEh ;
mov r6, #02h ;
mov 20h, #0Fh ;
mov 30h, #05h ;
mov 31h, #09h ;
mov 32h, #03h ;

;; primos
mov DPTR, #TablaPrimos;
mov 20h, #00h ;
acall paresinc ;
mov 20h, #41h
acall paresdec ;

;; Rutina de retardo

tiempito:
mov 90h, A;
mov r0, #02;
in1: mov r1, #040h;
in2: mov r2, #090h;

wait: djnz r2, wait;
djnz r1, in2;
djnz r0, in1;
ret;

;; Rutinas para pares

paresinc:
inc 20h ;
mov A, 20h ;
mov B, r6 ;
;; Divición entre 2
div AB ;
mov A, B ;
cjne A, #00h, paresinc ;
mov A, 20h ;
mov B, 20h ;
;; Divición entre si mismo
div AB ;
mov A, B ;
cjne A, #00h, paresinc ;
mov A, 20h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 20h ;
cjne A, #41h, paresinc ;
ret

paresdec:
dec 20h ;
mov A, 20h ;
mov B, r6 ;
;; Divición entre 2
div AB ;
mov A, B ;
cjne A, #00h, paresdec ;
mov A, 20h ;
mov B, 20h ;
;; Divición entre si mismo
div AB ;
mov A, B ;
cjne A, #00h, paresdec ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 20h ;
cjne A, #00h, paresdec ;
ret


TablaPrimos:

DB 11111111B;
DB 11111110B;
DB 11111101B;
DB 11111100B;
DB 11111011B;
DB 11111010B;
DB 11111001B;6
DB 11111000B;7
DB 11110111B;8
DB 11110110B;9
DB 11110101B;10
DB 11110100B;11
DB 11110011B;12
DB 11110010B;13
DB 11110001B;14
DB 11110000B;15
DB 11101111B;16
DB 11101110B;17
DB 11101101B;18
DB 11101100B;19
DB 11101011B;20
DB 11101010B;
DB 11101001B;
DB 11101000B;
DB 11100111B;
DB 11100110B;
DB 11100101B;
DB 11100100B;
DB 11100011B;
DB 11100010B;
DB 11100001B;30
DB 11100000B;31
DB 11011111B;32
DB 11011110B;33
DB 11011101B;34
DB 11011100B;35
DB 11011011B;36
DB 11011010B;
DB 11011001B;38
DB 11011000B;39
DB 11010111B;40
DB 11010110B;41
DB 11010101B;42
DB 11010100B;43
DB 11010011B;44
DB 11010010B;45
DB 11010001B;
DB 11010000B;
DB 11001111B;
DB 11001110B;
DB 11001101B;50
DB 11001100B;
DB 11001011B;
DB 11001010B;
DB 11001001B;
DB 11001000B;55
DB 11000111B;
DB 11000110B;
DB 11000101B;
DB 11000100B;
DB 11000011B;60
DB 11000010B;
DB 11000001B;
DB 11000000B;
DB 10111111B;
DB 10111110B;65

end

Jugando con ensamblador. Que mello!!

Cada que me siento tras una IDE o un editor de textos como emacs o vi, en mi cabeza se invoca la voz de mi amiga Argelia que le reclama a su novio y a mi: Estas como medio obcesionado con la programación. Y como decirles que es mentira. 

Normalmente me dedico a programar en java, c, cuando se requiere en sql estandar y de vez en cuando en algo mas como visual o C#, pero no son lenguajes que me llamen la atención. Pero ahora me ha tocado programar en un viejo amigo complemento de C, si, ensamblador, o como le llamamos: Empalador (Pa' los cuates).

Así que me puse a recordar el set de instrucciones para la serie 8086 (i386) de intel. Pero oh sorpresa que me di, pues el micro que usamos es uno viejito, pero lindo. Me refiero al 8051, y por suerte su set de instrucciones es mas simple, pero mas rarito que el complejo set del i386. Pero ya te tome modo y este es el RC1 para uno de mis proyectos. 

Con ustedes, el código fuente!!! Aplausos, señores!

Este es un programa que manda por el puerto 1 numeros del 1 al F hexadesimal y hace dos sumas. Usa una tabla en apuntadores. 

clr A;
clr C;

mov DPTR, #Tabla ;
mov r3, #0 ;
mov r4, #02 ;
mov 20h, #0Fh ;
mov 30h, #05h ;
mov 31h, #09h ;
mov 32h, #03h ;
 
 ;; led's test
acall test ;
NOP ;
acall separador ;

 ;; Suma

mov A, 30h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 32h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
 
 ;; separador de suma
 
acall separador ;

mov A, 30h ;
add A, 32h ;
movc A, @A+DPTR ;
mov P1, A ;
acall Tiempito ;

acall separador ;

 ;; Suma

mov A, 31h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 30h ;
movc A, @A+DPTR ;
acall tiempito ;

 ;; Sepaarador de suma
acall separador ;

mov A, 31h ;
add A, 30h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;


 ;; tabla
Tabla:
DB 11000000B; 0
DB 11111001B; 1
DB 10100100B; 2
DB 10110000B; 3
DB 10011001B; 4
DB 10010010B; 5
DB 10000010B; 6
DB 11111000B; 7
DB 10000000B; 8
DB 10010000B; 9
DB 10001000B; a
DB 10000011B; b
DB 11000110B; c
DB 10100001B; d
DB 10000110B; e
DB 10001110B; f

 ;; Rutina de retardo

tiempito:
 mov 90h, A;
 mov r0, #02;
 in1: mov r1, #040h;
 in2: mov r2, #090h;

 wait: djnz r2, wait;
  djnz r1, in2;
  djnz r0, in1;
  ret;
 
 ;; Rutina del test

test: mov A, 20h ;
 movc A, @A+DPTR ;
 mov P1, A ;
 acall tiempito;
 mov A, 20h ;
decr: subb A, #01h ;
 mov 21h, A ;
 movc A, @A+DPTR ;
 mov P1, A ;
 acall tiempito ;
 mov A, 21h ;
 jnz decr ;
 ret ;

 ;;Rutina de separador.

separador:
 mov A, #0B6h ;
 mov P1, A ;
 acall tiempito ;
 ret