const 배열의 부분을 활성화

Question

나는 각 약 50 elemets와 4 개의 const char[][] 배열을 가지고 있으며, 각 요소는 또 다른 40 개의 값을 포함하며, 그래픽 LCD로 전송되어 특정 문자, 숫자, 기호를 그려야합니다.

이제 문제는 매우 제한된 리소스로 임베디드 시스템에서 작업하고 있다는 것입니다. 네 개의 배열 모두가 전에 작업했던 프로젝트에서 유용했지만, 대부분의 캐릭터를 필요로하는 곳에서는 이제 겨우 5 ~ 10 개만 필요합니다.

필자가 필요로하지 않는 charaters 배열에서 삭제하고 삭제할 수 있지만 RAM/FLASH에 기록되지 않도록 해당 문자를 사용하지 않는 것이 더 좋은 방법이되기를 바라고 있습니다.

#ifdef 및 #endif을 사용하려고 생각했습니다. 그러나 각 요소에 대해 이렇게하면 코드가 엉망이됩니다.

다른 방법이 있습니까?

미리 감사드립니다.

편집 :

는 바로 지금, 내가 좋아하는 더 큰 부품 #ifdef 및 #endif이 있습니다

#define ARRAY1_BIG_LETTERS 
#define ARRAY1_SMALL_LETTERS 
#define ARRAY1_NUMBERS 
#define ARRAY1_OTHER 

#define ARRAY2_BIG_LETTERS 
#define ARRAY2_SMALL_LETTERS 
#define ARRAY2_NUMBERS 
#define ARRAY2_OTHER 

... 

하지만, 난 여전히 콘텐츠를 더 잘 설정 제어가 필요합니다.

EDIT2 :

이가 (작은) 배열 중 하나가 :

