Cómo crear un puntero para codificar la memoria en el microchip C30

Se supone que los dígitos [] son constantes y contienen punteros a punteros constantes, ¿verdad? Quizás la precedencia de * aquí podría ser un problema y tal vez

const BYTE * Digits[] = {DIGIT1,DIGIT2,DIGI3,DIGIT4,DIGIT5,DIGIT6};

debería ser

const BYTE (*Digits)[] const = {DIGIT1,DIGIT2,DIGI3,DIGIT4,DIGIT5,DIGIT6};

enlace

También sugiero agregar ese segundo "const". No creo que ese sea el problema, pero si hay un error que intenta cambiar los dígitos, podría ayudarlo a encontrarlo. (Por cierto, podría ser útil intentar diferenciar más los nombres de las variables; la palabra "dígito" se usa de muchas formas y sería fácil para alguien [especialmente para un extraño como yo] confundir uno con otro.)

Por cierto, creo que hiciste un error tipográfico aquí (¿no debería ser ++ no **?)

digit**;//incrememt pointer

La forma en que normalmente escribo una interfaz de pantalla de 7 segmentos es algo como esto:

// Human-readable bit values
#define BIT0 0x01
#define BIT1 0x02
#define BIT2 0x04
#define BIT3 0x08
#define BIT4 0x10
#define BIT5 0x20
#define BIT6 0x40
#define BIT7 0x80

// Number of available positions on display
#define NUM_DIGITS 4

// Map symbols to segments
#define SYMBOL_0 (BIT0 | BIT1 | BIT2)
#define SYMBOL_1 (BIT0 | BIT5)
// (these are just examples -- not real mappings) 

// function prototypes
void display_number(int number);    // calls display_digit once per digit
void display_digit(unsigned char symbol, unsigned char position);    // writes symbol to one of the 7-segment positions
void display_refresh();    // Scans through each digit and illuminates segments again

const unsigned char digit_map[] = { SYMBOL_0, SYMBOL_1, ...}
unsigned char digits_being_displayed[NUM_DIGITS];


// (in main)
int x = 1234;
display_number(x);
// ...
// (in polling/timer loop)
display_refresh();


// (in display_number)
// Note: need to handle signs, convert number, etc. this is just for illustration
// ...
for (int pos=0; pos < NUM_DIGITS; pos++) {
    int i, temp = number;
    // get corresponding digit (depending on how you number your digits, this could be different)
    for (i=1; i<(pos+1); i++)
        temp /= 10;
    temp %= 10;
    switch (temp) {
        case 0:
            digit = SYMBOL_0;
            break;
        case 1:
            digit = SYMBOL_1;
            break;
        // ...
    }

    display_digit(digit_map[digit], pos); 
}

// ...

// (in display_digit)
digits_being_displayed[position] = value;  // this value can get written periodically to the display with display_refresh()

Por lo tanto, no estoy muy familiarizado con la sintaxis / estructuras que está utilizando (por ejemplo, BYTE = {}) pero espero que mis comentarios sigan siendo útiles. Si te gusta la enumeración mejor que #define eso también está bien, por supuesto.

  

Luego observo que en la ventana de vigilancia la dirección de DIGIT1 en   la memoria de código es 0x48A, mientras que la de DIGIT2 es 0x491.

     

Pero al verificar su dirección en la matriz DIGITS, veo los valores   0X848A y 0x8491 para DIGIT1 y DIGIT2 respectivamente.

Esto es normal. El PIC no es un espacio de memoria plano, por lo que necesita alguna forma de marcar el hecho de que la dirección 0x12 en la memoria de códigos no es lo mismo que la dirección 0x12 en SRAM, por ejemplo. El compilador usa bits extra altos para denotar esto.