Mensajes

Buenas:

Voy hacerles una pregunta. Sobre el código de arriba quiero hacer algo parecido del PIC16F88 al PIC16F630 para saber si realmente funciona. Hablo de adaptación del código y usando un decodificador 74LS48.

Transformar este esquema...


Con este otro.

Habiendo el primer circuito con menos componentes. ¿Por qué usar el segundo esquema también?

Porque otras personas que quieren montar el circuito no pueden debido a que su local de electrónica favorita no tienen el PIC16F88 y si el PIC16F630 junto con el decodificador de 7 segmentos 74LS48.

Partiendo del código de abajo del PIC16F88 para analizarlo bien.

Código [Seleccionar] Expandir


; Un pulsador en RA4 va incrementando un Contador, entre [1-4].
; La salida se envía a un display de 7 seg. en PORTB, y hacia salidas en PORTA.
; El Contador queda guardado en la EEPROM.
;
; (Contador)  |RB 76543210 |RA 76543210
; ------------|------------------------
;       1     |   00000011 |   00000010
;       2     |   00100100 |   00000101
;       3     |   00001100 |   00000110
;       4     |   00111100 |   00001001
;
; PORTA:
;  RA0 : OE1
;  RA1 : OE2
;  RA2 : A21
;  RA3 : AUX
;  RA4 : Pulsador
;
; PORTB : display de 7 segmentos. a = RB0
;

;*******************************************************************************
; Listado y condiciones de ensamblado

    LIST    P=16F88           ; 4 Mhz
    INCLUDE <P16F88.INC>
    ;radix       hex
    ERRORLEVEL  -302            ; Turn off banking message

;*******************************************************************************
; Fusibles

    __CONFIG _CONFIG1, _CP_OFF & _DEBUG_OFF & _WRT_PROTECT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _MCLR_ON & _PWRTE_ON & _WDT_OFF & _INTRC_IO

; _CP_OFF           : Protección de código
; _DEBUG_OFF        : Debug en circuito
; _WRT_PROTECT_OFF  : Protección a escritura en memoria de programa
; _CPD_OFF          : Protección de código de datos
; _LVP_OFF          : Programación en baja tensión
; _BODEN_OFF        : Reset por Brown-out
; _MCLRE_ON         : Reset por pin externo
; _PWRTE_ON         : Retraso al reset
; _WDT_OFF          : Watchdog
; _XT_OSC           : Oscilador externo del tipo XT


;*******************************************************************************
; Definiciones

; Máscaras de E/S de los puertos. 0 = salida, 1 = entrada
;                    |76543210|
#DEFINE PUERTO_A    b'00010000'
#DEFINE PUERTO_B    b'00000000'

; Incorporar sentencias de comprobación de la EEPROM
#DEFINE test_eeprom 0

;*******************************************************************************
; Variables
Variables   UDATA_SHR
Contador    RES 1                   ; Contador en la SRAM

; ******************************************************************************
; EEPROM

; Dirección del Contador dentro de la EEPROM
EE_Contador EQU 0x02

; Debemos desplazarnos a la zona de memoria más allá del 0x2100, que corresponde
; a la zona de la EEPROM en la mayoría de los PIC (ver documentación).
; Este valor es el que se grabará en la EEPROM en el momento de grabar el programa
; en el µcontrolador.
    ORG     0x2100 + EE_Contador
    DE      0x01                               ; valor inicial de ee_Contador

;*******************************************************************************

    CODE    0x0000

Inicio
    banksel ANSEL           ; bank 1
    clrf    ANSEL           ; puerto A digital
    movlw   PUERTO_A        ; definir E/S puerto A
    movwf   TRISA
    movlw   PUERTO_B        ; definir E/S puerto B
    movwf   TRISB
    movlw   b'01100000'     ; 4 MHz
    movwf   OSCCON
    call    EEPROM_LeeDato


#if test_eeprom
; Comprobar que el Contador es correcto (esta parte es opcional)
    decf    Contador, w     ; leemos el Contador y le quitamos 1
    andlw   0x3             ; nos quedamos solo con los bits inferiores
    addlw   0x1             ; volvemos a sumarle 1
    movwf   Contador        ; y lo guardamos
