Halte Arrays nicht im RAM

Question

Ich lerne (und versuche zu lehren) Elektronik/Programmierung mit ein paar Freunden. Wir haben uns entschieden, einen LED-Würfel mit einem Launchpad für unsere Aufgabe zu bauen.

Hier ist das Problem, das wir laufen in:

Für unsere Animationen, wir speichern sie in einer zweidimensionalen Matrix. Wir erhalten Fehler, wenn wir Array als Konstante definieren

Ich möchte nicht, dass dieses Array im RAM sein, weil wir nicht sehr viel zur Verfügung haben.

EDIT: Siehe unten für Code

Ich hoffe, dass dies an der richtigen Stelle gebucht wird.
Zu keiner Zeit (denke ich?) Ändere ich irgendein Array, sie werden alle einmal von Hand gesetzt und einfach überschliffen. Ich bin nicht sicher, was versucht zu konvertierenden

Info, wenn nötig (implizit?):

MSP430G2553 16kB Flash- 0,5 kb RAM

Danke für Ihre Hilfe

UPDATE: Nun, HansPassant hat mir gesagt, warum dieser Fehler auftaucht. Aber ich bekomme immer noch einen RAM-Überlauf (Anscheinend wird es nicht im Flash gespeichert?)

Eine andere Sache, die ich versuchte, ist anstelle von #define RON (Row ON) Ich erklärte es als const auch. (Wenn also ein Animations-Array erstellt wurde, wurde es explizit nur mit Konstanten erstellt) Ich hatte gehofft, dass es in Flash gespeichert würde. wenn

Hier ist der gesamte Code benötigt:

#define povDelay delayMicroseconds(200) // POV Delay 

const int CON = LOW; 
const int COFF = HIGH; 
const int RON = HIGH; 
const int ROFF = LOW; 

const int col[9] = {P1_0, P1_1, P1_2, P1_3, P1_4, P1_5, P2_0, P2_1, P2_2}; 
const int row[3] = {P1_6, P1_7, P2_3}; 

void setup() 
{ 
// Serial.begin(9600); 
    for (int i = 0; i < 9; i++) 
    { 
    pinMode(col[i], OUTPUT); 
    digitalWrite(col[i], COFF); 
    } 
    for (int i = 0; i < 3; i++) 
    { 
    pinMode(row[i], OUTPUT); 
    digitalWrite(row[i], ROFF); 
    } 
} 

void sideToSide(int delayTime) 
{ 
    int sideDelay = 1000; 
    // Left Frame 
    const int leftFrame[3][9] = { 
    {CON, COFF, COFF, CON, COFF, COFF, CON, COFF, COFF}, 
    {CON, COFF, COFF, CON, COFF, COFF, CON, COFF, COFF}, 
    {CON, COFF, COFF, CON, COFF, COFF, CON, COFF, COFF} 
    }; 
    // Middle Frame 
    const int middleFrame[3][9] = { 
    {COFF, CON, COFF, COFF, CON, COFF, COFF, CON, COFF}, 
    {COFF, CON, COFF, COFF, CON, COFF, COFF, CON, COFF}, 
    {COFF, CON, COFF, COFF, CON, COFF, COFF, CON, COFF} 
    }; 
    // Right Frame 
    const int rightFrame[3][9] = { 
    {COFF, COFF, CON, COFF, COFF, CON, COFF, COFF, CON}, 
    {COFF, COFF, CON, COFF, COFF, CON, COFF, COFF, CON}, 
    {COFF, COFF, CON, COFF, COFF, CON, COFF, COFF, CON} 
    }; 




    // Display this animation 3 times (Frame 1, Frame 2, Frame 3, Frame 2) 
    for (int i = 0; i < 4; i++) 
    { 
    displayFrame(leftFrame, delayTime); 
    displayFrame(middleFrame, delayTime); 
    displayFrame(rightFrame, delayTime); 
    displayFrame(middleFrame, delayTime); 
    } 
    // Last animation 
    displayFrame(leftFrame, delayTime); 



} // ############ END SIDE TO SIDE 

