Le tableau C affiche des données parasites (problèmes de mémoire?)

Question

Je crée un pilote pour une matrice LED 8x8 que je conduis depuis le port parallèle d'un ordinateur. C'est censé être une horloge, inspirée par un design que j'ai vu sur Tokyoflash.

Une partie du pilote est un tableau de 3 * 5 "sprites" numériques qui sont dessinés sur la matrice. Une coordonnée de la matrice est assignée à une coordonnée du sprite et ainsi de suite, jusqu'à ce que le sprite entier soit dessiné dessus. Ce processus est répété pour l'autre chiffre avec un décalage. J'ai vérifié que j'ai dessiné les sprites correctement, et que la matrice est vide quand elle est écrite. Cependant, quand je dessine un nombre sur la matrice, je reçois 1s au Numpad6 pour le chiffre gauche, Numpad1 pour le droit (Example with the left digit not drawn.)

J'ai une semaine d'expérience en C et cela me déconcerte.

Voici le pilote en entier si vous voulez le compiler vous-même. Il est loin d'être fini.

//8x8 LED MATRIX DRIVER VER 0.1 APR062009 
//CLOCK 
// 
//
// 0 BXXXXXXH B: Binary Mode Indicator 
// 1 DXXXXXXM D: Decimal Mode Indicator 
// 2 NNNNNNNN H: Hour Centric Display 
// 3 LLLNNRRR M: Minute Centric Display 
// 4 LNLNNRNR X: Secondary Information 
// 5 LLLNNRRR L: Left Digit 
// 6 LNLNNRNR R: Right digit 
// 7 LLLNNRRR N: Not Used 

#include <stdio.h> 
#include <unistd.h> 
//#include <math.h> 
#include <time.h> 
#include </usr/include/sys/io.h> 

#define BASEPORT 0x378 

int main() 
{ 
//Increasing array parameters to seems to reduce glitching [best 10 5 3] 
int Dig[10][5][3] = {0}; //ALPHANUMERIC ARRAY [NUMBER (0..9)][Y(0..4)][X(0..2)] 
int Mat[7][7] = {0};  //[ROW][COL], Top L corner = [0][0] 
int Aux1[7] = {0};  //Topmost Row 
int Aux2[7] = {0};   //Second to Topmost Row 
int Clk; //Clock 
int Wait; //Delay; meant to eventually replace clock in its current state 
int C1;  //Counters 
int C2; 
int C3; 
int L;  //Left Digit 
int R;  //Right Digit 
//break string left undefined atm 

//ioperm (BASEPORT, 3, 1); 
//outb(0, BASEPORT); 
printf("Now running.\n"); 

//Set Variables 

//3D DIGIT ARRAY [Num][Row][Col] (INITIALIZED BY INSTRUCTIONS) 
    //Dig array is meant to be read only once initialized 
    //3D arrays are unintuitive to declare so the numbers are 
    //"drawn" instead. 

//Horizontals 
    //Some entries in the loop may have the variable in the middle 
    //coordinate instead of the 3rd and/or with a +2. This is to 
    //incorporate the incomplete columns some numbers have (eg "2") and 
    //saves coding additional loops. 

for(C1=0; C1<=2; C1++){ 
Dig[0][0][C1]=1; Dig[0][4][C1]=1; 
Dig[2][0][C1]=1; Dig[2][2][C1]=1; Dig[2][4][C1]=1; Dig[2][C1][2]=1; Dig[2][C1+2][0]=1; 
Dig[3][0][C1]=1; Dig[3][2][C1]=1; Dig[3][4][C1]=1; 
Dig[4][2][C1]=1; Dig[4][C1][0]=1; 
Dig[5][0][C1]=1; Dig[5][2][C1]=1; Dig[5][4][C1]=1; Dig[5][C1][0]=1; Dig[5][C1+2][2]=1; 
Dig[6][0][C1]=1; Dig[6][2][C1]=1; Dig[6][4][C1]=1; Dig[6][C1+2][2]=1; 
Dig[7][0][C1]=1; 
Dig[8][0][C1]=1; Dig[8][2][C1]=1; Dig[8][4][C1]=1; 
Dig[9][0][C1]=1; Dig[9][2][C1]=1; Dig[9][4][C1]=1; Dig[9][C1][0]=1; 
} 

//Verticals 

for(C1=0; C1<=4; C1++){ 
Dig[0][C1][0]=1; Dig[0][C1][2]=1; 
Dig[1][C1][2]=1; 
Dig[3][C1][2]=1; 
Dig[4][C1][2]=1; 
Dig[6][C1][0]=1; 
Dig[7][C1][2]=1; 
Dig[8][C1][0]=1; Dig[8][C1][2]=1; 
Dig[9][C1][2]=1; 
    } 

Clk=10000; 

L=2; //Think about incorporating overflow protection for L,R 
R=4; 

//Print Left Digit to Matrix @ (3, 0) 

for(C1=0; C1<=4; C1++){    //For some reason produces column of 1s at numpad 6 
    for(C2=0; C2<=2; C2++){  
    Mat[C1+3][C2]=Dig[L][C1][C2]; 
    printf("%d", Dig[L][C1][C2]);  //Debug 
    } 
printf(" %d %d %d\n", L, C1, C2); //Debug 
} 

//Print Right Digit to Matrix @ (3, 5) 

for(C1=0; C1<=4; C1++){    //For some reason produces column of 1s at numpad 1 
    for(C2=0; C2<=2; C2++){ 
    Mat[C1+3][C2+5]=Dig[R][C1][C2]; 
    } 
} 

//X Test Pattern 

//for(C1=0; C1<=7; C1++){ 
// Mat[C1][C1]=5;  
// Mat[7-C1][C1]=5; 
//} 

usleep(Clk); 

    //while(1){ 

//Breakfree [NOT FUNCTIONAL] 

//Break_String=getch(); (Getch is not ANSI, need ncurses) 

//if(Break_String != -1){ 
// if(Break_String = 27){ 
// break; 
// } 
//}  

//Terminal Display 

//for(C3=0; C3<=9; C3++){   //Debug Digit array [Successful, numbers draw correctly] 
// for(C2=0; C2<=4; C2++){ 
//  for(C1=0; C1<=2; C1++){ 
//   printf("%d", Dig[C3][C2][C1]); 
//  } 
// printf("\n"); 
// } 
//printf("\n"); 
//usleep(1000000); //Debug 
//} 

usleep(3000000); //Debug 

for(C1=0; C1<=7; C1++){    //Prints to terminal every second, when looping 
    for(C2=0; C2<=7; C2++){ 
    printf("%d", Mat[C1][C2]); 
    } 
printf("\n"); 
} 

printf("\n"); 

//Hardware Display 

for(C1=0; C1<=29; C1++){    //30 Hz 
    for(C3=0; C3<=7; C3++){    //COLUMN 
     //printf("%d %d \n", C3, C1);  //Loop Debug 
     usleep(1000); 
     //CLOCK GROUND TO GO HERE, OUT STATUS 
     //for(C2=0; C2<=7; C2++){  //PX 
      //outb(Mat[C3][C2], BASEPORT); 
     //} 
    } 
usleep(4*Clk); 
} 

//} 

//ioperm(BASEPORT, 3, 0); 
exit(0); 
} 