#endif
    goto    Visualiza       ; ir a presentar

; Bucle principal
Principal
    btfsc   PORTA, RA4      ; leer pulsador
    goto    Principal       ; No, esperar
;
; Se ha pulsado el botón
    call    incrementa_Contador
Visualiza
    call    visualiza_Contador
    call    salida_hacia_A

; Esperar liberación del botón
Espera_levantar
    call    Retardo_100ms   ; Esperar la suelta del botón

    btfss   PORTA, RA4      ; leer pulsador
    goto    Espera_levantar ; No, esperar

; Repetir
    goto    Principal


; ******************************************************************************
;; salida_hacia_A
;
; Según el valor del Contador ([1-4]), lo transforma en otro, basado en una
; tabla y lo saca por el puerto A
;

salida_hacia_A
    call    transforma_Contador
    movwf   PORTA           ; visualiza en puerto A
    return

transforma_Contador
    decf    Contador, w     ; leemos el Contador y le restamos 1
    addwf   PCL, f          ; saltamos dentro de la tabla

    ;                            |76543210|
    retlw   b'00000010'
    retlw   b'00000101'
    retlw   b'00000110'
    retlw   b'00001001'

; ******************************************************************************
;; incrementa_Contador
;
; Incrementa el valor de la variable Contador, entre 1 y 4, inclusives.
;

incrementa_Contador
    bcf     Contador, 2     ; Si el Contador valía 4, ahora vale 0
    incf    Contador, f     ; Incrementa el Contador
    call    EEPROM_EscribeDato

; ******************************************************************************
;; visualiza_Contador
;
; Muestra el valor del Contador en el display de 7 segmentos
;

visualiza_Contador
    movfw   Contador        ; leemos Contador
    call    w_a_digito      ; transformación a dígito 7 segmentos
    movwf   PORTB           ; visualiza en puerto B
    return

w_a_digito
    addwf   PCL, f          ; salta al dígito indexado por w

;            |76543210|
    retlw   b'00111111'     ; 0
    retlw   b'00000110'     ; 1
    retlw   b'01011011'     ; 2
    retlw   b'01001111'     ; 3
    retlw   b'01100110'     ; 4
    retlw   b'01101101'     ; 5
    retlw   b'01111101'     ; 6
    retlw   b'00000111'     ; 7
    retlw   b'01111111'     ; 8
    retlw   b'01101111'     ; 9

; ----------------------------------------------------------------------------------------------------

Retardo_var        udata_shr

Retardo_100ms_d1    res 1
Retardo_100ms_d2    res 1

Retardo_code       code

Retardo_100ms
;99993 cycles
movlw 0x1E
movwf Retardo_100ms_d1
movlw 0x4F
movwf Retardo_100ms_d2
Retardo_100ms_0
decfsz Retardo_100ms_d1, f
goto $+2
decfsz Retardo_100ms_d2, f
goto Retardo_100ms_0

;3 cycles
goto $+1
nop

;4 cycles (including call)
return

; ******************************************************************************

; Leer valor del Contador en la EEPROM
EEPROM_LeeDato
    banksel EEADR           ; bank 2
    movlw   EE_Contador     ; dirección de la EEPROM a leer
    movwf   EEADR

    banksel EECON1          ; bank 3
    bcf     EECON1, EEPGD   ; acceso a la memoria de datos
    bsf     EECON1, RD      ; inicia la lectura

    banksel EEDATA          ; bank 2
    movf    EEDATA, w       ; dato leído en W
    movwf   Contador        ; guardar en SRAM
    ;
    banksel PORTA           ; bank 0, durante el programa
    return

