# Desamblar código *.hex



## Meta (Jul 14, 2008)

Hola:

Aquí tengo un código que hice muy pequeño.
He intentado desamblar alguno pero grande y no soy capaz de saber que PIC usa, ni configuración, sólo las instrucciones.

Los dejo aquí el código que hice muy pequeño a ver si alguien sabe desamblarlo y hacerlo funcionar en el MPLAB, lo he probado con v8.14. Al menos saber que hace este programa que hice.

```
:020000040000FA
:1000000083168601FF308500831286018501051C59
:0E0010000C28061386170728061786130728E4
:02400E00F13F80
:00000001FF
```

Saludos.


----------



## mcrven (Jul 14, 2008)

Amigo Meta, antes de intentar "de-ensamblar" ese tipo de código "HEX", se debe filtrar el formato serial correspomdiente al formato Intel.

Te anexo un archivo que te explica en qué consiste y, con eso, vasa a poder leer los datos válidos del programa.

Saludos:


----------



## Chico3001 (Jul 14, 2008)

```
bsf status,rp0	; switch to bank 1
	clrf trisb
	movlw FF	; d'255' b'11111111' a''
	movwf trisa
	bcf status,rp0	; switch to bank 0
	clrf portb
	clrf porta
lbl_2	btfss porta,0
	goto lbl_1	; lbl_1 = 0xC
	bcf portb,6
	bsf portb,7
	goto lbl_2	; lbl_2 = 0x7
lbl_1	bsf portb,6
	bcf portb,7
	goto lbl_2
ORG 0x2007
	addlw F1	; d'241' b'11110001' a''
```


----------



## Meta (Jul 14, 2008)

Bien hecho campeón. ¿Sabes la configuración y el PIC?

Ya lo pondré entero con mis explicaciones.


----------



## Chico3001 (Jul 15, 2008)

Nop.. .esa información no se incluye en el archivo HEX... tampoco la configuracion de bits.... 

Generalmente esa iformacion viene en archivos separados (no recuerdo la extension pero creo que son .OBJ o .COF) o solo la conoce el usuario 

Saludos...


----------



## Meta (Jul 15, 2008)

Veo que la configuración las has sacado y es esa. Esa configuración te tiene que venir porque el PIC sabe lo que has programado, me refiero el CD, PWRT, WDT, etc cosas así.


```
ORG 0x2007
   addlw F1   ; d'241' b'11110001' a''
```

El Pic que utilicé es el 16F84A.


```
ORG 0x2000       ; ID

       Data   0x3FFF
       Data   0x3FFF
       Data   0x3FFF
       Data   0x3FFF

     ORG 0x2007       ; CONFIG

       Data   0x3FF1
```

El      ORG 0x2100       ya corresponde a la dirección EEPROM del 16F84A.

Lo de saber el PIC no se.

*¿Lo has descompilado a mano o con algún programa?*


----------



## Vick (Jul 15, 2008)

Abre el archivo .hex en el IC-PROG y ahí hay una opción de verlo en hexadecimal o en ensamblador, con el botón que tiene una A.


----------



## Chico3001 (Jul 15, 2008)

use un decompilador que me encontre en la red.... 

http://www.geocities.com/dinceraydin/pic/djdasm/djdasm.html

Saludos..


----------



## Meta (Jul 16, 2008)

Chico3001 dijo:
			
		

> use un decompilador que me encontre en la red....
> 
> http://www.geocities.com/dinceraydin/pic/djdasm/djdasm.html
> 
> Saludos..



Gracias, es lo mejor que he visto.


----------



## asherar (Jul 16, 2008)

Meta dijo:
			
		

> Chico3001 dijo:
> 
> 
> 
> ...



Yo directamente me lo bajé ! No sé para qué, pero clin caja !

http://www.geocities.com/dinceraydin/pic/djdasm/djdasm_1_beta1.zip


----------



## Meta (Jul 16, 2008)

ME lo había bajado, tal vez para que lo pongamos en nuestra Web, si tenemos alguna.


----------



## asherar (Jul 29, 2008)

Meta dijo:
			
		

> ME lo había bajado, tal vez para que lo pongamos en nuestra Web, si tenemos alguna.



Buena idea. Fijate si te sirve algo de lo mío.

 raíz 
 clasificado 
 descargas


----------



## Meta (Jul 26, 2017)

Hola:

El descompilador jdjasm ya no funciona. ¿Hay otro por ahí que valga la pena?

Saludos.


----------



## Meta (Ago 17, 2017)

Buenas:

Les dejo el descompilador en zip que se puede descargar. Es del djdasm.

Aquí hay una especie de pseudocódigo en C para descompilar el hex del PIC16F84A.