const char writting_8x8[][9] = { 
    #ifdef ARRAY1_OTHER 
    {32, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0},      /* */ 
    {45, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0},      /* - */ 
    {46, 0 , 0 , 96 , 96 , 0 , 0 , 0 , 0},      /* . */ 
    {58, 0 , 0 , 108 , 108 , 0 , 0 , 0 , 0},     /* : */ 
    {61, 0 , 36 , 36 , 36 , 36 , 36 , 0 , 0},     /* = */ 
    #endif 
    #ifdef ARRAY1_NUMBERS 
    {48, 0 , 62 , 81 , 73 , 69 , 62 , 0 , 0},     /* 0 */ 
    {49, 0 , 0 , 66 , 127 , 64 , 0 , 0 , 0},     /* 1 */ 
    {50, 0 , 98 , 81 , 73 , 73 , 70 , 0 , 0},     /* 2 */ 
    {51, 0 , 34 , 73 , 73 , 73 , 54 , 0 , 0},     /* 3 */ 
    {52, 0 , 24 , 20 , 18 , 127 , 16 , 0 , 0},     /* 4 */ 
    {53, 0 , 47 , 73 , 73 , 73 , 49 , 0 , 0},     /* 5 */ 
    {54, 0 , 60 , 74 , 73 , 73 , 48 , 0 , 0},     /* 6 */ 
    {55, 0 , 1 , 113 , 9 , 5 , 3 , 0 , 0},      /* 7 */ 
    {56, 0 , 54 , 73 , 73 , 73 , 54 , 0 , 0},     /* 8 */ 
    {57, 0 , 6 , 73 , 73 , 41 , 30 , 0 , 0},     /* 9 */ 
    #endif 
    #ifdef ARRAY1_BIG_LETTERS 
    {65, 0 , 126 , 17 , 17 , 17 , 126 , 0 , 0},     /* A */ 
    {66, 0 , 127 , 73 , 73 , 73 , 54 , 0 , 0},     /* B */ 
    {67, 0 , 62 , 65 , 65 , 65 , 34 , 0 , 0},     /* C */ 
    {68, 0 , 127 , 65 , 65 , 65 , 62 , 0 , 0},     /* D */ 
    {69, 0 , 127 , 73 , 73 , 73 , 65 , 0 , 0},     /* E */ 
    {70, 0 , 127 , 9 , 9 , 9 , 1 , 0 , 0},      /* F */ 
    {71, 0 , 62 , 65 , 73 , 73 , 122 , 0 , 0},     /* G */ 
    {72, 0 , 127 , 8 , 8 , 8 , 127 , 0 , 0},     /* H */ 
    {73, 0 , 0 , 65 , 127 , 65 , 0 , 0 , 0},     /* I */ 
    {74, 0 , 48 , 64 , 64 , 64 , 63 , 0 , 0},     /* J */ 
    {75, 0 , 127 , 8 , 20 , 34 , 65 , 0 , 0},     /* K */ 
    {76, 0 , 127 , 64 , 64 , 64 , 64 , 0 , 0},     /* L */ 
    {77, 0 , 127 , 2 , 4 , 2 , 127 , 0 , 0},     /* M */ 
    {78, 0 , 127 , 2 , 4 , 8 , 127 , 0 , 0},     /* N */ 
    {79, 0 , 62 , 65 , 65 , 65 , 62 , 0 , 0},     /* O */ 
    {80, 0 , 127 , 9 , 9 , 9 , 6 , 0 , 0},      /* P */ 
    {81, 0 , 62 , 65 , 81 , 33 , 94 , 0 , 0},     /* Q */ 
    {82, 0 , 127 , 9 , 9 , 25 , 102 , 0 , 0},     /* R */ 
    {83, 0 , 38 , 73 , 73 , 73 , 50 , 0 , 0},     /* S */ 
    {84, 0 , 1 , 1 , 127 , 1 , 1 , 0 , 0},      /* T */ 
    {85, 0 , 63 , 64 , 64 , 64 , 63 , 0 , 0},     /* U */ 
    {86, 0 , 31 , 32 , 64 , 32 , 31 , 0 , 0},     /* V */ 
    {87, 0 , 63 , 64 , 60 , 64 , 63 , 0 , 0},     /* W */ 
    {88, 0 , 99 , 20 , 8 , 20 , 99 , 0 , 0},     /* X */ 
    {89, 0 , 7 , 8 , 112 , 8 , 7 , 0 , 0},      /* Y */ 
    {90, 0 , 113 , 73 , 69 , 67 , 0 , 0 , 0},     /* Z */ 
    {200, 0 , 56 , 69 , 70 , 69 , 40 , 0 , 0},     /* Č */ 
    #endif 
    #ifdef ARRAY1_SMALL_LETTERS 
    {97, 0 , 32 , 84 , 84 , 84 , 120 , 0 , 0},     /* a */ 
    {98, 0 , 127 , 68 , 68 , 68 , 56 , 0 , 0},     /* b */ 
    {99, 0 , 56 , 68 , 68 , 68 , 40 , 0 , 0},     /* c */ 
    {100, 0 , 56 , 68 , 68 , 68 , 127 , 0 , 0},     /* d */ 
    {101, 0 , 56 , 84 , 84 , 84 , 8 , 0 , 0},     /* e */ 
    {102, 0 , 8 , 126 , 9 , 9 , 0 , 0 , 0},      /* f */ 
    {103, 0 , 24 , 164 , 164 , 164 , 124 , 0 , 0},    /* g */ 
    {104, 0 , 127 , 4 , 4 , 120 , 0 , 0 , 0},     /* h */ 
    {105, 0 , 0 , 0 , 125 , 64 , 0 , 0 , 0},     /* i */ 
    {106, 0 , 64 , 128 , 132 , 125 , 0 , 0 , 0},    /* j */ 
    {107, 0 , 127 , 16 , 40 , 68 , 0 , 0 , 0},     /* k */ 
    {108, 0 , 0 , 0 , 127 , 64 , 0 , 0 , 0},     /* l */ 
    {109, 0 , 124 , 4 , 24 , 4 , 120 , 0 , 0},     /* m */ 
    {110, 0 , 124 , 4 , 4 , 120 , 0 , 0 , 0},     /* n */ 
    {111, 0 , 56 , 68 , 68 , 68 , 56 , 0 , 0},     /* o */ 
    {112, 0 , 252 , 68 , 68 , 68 , 56 , 0 , 0},     /* p */ 
    {113, 0 , 56 , 68 , 68 , 68 , 252 , 0 , 0},     /* q */ 
    {114, 0 , 68 , 120 , 68 , 4 , 8 , 0 , 0},     /* r */ 
    {115, 0 , 8 , 84 , 84 , 84 , 32 , 0 , 0},     /* s */ 
    {116, 0 , 4 , 62 , 68 , 36 , 0 , 0 , 0},     /* t */ 
    {117, 0 , 60 , 64 , 32 , 124 , 0 , 0 , 0},     /* u */ 
    {118, 0 , 28 , 32 , 64 , 32 , 28 , 0 , 0},     /* v */ 
    {119, 0 , 60 , 96 , 48 , 96 , 60 , 0 , 0},     /* w */ 
    {120, 0 , 108 , 16 , 16 , 108 , 0 , 0 , 0},     /* x */ 
    {121, 0 , 156 , 160 , 96 , 60 , 0 , 0 , 0},     /* y */ 
    {122, 0 , 100 , 84 , 84 , 76 , 0 , 0 , 0},     /* z */ 
    {154, 0 , 8 , 85 , 86 , 85 , 32 , 0 , 0},     /* š */ 
    {158, 0 , 100 , 85 , 86 , 77 , 0 , 0 , 0},     /* ž */ 
    {232, 0 , 56 , 69 , 70 , 69 , 40 , 0 , 0}     /* č */ 
    #endif 
}; 