; Escribe el Contador en la EEPROM
EEPROM_EscribeDato
    banksel EECON1          ; bank 3
    btfsc   EECON1, WR      ; esperar para poder escribir
    goto    $-1

    banksel EEADR           ; bank 2
    movlw   EE_Contador     ; dirección donde vamos a escribir
    movwf   EEADR

    movf    Contador, w     ; el valor que vamos a escribir
    movwf   EEDATA

    banksel EECON1          ; bank 3
    bcf     EECON1, EEPGD   ; acceso a la memoria de datos
    bsf     EECON1, WREN    ; activa la escritura

    ;                    bcf     INTCON, GIE     ; desactivar interrupciones

    movlw   b'01010101'     ; valores mágicos (requeridos)
    movwf   EECON2
    movlw   b'10101010'
    movwf   EECON2

    bsf     EECON1, WR      ; comienza la escritura

    ;                    bsf     INTCON, GIE     ; reactiva interrupciones

    bcf     EECON1, WREN    ; desactiva escrituras

    banksel PORTA           ; volvemos a bank 0
    return
    END


Antes de tocar algo.

¿Debo saber algo más?

Un saludo.

PD: Espero que no sea mucho de machacarte las neuronas por una adapación en asm.

Hola:

Quiero saber cual es la Web oficial o original de Willem. Simpre he creido que es este.

http://www.sivava.com/
http://www.mpu51.com/eprom/eprom.html

Según veo por Internet, veo Willem muy modernos hasta los componentes que la Web de arriba parece viejo. Otras personas dicen que hay otra Web. No se que pensar. Antes de hacer compras de Willem, prefiero preguntar.

Saludo.

Hola:

Por si acaso.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Rict
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        string Texto = "Hola";
        string Texto2 = "¿Qué tal?";

        private void button1_Click(object sender, EventArgs e)
        {
            richTextBox1.AppendText(Texto + "\r\n");
        }

        private void button_Que_tal_Click(object sender, EventArgs e)
        {
            richTextBox1.AppendText(Texto2 + "\r\n");
        }
    }
}


Un saludo.

Hola de nuevo queridísimos amigos:

Espero que sigan vivos a estas altura de la vida.

Tengo instalado el Virtual Box con openSUSE 13.1 y el último Ubuntu. ¿Con qué compilador y lenguaje es recomendable usar para hacer lo mismo bajo Linux?

Me imagino que será capaz de hacerlo.

aaaaaaaaaaaah. La revisión de códigos sin problemas ninguno como los códigos de arriba, aquí uso el Visual C# 2013 y funciona de maravilla.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.Runtime.InteropServices; // No olvidar.

namespace Lector_IDE
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        [DllImport("winmm.dll")]
        public static extern Int32 mciSendString(string lpstrCommand,
            StringBuilder lpstrReturnString, int uReturnLength, IntPtr hwndCallback);
        //Why did i put this here?
        StringBuilder rt = new StringBuilder(127);

        private void button_Abrir_Click(object sender, EventArgs e)
        {
            mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
            label_Mensaje.Text = "Abierto";
        }

        private void button_Cerrar_Click(object sender, EventArgs e)
        {
            mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
            label_Mensaje.Text = "Cerrado";
        }
    }
}


Saludo.

Buenas:

Los ejemplos que he hecho es cortar una cadena de unas variables en C#, no en archivo. Lo que he hecho era modificar binarios, ahora me toca cortarlos.

Código (csharp) [Seleccionar] Expandir


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.IO; // No olvidar este using.

