Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

14/07/2008 #1

Avatar de Meta

Desamblar código *.hex
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.
Código:
:020000040000FA
:1000000083168601FF308500831286018501051C59
:0E0010000C28061386170728061786130728E4
:02400E00F13F80
:00000001FF
Saludos.
14/07/2008 #2


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:
14/07/2008 #3
Moderador

Avatar de Chico3001

Código:
	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''
14/07/2008 #4

Avatar de Meta

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

Ya lo pondré entero con mis explicaciones.
15/07/2008 #5
Moderador

Avatar de Chico3001

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...
15/07/2008 #6

Avatar de Meta

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í.

Código:
ORG 0x2007
   addlw F1   ; d'241' b'11110001' a''
El Pic que utilicé es el 16F84A.

Código:
   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?
15/07/2008 #7
Moderador

Avatar de Vick

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.
15/07/2008 #8
Moderador

Avatar de Chico3001

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

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

Saludos..
16/07/2008 #9

Avatar de Meta

Chico3001 dijo:
use un decompilador que me encontre en la red....

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

Saludos..
Gracias, es lo mejor que he visto.
16/07/2008 #10

Avatar de asherar

Meta dijo:
Chico3001 dijo:
use un decompilador que me encontre en la red....

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

Saludos..
Gracias, es lo mejor que he visto.
Yo directamente me lo bajé ! No sé para qué, pero clin caja !

http://www.geocities.com/dinceraydin...sm_1_beta1.zip
16/07/2008 #11

Avatar de Meta

ME lo había bajado, tal vez para que lo pongamos en nuestra Web, si tenemos alguna.
29/07/2008 #12

Avatar de asherar

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
26/07/2017 #13

Avatar de Meta

Hola:

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

Saludos.
17/08/2017 #14

Avatar de Meta

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.
Código:
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.
Archivos Adjuntos
Tipo de Archivo: zip djdasm_1_beta1.zip (17,8 KB (Kilobytes), 3 visitas)
Tipo de Archivo: zip Descompilar v0.02.zip (4,3 KB (Kilobytes), 8 visitas)
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.