void frontToBack(int delayTime) 
{ 
    // Left Frame 
    const int frontFrame[3][9] = { 
    {CON, CON, CON, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {CON, CON, CON, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {CON, CON, CON, COFF, COFF, COFF, COFF, COFF, COFF} 
    }; 
    // Middle Frame 
    const int middleFrame[3][9] = { 
    {COFF, COFF, COFF, CON, CON, CON, COFF, COFF, COFF}, 
    {COFF, COFF, COFF, CON, CON, CON, COFF, COFF, COFF}, 
    {COFF, COFF, COFF, CON, CON, CON, COFF, COFF, COFF} 
    }; 
    // Right Frame 
    const int backFrame[3][9] = { 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, CON, CON}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, CON, CON}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, CON, CON} 
    }; 




    // Display this animation 3 times (Frame 1, Frame 2, Frame 3, Frame 2) 
    for (int i = 0; i < 4; i++) 
    { 
    displayFrame(frontFrame, delayTime); 
    displayFrame(middleFrame, delayTime); 
    displayFrame(backFrame, delayTime); 
    displayFrame(middleFrame, delayTime); 
    } 
    // Last animation 
    displayFrame(frontFrame, delayTime); 


} // ############# END FRONT TO BACK 


void diagFunctionOne(int delayTime) 
{ 
    const int firstFrame[3][9] = { 
    {CON, COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {CON, COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {CON, COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF} 
    }; 
    const int secondFrame[3][9] = { 
    {COFF, CON, COFF, CON, COFF, COFF, COFF, COFF, COFF}, 
    {COFF, CON, COFF, CON, COFF, COFF, COFF, COFF, COFF}, 
    {COFF, CON, COFF, CON, COFF, COFF, COFF, COFF, COFF} 
    }; 
    const int thirdFrame[3][9] = { 
    {COFF, COFF, CON, COFF, CON, COFF, CON, COFF, COFF}, 
    {COFF, COFF, CON, COFF, CON, COFF, CON, COFF, COFF}, 
    {COFF, COFF, CON, COFF, CON, COFF, CON, COFF, COFF} 
    }; 
    const int forthFrame[3][9] = { 
    {COFF, COFF, COFF, COFF, COFF, CON, COFF, CON, COFF}, 
    {COFF, COFF, COFF, COFF, COFF, CON, COFF, CON, COFF}, 
    {COFF, COFF, COFF, COFF, COFF, CON, COFF, CON, COFF} 
    }; 
    const int fifthFrame[3][9] = { 
    {COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF, CON}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF, CON}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, COFF, COFF, CON} 
    }; 
    // Start from 7 
    const int sixthFrame[3][9] = { 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, COFF, COFF}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, COFF, COFF}, 
    {COFF, COFF, COFF, COFF, COFF, COFF, CON, COFF, COFF} 
    }; 
    const int seventhFrame[3][9] = { 
    {COFF, COFF, COFF, CON, COFF, COFF, COFF, CON, COFF}, 
    {COFF, COFF, COFF, CON, COFF, COFF, COFF, CON, COFF}, 
    {COFF, COFF, COFF, CON, COFF, COFF, COFF, CON, COFF} 
    }; 
    const int eighthFrame[3][9] = { 
    {CON, COFF, COFF, COFF, CON, COFF, COFF, COFF, CON}, 
    {CON, COFF, COFF, COFF, CON, COFF, COFF, COFF, CON}, 
    {CON, COFF, COFF, COFF, CON, COFF, COFF, COFF, CON} 
    }; 
    const int ninthFrame[3][9] = { 
    {COFF, CON, COFF, COFF, COFF, CON, COFF, COFF, COFF}, 
    {COFF, CON, COFF, COFF, COFF, CON, COFF, COFF, COFF}, 
    {COFF, CON, COFF, COFF, COFF, CON, COFF, COFF, COFF} 
    }; 
    const int tenthFrame[3][9] = { 
    {COFF, COFF, CON, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {COFF, COFF, CON, COFF, COFF, COFF, COFF, COFF, COFF}, 
    {COFF, COFF, CON, COFF, COFF, COFF, COFF, COFF, COFF} 
    }; 

    for (int i = 0; i < 4; i++) 
    { 
    displayFrame(firstFrame, delayTime); 
    displayFrame(secondFrame, delayTime); 
    displayFrame(thirdFrame, delayTime); 
    displayFrame(forthFrame, delayTime); 
    displayFrame(fifthFrame, delayTime); 
    displayFrame(sixthFrame, delayTime); 
    displayFrame(seventhFrame, delayTime); 
    displayFrame(eighthFrame, delayTime); 
    displayFrame(ninthFrame, delayTime); 
    displayFrame(tenthFrame, delayTime); 
    } 
} 