namespace Archivo_Binario
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.Title = "Moficicar cabeceras";


      while (true)
      {
        Console.WriteLine(@"Seleccione C, c, M, m, R, r, L, l, S o s.
C o c = Limpiar pantalla.
M o m = Modificar.
R o r = Recuperar.
L o l = Leer.
S o s = Salir.
");
        string str = Console.ReadLine();

        switch (str)
        {
            case "C": // Limpiar pantalla.
            case "c":
                Console.Clear();
                break;

            case "M": // Modificar.
            case "m":
                Modificar();
                break;

            case "R": // Recuperar.
            case "r":
                Recuperar();
                break;

            case "L": // Leer.
            case "l":
                Leer();
                break;

            case "S": // Salir.
            case "s":
                // Espera por una tecla para terminar la aplicación.
                Environment.Exit(0);
                break;

            default:
            Console.WriteLine("Selección inválida. Por favor, selecciona M, m, R, r, S o l.");
            break;
        }

        if (str.ToUpper() == "S")
        {
          break;
        }

        //Console.ReadLine();
      }
    }

    private static void Modificar()
    {
      try
      {
        FileStream fs = new FileStream(@"C:\Archivo.zip", FileMode.Open, FileAccess.ReadWrite);
        BinaryReader br = new BinaryReader(fs);
        BinaryWriter bw = new BinaryWriter(fs);

        //if ((br.ReadByte() == 'P') && (br.ReadByte() == 'K'))
        //{
          fs.Position = 0;
          bw.Write((byte)0x4D);
          bw.Write((byte)0x53);

          fs.Position = 0x25;
          bw.Write((byte)0xA9); // ©.
          bw.Write((byte)0x4D); // M.
          bw.Write((byte)0x53); // S.

          fs.Position = 0xC53A40;
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
          bw.Write((byte)0x00);
        //}

        //
        br.Close();
        bw.Close();
        Console.WriteLine("Se ha modificado correctamente.");
      }
      catch
      {
        Console.WriteLine("Error. No encuentra el archivo.");
      }
    }

    private static void Recuperar()
    {
      try
      {
        FileStream fs = new FileStream(@"C:\Archivo.zip", FileMode.Open, FileAccess.ReadWrite);
        BinaryReader br = new BinaryReader(fs);
        BinaryWriter bw = new BinaryWriter(fs);

        //if ((br.ReadByte() == 'M') && (br.ReadByte() == 'S'))
        //{
          fs.Position = 0;
          bw.Write((byte)'P');
          bw.Write((byte)'K');

          fs.Position = 0x25;
          bw.Write((byte)0x2F); // /.
          bw.Write((byte)0x50); // P.
          bw.Write((byte)0x4B); // K.
        //}
          fs.Position = 0xC53A40;
          bw.Write((byte)0xBF);
          bw.Write((byte)0xCE);
          bw.Write((byte)0x01);
          bw.Write((byte)0xA0);
          bw.Write((byte)0x9F);
          bw.Write((byte)0x17);
          bw.Write((byte)0xDB);
          bw.Write((byte)0x5D);
          bw.Write((byte)0xBF);
          bw.Write((byte)0xCE);
          bw.Write((byte)0x01);
          bw.Write((byte)0x50);
          bw.Write((byte)0x4B);
          bw.Write((byte)0x05);
          bw.Write((byte)0x06);
          bw.Write((byte)0x00);
        //
        br.Close();
        bw.Close();
        Console.WriteLine("Se ha recuperado correctamente.");
      }
      catch
      {
        Console.WriteLine("Error. No encuentra el archivo.");
      }
    }

    private static void Leer()
    {
        FileStream fs = new FileStream(@"C:\Archivo.zip", FileMode.Open);
        BinaryReader br = new BinaryReader(fs);

        string Valores = null;
        for (int i = 0x181760; i <= 0x181795; i++)
        {
            br.BaseStream.Position = i;
            Valores += br.ReadByte().ToString("X2");
        }

        Console.WriteLine(Valores);
        Valores = null;

        string misBytes = @"57 69 6E 6E 74 6E 74 2F 56 79 4B 67 7A 2E 6A 70 67 0A 00 20 00 00 00 00 00 01 00 18 00 00 A0 19 28 04 1F CC 01 0A 07 17 DB 5D BF CE 01 0A 07 17 DB 5D BF CE 01 50 4B 01 02 1F 00 14 00 00 00 08 00 7D 47 A2 3E 94 19 72 D9 31 B9 01 00 4E B9 01 00 19 00 24 00 00 00 00 00 00 00 20 00 00 00 1E FD C0 00 57 69 6E 6E 74 6E 74 2F 57 69 6E 6E 74 6E 74 2F 57 65 4B 48 33 2E 6A 70 67 0A 00 20 00 00 00 00 00 01 00 18 00 00 93 22 EE 9E 08 CC 01 55 53 17 DB 5D BF CE 01 55 53 17 DB 5D BF CE 01 50 4B 01 02 1F 00 14 00 00 00 08 00 2C 4D A3 3E F7 60 2F 06 EA 74 02 00 16 75 02 00 19 00 24 00 00 00 00 00 00 00 20 00 00 00 86 B6 C2 00 57 69 6E 6E 74 6E 74 2F 57 69 6E 6E 74 6E 74 2F 58 49 30 67 50 2E 6A 70 67 0A 00 20 00 00 00 00 00 01 00 18 00 00 D2 51 E2 6D 09 CC 01 A0 9F 17 DB 5D BF CE 01 A0 9F 17 DB 5D BF CE 01 50 4B 05 06 00 00 00 00 22 00 22 00 A4 0E 00 00 A7 2B C5 00 00";

        string[] listaDeBytes = misBytes.Split(' ');
        foreach (string hex in listaDeBytes)
        {
            //Aquí la variable hex vale, por ejemplo "6E".
            //Conviértela a binario y usa el resultado en bw.Write(...)
           
                misBytes = Convert.ToString(Convert.ToInt32(hex, 16), 2);
                Console.WriteLine(hex);
        }
            br.Close();
    }
  }
}