내가 값의 내가 사용하기 위하여려고하고있는 선행 선택합니다. 그래서 이것은 어떻게 든 preproccessors와 함께 할 필요가있을 것입니다 ...

Answer 1

처음에는 구조체 목록을 만드는 것이 좋습니다. 또한 디스플레이가 8x8이지만 6x8 만 사용합니다 (경계선은 항상 0입니다). 첫 번째 문자를 단순히 char로 바꾸면 "실제로 어떤 문자입니까?"라는 메모를 작성할 필요가 없습니다. 테이블에 "터미네이터"(또는 정지 시퀀스)를 추가하는 트릭도 있습니다. 그렇다면 배열 크기를 알 필요가 없습니다 (올바른 문자를 찾기 위해 배열을 반복하고 있다고 가정합니다). SO : 같은

typedef struct _dsp_letter { 
    const char ascii; 
    const char pixels[6]; 
} dsp_letter_t; 

const dsp_letter_t writing[] = { 
    #ifdef ARRAY1_OTHER 
    {' ', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'-', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'.', { 0 , 96 , 96 , 0 , 0 , 0 } }, 
    {':', { 0 , 108 , 108 , 0 , 0 , 0 } }, 
    {'=', { 36 , 36 , 36 , 36 , 36 , 0 } }, 
    #endif 
    // ... 
    { 0 } 
} 

그리고 사용 외모 :

int i = 0; 
while (writing[i].ascii != 0) { 
    // do stuff, add if or anything 
    ++i; 
} 

그 변화는 표시 기능의 변화를 필요로하지만, 그 저장 메모리가 가치가있을 수 있습니다.

그건 한 부분입니다. 자, 그 차이점은 입니다. const char str [] = "Str"; 및 const char * pStr = "Str"; ?

크기!

const char str[] = "My long C-style string"; 
const char *pStr = "My long C-style string"; 

printf("str: %d vs pStr: %d", sizeof(str), sizeof(pStr)); 
// str: 23 vs pStr: 8 

CONST 숯불 STR []는는 스택에 할당되고, 실행 시간 동안 데이터가 기록 될 때 실제로 배열이다.

const를 숯불 * pStr는 힙에 할당되고, 데이터에 런타임 만 포인터가 기록되며, 데이터는 응용 프로그램의 전역 메모리입니다.

그 의미는 무엇입니까? onst char writting_8x8 [] [9] = {...};은 엄청난 양의 메모리를 할당하고 있습니다. 임베디드 장치에서 이것은 ... 음, 나는 그것을 권장하지 않는다고 말할 수 있습니다.

어떻게해야합니까? 큰 배열을 모두 작은 배열로 나눌 수 있습니다. 이제

typedef struct _dsp_letter { 
    const char ascii; 
    const char pixels[6]; 
} dsp_letter_t; 

#ifdef ADD_OTHER 
const dsp_letter_t other[] = { 
    {' ', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'-', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'.', { 0 , 96 , 96 , 0 , 0 , 0 } }, 
    {':', { 0 , 108 , 108 , 0 , 0 , 0 } }, 
    {'=', { 36 , 36 , 36 , 36 , 36 , 0 } }, 
    { 0 } 
}; 
#endif ADD_OTHER 

#ifdef ADD_SMALL 
const dsp_letter_t small[] = { 
    {'a', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'b', { 0 , 0 , 0 , 0 , 0 , 0 } }, 
    {'c', { 0 , 96 , 96 , 0 , 0 , 0 } }, 
    {'d', { 0 , 108 , 108 , 0 , 0 , 0 } }, 
    { 0 } 
}; 
#endif ADD_SMALL 

당신이 (당신의 같은 전)

컴파일시 컴파일 시간 또는 실행 시간에 한 장소에서 그들 모두를 얻을 수 있습니다 :

const dsp_letter_t *writting[] = { 
#ifdef ADD_OTHER 
    other, 
#endif 
#ifdef ADD_SMALL 
    small, 
#endif 
    0 
}; 

또는 런타임 :

#define ADD_OTHER 1 
#define ADD_SMALL 0 

int size = ADD_OTHER + ADD_SMALL; 
int i = 0; 
dsp_letter_t **writting = (dsp_letter_t *writting(malloc)(size* sizeof (dsp_letter_t *writting)); 

#ifdef ADD_OTHER 
writting[i++] = other; 
#endif 

#ifdef ADD_SMALL 
writting[i++] = small; 
#endif 

당신은 그와 함께 작업 할 수 있습니다 :

불행히도 나는 퍼팅하지 않고 더 잘 할 수있는 방법을 모르겠다. #ifdef ... endif 모든 장소에 oveer :/