/* 

##################################################### 
##################################################### 
##################################################### 
###################################################### 
####################################################### 


*/ 






// Takes a frame and displays it for the length of animation delay (in ms) 
void displayFrame(const int frame[3][9], int animationDelay) 
{ 
// Serial.println("displayFrame called"); 
unsigned long currentTime = millis(); 

while (1) // Do this continually until animationDelay is met 
{ 
int i, j; 
// Rows 
for (i = 0; i < 3; i++) 
{ 
    // Turn correct ROW on 
    digitalWrite(row[i], RON); 

    // Columns 
    for (j = 0; j < 9; j++) 
    { 
    // Turn correct COLUMNS on 
    digitalWrite(col[j], frame[i][j]); 

    } // End J loop 

    povDelay; 
    digitalWrite(row[i], ROFF); 

} // End I Loop 

if ((millis() - currentTime) >= animationDelay) 
{ 
    delay(10); 
    // Cleanup, Turn all OFF 
    for (int i = 0; i < 9; i++) 
    { 
     digitalWrite(col[i], COFF); 
    } 
    for (int i = 0; i < 3; i++) 
    { 
     digitalWrite(row[i], ROFF); 
    } 

    delay(10); // timefix? 

    return; 

} // End time test if statement 

} 


} 


void loop() 
{ 
    diag(350); 
    sideToSide(350); 
    frontToBack(350); 


// for (int i = 0; i < 9; i++) 
// { 
// digitalWrite(col[i], CON); 
// } 
// for (int i = 0; i < 3; i++) 
// { 
// digitalWrite(row[i], RON); 
// delay(250); 
// digitalWrite(row[i], ROFF); 
// } 

} 

Und die Fehler, die es gibt:

c:/users/dan/appdata/local/energi~1/hardware/tools/msp430/bin/../lib/gcc/msp430/4.6.3/../../../../msp430/bin/ld.exe: 

Region `ram‘ überschwemmt von 142 Bytes collect2: ld 1 Exit-Status zurück

Answer 1

nicht sicher, dass dies helfen wird, aber zu ld können Sie Spezifizieren Sie den zu verwendenden Speicherbereich, siehe docs.

Das auseinander, Sie verschwenden viel Platz für ein bisschen, mit einer Ganzzahl. Der einfachere Weg, um Speicher zu reduzieren: ändern const int frontFrame[3][9] zu const BYTE frontFrame[3][9], nach Erklärung von .

Sie können mehr sparen, wenn Sie Bits verwenden Bits darzustellen:

#define ON(b) (1 << b) 

const int frontFrame[3] = { 
    {ON(8) | ON(7) | ON(6)}, 
    {ON(8) | ON(7) | ON(6)}, 
    {ON(8) | ON(7) | ON(6)} 
}; 

und Sie werden ein wenig (in Displayrahmen) testen

for (int r = 0; r < ROWS_NUM; ++r) 
    for (int c = 0; c < COLS_NUM; ++c) 
    if (frame[r] & ON(c)) { ... } 

mit würde ich auch versuchen static vor hinzufügen der Datendeklaration, aber höchstwahrscheinlich hätte dies keine Auswirkung auf die Speicherplatzierung.