Gracias por la ayuda. Aunque no tenga nada que ver este código, irá relacionado con cortar.

basicamente lo que tienes que hacer es leer el archivo en modo binario, crear un archivo binario vacío, leer del original y guardar la sección que te interese...


aqui un ejemplo en ingles http://socketprogramming.blogspot.com/2008/11/split-and-assemble-large-file-around.html

y la informacion de lectura/escritura en msdn http://msdn.microsoft.com/es-es/library/aa711083(v=vs.71).aspx

Gracias, voy a analizaro.

Hola:

Uso Visual Express 2013. Tengo un archivo binario llamado Archivo.dat que pesa 2 MB. Quiero hacer un programa que sea capaz de partirlo en 2 partes a 1 MB cada uno o lo que yo quiera como hacer Winrar. Después unirlo. El proceso es el siguiente.

    Cargar tu aplicación un archivo llamado Archivo.dat que es binario, puede ser cualquiera, como un archivo.jpg.
    Al cargar el Archivo.dat detecta cuantos MB son, por ejemplo 2 MB.
    Opción para elegir cuantos KB a partir, en este caso, la mitad.
    Se renombra los archivos llamado Archivo_01.bin y Archivo_02.bin de 1 MB cada uno.
    Fin de programa.

¿Cómo se hace?

Espero que no sea muy complicado hacer estas cosas.

Saludo.

Buenas:



La GameCube no gira el disco ni se ve el laser para que lo lea, a veces, se ve la imagen de arriba. He intentado calibra el lector siguiento este enlace y nada de nada.

No da nada señales de vida la parte del lector, nada de nada, si l apila, el ventilador. Lo de desarmado hasta las entrañas haber si veo algún conector suelto y nada de nada. También puedo acceder a la Memory cArd qu elo lee bien. Como dije antes, a veces se cuelga o se ve el mensaje rojo de arriba.

De entrada está más que muerta. Quiero saber lo que le pasa y si es posible repararla. Me iba a compra otra, pero prefiero la Wii normal ya que es capaz de leer juegos de GC.

La GC está totalmente libre de piratería.

¿Alguna chispa de luz?

Un cordial saludo.

Hola:

Ahora me funciona todo.

Código (asm) [Seleccionar] Expandir

;
; Un pulsador en RA4 va incrementando un Contador, entre [1-4].
; La salida se envía a un display de 7 seg. en PORTB, y hacia salidas en PORTA.
; El Contador queda guardado en la EEPROM.
;
; (Contador)  |RB 76543210 |RA 76543210
; ------------|------------------------
;       1     |   00000011 |   00000010
;       2     |   00100100 |   00000101
;       3     |   00001100 |   00000110
;       4     |   00111100 |   00001001
;
; PORTA:
;  RA0 : OE1
;  RA1 : OE2
;  RA2 : A21
;  RA3 : AUX
;  RA4 : Pulsador
;
; PORTB : display de 7 segmentos. a = RB0
;