```
bits1413 = (0b11_0000_0000_0000 & opcode) >> 12;      // extraemos los dos bits superiores

switch (bits1413) {
   case 0b00:
      // en este caso, el tercer nibble es la operación, el bit 7 es la suboperación o destino, y el resto, el operando
      nibble3  = (0b00_1111_0000_0000 & opcode) >> 8;
      bit7     = (0b00_0000_1000_0000 & opcode) >> 7;
      operando = (0b00_0000_0111_1111 & opcode);

      switch (bit7) {
         case 0:
            reg = 'W';
            break;
         case 1;
            reg = 'F';
            break;
      }

      switch (nibble3) {
         
         case 0x0:
            switch (bit7) {
               case 1:
                  printf("MOVWF %x\n", operando);
                  break;
               case 0;
                  // aquí pueden ocurrir varios casos, según el primer nibble
                  nibble1 = (0b00_0000_0000_1111 & opcode);
                  switch (nibble1) {
                     case 0x0:
                        printf("NOP\n");
                        break;
                     case 0x4:
                        printf("CLRWDT\n");
                        break;
                     case 0x9:
                        printf("RETFIE\n");
                        break;
                     case 0x8:
                        printf("RETURN\n");
                        break;
                     case 0x3:
                        printf("SLEEP\n");
                        break;
                  }
                  break;
            }
            break;
         case 0x1:
            switch (bit7) {
               case 0:
                  printf("CLRW\n");
                  break;
               case 1;
                  printf("CLRF %x\n", operando);
                  break;
            }
            break;
         case 0x2:
            printf("SUBWF %x,%c\n", operando, reg);
            break;
         case 0x3:
            printf("DECF %x,%c\n", operando, reg);
            break;
         case 0x4:
            printf("IORWF %x,%c\n", operando, reg);
            break;
         case 0x5:
            printf("ANDWF %x,%c\n", operando, reg);
            break;
         case 0x6:
            printf("XORWF %x,%c\n", operando, reg);
            break;
         case 0x7:
            printf("ADDWF %x,%c\n", operando, reg);
            break;
         case 0x8:
            printf("MOVF %x,%c\n", operando, reg);
            break;
         case 0x9:
            printf("COMF %x,%c\n", operando, reg);
            break;
         case 0xA:
            printf("INCF %x,%c\n", operando, reg);
            break;
         case 0xB:
            printf("DECFSZ %x,%c\n", operando, reg);
            break;
         case 0xC:
            printf("RRF %x,%c\n", operando, reg);
            break;
         case 0xD:
            printf("RLF %x,%c\n", operando, reg);
            break;
         case 0xE:
            printf("SWAPF %x,%c\n", operando, reg);
            break;
         case 0xF:
            printf("INCFSZ %x,%c\n", operando, reg);
            break;
      }
      break;
   case 0b01:
      // en este caso, los bits 12 y 11 es la suboperación, los bits 8, 9 y 10 es el número de bit, y el resto, el operando
      subop    = (0b00_1100_0000_0000 & opcode) >> 10;
      bit      = (0b00_0011_1000_0000 & opcode) >> 7;
      operando = (0b00_0000_0111_1111 & opcode);

      switch (subop) {
         case 0x0;
            printf("BCF %x,%d\n", operando, bit);
            break;
         case 0x1;
            printf("BSF %x,%d\n", operando, bit);
            break;
         case 0x2;
            printf("BTFSC %x,%d\n", operando, bit);
            break;
         case 0x3;
            printf("BTFSS %x,%d\n", operando, bit);
            break;
      }
      break;
   case 0b10:
      // ver el bit 12. El resto es el operando
      bit12    = (0b00_1000_0000_0000 & opcode) >> 11;
      operando = (0b00_0111_1111_1111 & opcode);

      switch (bit12) {
         case 0:
            printf("CALL %x\n", operando);
            break;
         case 1:
            printf("GOTO %x\n", operando);
            break;
      }
      break;
   case 0b11:
      // el tercer nibble es la suboperación, y el resto, el operando
      nibble3  = (0b00_1111_0000_0000 & opcode) >> 8;
      operando = (0b00_0000_1111_1111 & opcode);
      
      switch (nibble3) {
         case 0b0000:
         case 0b0001:
         case 0b0010:
         case 0b0011:
            printf("MOVLW %x\n", operando);
            break;
         case 0b0100:
         case 0b0101:
         case 0b0110:
         case 0b0111:
            printf("RETLW %x\n", operando);
            break;
         case 0b1000:
            printf("IORLW %x\n", operando);
            break;
         case 0b1001:
            printf("ANDLW %x\n", operando);
            break;
         case 0b1010:
            printf("XORLW %x\n", operando);
            break;
         case 0b1100:
         case 0b1101:
            printf("SUBLW %x\n", operando);
            break;
         case 0b1110:
         case 0b1111:
            printf("ADDLW %x\n", operando);
            break;
      }
      break;
}
```

Hice uno en C# pero no funciona al 100%, hay que corregir cositas, lo puedes decargar para que vean el funcionamiento. Si quieren les paso el código fuente.

Si conocen alguna Web con códigos en C/C++ completo, sea en JAva, Visual Basic o lo que sea. Lo hacen saber.

Como se nota que la moda de los PIC ha disminuido demasiado.

Saludos.


----------