De plus, j'ai dû faire en sorte que mes limites de tableau Sprite soient plus grandes qu'elles ne devraient l'être pour le faire fonctionner. Je me dis que tout cela est de la mémoire, mais je ne suis pas du tout proche de C qui sait quoi faire.

J'apprécierais grandement toute aide.

Answer 1

J'ai besoin de regarder à travers cela plus mais un problème du début est que vous conduisez une matrice de LED 8x8 mais en utilisant une matrice 7x7 pour contenir les données. Déclarez votre matrice comme:

int Mat[8][8]; 

Answer 2

Bryan, je ne vois pas le problème désinvolture, mais ce que vous décrivez semble que vous rencontrez un problème d'indexation de tableau. (Règle générale, chaque fois que vous pensez que quelque chose ne va pas avec l'ordinateur causant vos erreurs, vous vous trompez.)

Deux nouveaux programmeurs C rencontrent des problèmes avec ceci est confus par 0 indices basés - un tableau de taille 7 a des indices de 0..6 - et en ne réalisant pas que les tableaux sont juste disposés au-dessus d'une goutte de mémoire, donc un tableau qui est [10] [5] [2] est vraiment juste un ... morceau de mémoire cellulaire. Si vous faites une erreur d'indexation, vous pouvez mettre les choses dans ce qui semble être des endroits aléatoires.

Je passerais en revue le code et vérifierais ce qui est par étapes plus petites; ce qui se passe après une initialisation, ce genre de chose.

Answer 3

Bryan, je pense que vous manque seulement la compréhension fondamentale de la façon dont les indices de tableaux fonctionnent en C.

Lorsque vous déclarez

int array[N] 

vous accédez aux éléments dans une gamme de

array[0] ... array[N-1] 

qui vous donne un total de N éléments.

Par exemple:

int array[4] 

vous donne

array[0] 
array[1] 
array[2] 
array[3] 

pour un total de 4 éléments.

Lorsque boucle sur ce tableau, c'est la convention qui est presque toujours utilisé:

for(i = 0; i < 4; i++) 

Je pense que cette question est à l'origine de multiples problèmes dans votre code et si vous revenez sur vos tableaux après avoir compris ce que vous Je serai capable de résoudre les problèmes.