Holding Diziler RAM

Question

I öğrenme (ve öğretmeye çalışıyorum) birkaç arkadaşı ile elektronik/programlama am değil. Görevimiz için bir lansmanı kullanarak bir LED küp oluşturmaya karar verdik.

Burada girmek mesele var: Bizim animasyonlar için

, bir iki boyutlu bir dizi saklayabilirsiniz. Diziyi

olarak tanımladığımız hatayı alırsak, bu dizinin RAM'de olmasını istemiyorum çünkü çok fazla kullanılabilir durumda değiliz.

DÜZENLEME: kod

Bu doğru yerde yayınlanmıştır umut

için aşağıya bakınız. zaman değil (sanırım?) At
herhangi dizi değişiyorum, hepsi elle bir kez ayarlanır ve biraz üzerinde dolanır. (? Örtük) Ben olmaya çalışıyorum ne emin değilim gerekirse

Bilgisi dönüştürülen:

MSP430G2553 16kb Flaş 0.5kB RAM

Yardımlarınız için teşekkürler

GÜNCELLEME: İyi HansPassant bana bu hatanın neden ortaya çıktığını söyledi. Ama hala bir RAM taşması alıyorum (Anlaşılan o anda flaşta saklanmıyor mu?)

Denediğim başka bir şey de #define RON (Satır AÇIK) yerine const olarak da bildirdim. (böylece bir animasyon dizisi oluşturulduğunda, sadece sabitlerle açık bir şekilde oluşturuldu) bunu flaşta saklamayı ummuştum.

#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); 
// } 

} 

Ve var olan hata: ld returned 1 exit status: collect2 142 bayt tarafından taştı `ram'

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

bölgeyi İşte

gerekirse kod bütünlük

Answer 1

bu yardımcı olacaktır, ancak size olabilir ld emin değildi Kullanılacak bellek alanını belirtin, bkz. docs. Bunun dışında

, bir tamsayı kullanarak, biraz fazla yer harcıyorsun. typedef unsigned char BYTE ilanından sonra, const BYTE frontFrame[3][9] değişikliği const int frontFrame[3][9]: Daha kolay bir yol bellek azaltmak için. Ben de önünde static eklemek için çalışacaktı

#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)} 
}; 

ve

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

kullanarak (displayFrame olarak) biraz test edecek:

Eğer bit temsil etmek bitleri kullanırsanız daha ayırabilirim veri bildirimi, ancak muhtemelen bu bellek yerleştirme üzerinde herhangi bir etkisi olmaz.