;*******************************************************************************
; Listado y condiciones de ensamblado

    LIST    P=16F88           ; 4 Mhz
    INCLUDE <P16F88.INC>
    ;radix       hex
    ERRORLEVEL  -302            ; Turn off banking message

;*******************************************************************************
; Fusibles

    __CONFIG _CONFIG1, _CP_OFF & _DEBUG_OFF & _WRT_PROTECT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _MCLR_ON & _PWRTE_ON & _WDT_OFF & _INTRC_IO

; _CP_OFF           : Protección de código
; _DEBUG_OFF        : Debug en circuito
; _WRT_PROTECT_OFF  : Protección a escritura en memoria de programa
; _CPD_OFF          : Protección de código de datos
; _LVP_OFF          : Programación en baja tensión
; _BODEN_OFF        : Reset por Brown-out
; _MCLRE_ON         : Reset por pin externo
; _PWRTE_ON         : Retraso al reset
; _WDT_OFF          : Watchdog
; _XT_OSC           : Oscilador externo del tipo XT


;*******************************************************************************
; Definiciones

; Máscaras de E/S de los puertos. 0 = salida, 1 = entrada
;                    |76543210|
#DEFINE PUERTO_A    b'00010000'
#DEFINE PUERTO_B    b'00000000'

; Incorporar sentencias de comprobación de la EEPROM
#DEFINE test_eeprom 0

;*******************************************************************************
; Variables
Variables   UDATA_SHR
Contador    RES 1                   ; Contador en la SRAM

; ******************************************************************************
; EEPROM

; Dirección del Contador dentro de la EEPROM
EE_Contador EQU 0x02

; Debemos desplazarnos a la zona de memoria más allá del 0x2100, que corresponde
; a la zona de la EEPROM en la mayoría de los PIC (ver documentación).
; Este valor es el que se grabará en la EEPROM en el momento de grabar el programa
; en el µcontrolador.
    ORG     0x2100 + EE_Contador
    DE      0x01                               ; valor inicial de ee_Contador

;*******************************************************************************

    ORG    0x0000

Inicio
    banksel ANSEL           ; bank 1
    clrf    ANSEL           ; puerto A digital
    movlw   PUERTO_A        ; definir E/S puerto A
    movwf   TRISA
    movlw   PUERTO_B        ; definir E/S puerto B
    movwf   TRISB
    movlw   b'01100000'     ; 4 MHz
    movwf   OSCCON
    call    EEPROM_LeeDato


#if test_eeprom
; Comprobar que el Contador es correcto (esta parte es opcional)
    decf    Contador, w     ; leemos el Contador y le quitamos 1
    andlw   0x3             ; nos quedamos solo con los bits inferiores
    addlw   0x1             ; volvemos a sumarle 1
    movwf   Contador        ; y lo guardamos
#endif
    goto    Visualiza       ; ir a presentar

; Bucle principal
Principal
    btfsc   PORTA, RA4      ; leer pulsador
    goto    Principal       ; No, esperar
;
; Se ha pulsado el botón
    call    incrementa_Contador
Visualiza
    call    visualiza_Contador
    call    salida_hacia_A

; Esperar liberación del botón
Espera_levantar
    call    Retardo_100ms   ; Esperar la suelta del botón

    btfss   PORTA, RA4      ; leer pulsador
    goto    Espera_levantar ; No, esperar

; Repetir
    goto    Principal


; ******************************************************************************
;; salida_hacia_A
;
; Según el valor del Contador ([1-4]), lo transforma en otro, basado en una
; tabla y lo saca por el puerto A
;

salida_hacia_A
    call    transforma_Contador
    movwf   PORTA           ; visualiza en puerto A
    return

transforma_Contador
    decf    Contador, w     ; leemos el Contador y le restamos 1
    addwf   PCL, f          ; saltamos dentro de la tabla

    ;                            |76543210|
    retlw   b'00000010'
    retlw   b'00000101'
    retlw   b'00000110'
    retlw   b'00001001'

; ******************************************************************************
;; incrementa_Contador
;
; Incrementa el valor de la variable Contador, entre 1 y 4, inclusives.
;

incrementa_Contador
    bcf     Contador, 2     ; Si el Contador valía 4, ahora vale 0
    incf    Contador, f     ; Incrementa el Contador
    call    EEPROM_EscribeDato

; ******************************************************************************
;; visualiza_Contador
;
; Muestra el valor del Contador en el display de 7 segmentos
;

visualiza_Contador
    movfw   Contador        ; leemos Contador
    call    w_a_digito      ; transformación a dígito 7 segmentos
    movwf   PORTB           ; visualiza en puerto B
    return

w_a_digito         addwf   PCL, f          ; salta al dígito indexado por w

;            |76543210|
    retlw   b'00111111'     ; 0
    retlw   b'00000110'     ; 1
    retlw   b'01011011'     ; 2
    retlw   b'01001111'     ; 3
    retlw   b'01100110'     ; 4
    retlw   b'01101101'     ; 5
    retlw   b'01111101'     ; 6
    retlw   b'00000111'     ; 7
    retlw   b'01111111'     ; 8
    retlw   b'01101111'     ; 9

; ----------------------------------------------------------------------------------------------------
; Espera = 100ms
; Frecuencia de reloj = 4Mhz
;
; Espera real = 0.1 segundos = 100000 ciclos
; Error = 0.00 %

Retardo_var        udata_shr

Retardo_100ms_d1    res 1
Retardo_100ms_d2    res 1

Retardo_code       code

Retardo_100ms
;99993 cycles
movlw 0x1E
movwf Retardo_100ms_d1
movlw 0x4F
movwf Retardo_100ms_d2
Retardo_100ms_0
decfsz Retardo_100ms_d1, f
goto $+2
decfsz Retardo_100ms_d2, f
goto Retardo_100ms_0

;3 cycles
goto $+1
nop

;4 cycles (including call)
return

; ******************************************************************************

; Leer valor del Contador en la EEPROM
EEPROM_LeeDato
    banksel EEADR           ; bank 2
    movlw   EE_Contador     ; dirección de la EEPROM a leer
    movwf   EEADR

    banksel EECON1          ; bank 3
    bcf     EECON1, EEPGD   ; acceso a la memoria de datos
    bsf     EECON1, RD      ; inicia la lectura

    banksel EEDATA          ; bank 2
    movf    EEDATA, w       ; dato leído en W
    movwf   Contador        ; guardar en SRAM
    ;
    banksel PORTA           ; bank 0, durante el programa
    return

; Escribe el Contador en la EEPROM
EEPROM_EscribeDato
    banksel EECON1          ; bank 3
    btfsc   EECON1, WR      ; esperar para poder escribir
    goto    $-1

    banksel EEADR           ; bank 2
    movlw   EE_Contador     ; dirección donde vamos a escribir
    movwf   EEADR

    movf    Contador, w     ; el valor que vamos a escribir
    movwf   EEDATA

    banksel EECON1          ; bank 3
    bcf     EECON1, EEPGD   ; acceso a la memoria de datos
    bsf     EECON1, WREN    ; activa la escritura

    ;                    bcf     INTCON, GIE     ; desactivar interrupciones

    movlw   b'01010101'     ; valores mágicos (requeridos)
    movwf   EECON2
    movlw   b'10101010'
    movwf   EECON2

    bsf     EECON1, WR      ; comienza la escritura

    ;                    bsf     INTCON, GIE     ; reactiva interrupciones

    bcf     EECON1, WREN    ; desactiva escrituras

    banksel PORTA           ; volvemos a bank 0
    return
                    END




Gracias por tu tiempo. 

Hola:

Pensé que guardando el valor contador, es suficiente con solo un byte recordar las dos tablas donde van. Voy a examinarlo mejor tu código.

Le has puesto dos variables. ADDR y VALUE para guardar.

Saludo.