ASM51

Peguei uma rotina que usa originalmente uma matriz bidirecional,mas como vai ser usado num PIC lento,queria testar usando o modo unidirecional mas não consigo resultado.
segue exemplo de um trecho que fica dentro de um looping.

Código: Selecionar todos

    MAX7219_write(x+1,symbol[row1][x],chip);
    chip++;

Trecho acima retorna os valores corretos,mas o trecho abaixo retorna valores aleatório.

Código: Selecionar todos

    MAX7219_write(x+1,symbol[row1+x],chip);
    chip++;

A matriz contem 97 rows por 8.

Código: Selecionar todos

unsigned char const symbol[97][8]  = {

ou

Código: Selecionar todos

unsigned char const symbol[]  = {

É algum detalha que não percebi?

Se tu está querendo acessar a primeira linha, até dá certo.
A partir da segunda, row+x não vai funcionar. Tu pode verificar isso analiticamente.
Experimenta row*Ncols + x, sendo Ncols uma constante referente ao número de colunas, no seu caso 8.

Edit: Tem certeza de que o compilador não faz assim? Pergunto porque teria de ter muita criatividade pra bolar outro jeito de resolver algo simples de forma complicada.

eletroinf escreveu:Se tu está querendo acessar a primeira linha, até dá certo.
A partir da segunda, row+x não vai funcionar. Tu pode verificar isso analiticamente.
Experimenta row*Ncols + x, sendo Ncols uma constante referente ao número de colunas, no seu caso 8.

Edit: Tem certeza de que o compilador não faz assim? Pergunto porque teria de ter muita criatividade pra bolar outro jeito de resolver algo simples de forma complicada.

Olá.
Valeu,funcionou.
Pode me explicar o porque desta 'manobra'?
Para mim MAX7219_write(x+1,symbol[row1+x],chip); se row é 32 ,acessarias o inicio do caractere #,no proximo loop acessaria o segundo byte do mesmo caractere(33).

Código: Selecionar todos

unsigned char const symbol[]  = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // U+0020 (space)      0   (32 decimal ascii)
     0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00,   // U+0021 (!)          8
     0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // U+0022 (")          24
     0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00,   // U+0023 (#)          32
     0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00,   // U+0024 ($)          40
     0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00,   // U+0025 (%)          48
     0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00,   // U+0026 (&)          56
     0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,   // U+0027 (')          64
     0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00,   // U+0028 (()          72
     0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00,   // U+0029 ())          80
     0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00,   // U+002A (*)          88
     0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00,   // U+002B (+)          96
     0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06,   // U+002C (,)          104
     0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00,   // U+002D (-)          112
     0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00,   // U+002E (.)          120
     0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00,   // U+002F (/)          128
     0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00,   // U+0030 (0)          136
     0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00,   // U+0031 (1)          144
     0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00,   // U+0032 (2)          152
     0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00,   // U+0033 (3)          160
     0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00,   // U+0034 (4)          168
     0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00,   // U+0035 (5)          176
     0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00,   // U+0036 (6)          184
     0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00,   // U+0037 (7)          192
     0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00,   // U+0038 (8)          200
     0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00,   // U+0039 (9)          208
     0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00,   // U+003A (:)          216
     0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06,   // U+003B (;)          224
     0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00,   // U+003C (<)          232
     0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00,   // U+003D (=)          240
     0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00,   // U+003E (>)          248
     0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00,   // U+003F (?)          256
     0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00,   // U+0040 (@)          264
     0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00,   // U+0041 (A)          272
     0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00,   // U+0042 (B)          280
     0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00,   // U+0043 (C)          288
     0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00,   // U+0044 (D)          296
     0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00,   // U+0045 (E)          304
     0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00,   // U+0046 (F)          312
     0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00,   // U+0047 (G)          320
     0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00,   // U+0048 (H)          328
     0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00,   // U+0049 (I)          336
     0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00,   // U+004A (J)          344
     0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00,   // U+004B (K)          352
     0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00,   // U+004C (L)          360
     0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00,   // U+004D (M)          368
     0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00,   // U+004E (N)          376
     0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00,   // U+004F (O)          384
     0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00,   // U+0050 (P)          392
     0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00,   // U+0051 (Q)          400
     0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00,   // U+0052 (R)          408
     0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00,   // U+0053 (S)          416
     0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00,   // U+0054 (T)          424
     0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00,   // U+0055 (U)          432
     0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00,   // U+0056 (V)          440
     0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00,   // U+0057 (W)          448
     0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00,   // U+0058 (X)          456
     0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00,   // U+0059 (Y)          464
     0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00,   // U+005A (Z)          472
     0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00,   // U+005B ([)          480
     0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00,   // U+005C (\)          488
     0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00,   // U+005D (])          496
     0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00,   // U+005E (^)          504
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,   // U+005F (_)          512
     0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,   // U+0060 (`)          520
     0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00,   // U+0061 (a)          528
     0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00,   // U+0062 (b)          536
     0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00,   // U+0063 (c)          544
     0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00,   // U+0064 (d)          552
     0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00,   // U+0065 (e)          560
     0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00,   // U+0066 (f)          568
     0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F,   // U+0067 (g)          576
     0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00,   // U+0068 (h)          584
     0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00,   // U+0069 (i)          592
     0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E,   // U+006A (j)          600
     0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00,   // U+006B (k)          608
     0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00,   // U+006C (l)          616
     0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00,   // U+006D (m)          624
     0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00,   // U+006E (n)          632
     0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00,   // U+006F (o)          640
     0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F,   // U+0070 (p)          648
     0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78,   // U+0071 (q)          656
     0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00,   // U+0072 (r)          664
     0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00,   // U+0073 (s)          672
     0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00,   // U+0074 (t)          680
     0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00,   // U+0075 (u)          688
     0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00,   // U+0076 (v)          696
     0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00,   // U+0077 (w)          704
     0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00,   // U+0078 (x)          712
     0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F,   // U+0079 (y)          720
     0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00,   // U+007A (z)          728
     0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00,   // U+007B ({)          736
     0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00,   // U+007C (|)          744
     0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00,   // U+007D (})          752
     0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // U+007E (~)          760
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00    // U+007F              768
};


sabe me informar se usando a matriz deste jeito seria mais rápido que utilizando ela em modo bidimensional?

Quais são os tipos de variáveis que tu está usando?
Pois não faz sentido não funcionar uma parte, a não ser que esteja usando char, pois as letras ficam acima da posição 255 nessa sua tabela, o que demanda um endereçamento com variável de 16 bit.

Ja resolvi isso,mas sobre as questões acima?

se row é 32 ,acessarias o inicio do caractere #,no proximo loop acessaria o segundo byte do mesmo caractere(33).

Exatamente. Da mesma forma que acontece quando tu usa o método bidimensional, m[32][0] é o primeiro byte do "#", m[32][1] é o segundo byte, e assim por diante.

Procede o que andei lendo que na maiorias das vezes a matriz unidimensional é mais rápida?

Eu diria que a resposta é... depende

Se for acesso dinâmico, sim, a tendência é que a unidimensional seja mais rápida.
Por exemplo, dentro de dois loops for(;;) usando as variáveis de controle do loop como índices de acesso da matriz, vai exigir que o processador calcule o índice dinamicamente.
Agora se for acesso estático, ou seja, que o compilador trate os índices na compilação, tenderia a ficar tudo igual em termos de velocidade.
Tem a questão de "quanto mais rápido", que depende dos recursos do seu uC.
Em suma, penso que só valeria a pena se preocupar com isso se tu estiver no limite do limite do limite da capacidade de processamento para a sua aplicação.
Com tanto uC de alto poder de processamento acessível, isso fica cada vez mais exótico.

Em suma, penso que só valeria a pena se preocupar com isso se tu estiver no limite do limite do limite da capacidade de processamento para a sua aplicação.

Esse é o caso.
Como se trata de um 'acessório' do microcontrolador principal,a exigência é um de menor custo/tamanho possível.
Foi escolhido o 16f628a que tem bastante no estoque.

Chegando tarde no debate, mas muito tempo atrás tive um problema aparentemente parecido com o caso acima com um PIC16F, algo que funcionava de um modo que matematicamente era similar ao outro, mas no meu caso ( usando o compilador CCS, várias versões atrás, por volta de 2006 ) acontece que talvez devido a uma limitação do PIC, com matrizes unidimensionais de tamanho acima de 256 bytes não funcionava, mesmo tendo declarado coo const; no seu caso é 768 bytes (=8x96); a solução foi menos elegante que a sua, dividi o acesso com if's. Na minha opinião, os PICs dessa família por terem uma pilha minúscula isso acaba dificultando a vida do compilador, mas é apenas um palpite.

VTX, "dependendo da estrutura", uma matriz bidimensional pode corresponder a conjuntos de dados (listas).

Neste caso, para não sobrecarregar seu sistema, você poderia tratar cada lista de forma individual.

Assim: usa o parâmetro (índice) para selecionar e direcionar a pesquisa para a lista de momento.

Desta forma transforma a matriz bidimensional em unidimensional.

Prolongando o debate, eu fiquei buscando na memória aqui de quando programava f628, que foi mais em ASM...
Tinha um limite da quantidade de memória que poderia ser acessada diretamente (Flash, não ram), mas acho que era 2 k, de forma que nesse modelo de PIC não causava problema.
Era uma limitação do Program Counter.
Enfim, nessa situação sua o próximo passo para enxugar mais é ir para o assembly

eletroinf escreveu:Prolongando o debate, eu fiquei buscando na memória aqui de quando programava f628, que foi mais em ASM...
Tinha um limite da quantidade de memória que poderia ser acessada diretamente (Flash, não ram), mas acho que era 2 k, de forma que nesse modelo de PIC não causava problema.
Era uma limitação do Program Counter.
Enfim, nessa situação sua o próximo passo para enxugar mais é ir para o assembly

Pois é,ja faz um tempo que programava ele em ASM,mas para não perder tempo,adaptei o código que tinha escrito para STM32 para o PIC.Até que ficou bom mas ocupava mais espaço que o 'normal' para este PIC.
De qualquer forma é divertido fazer o PIC 'trabalhar de verdade' junto com a pessoa que está atrás dele.

To aqui apanhando denovo.
Quero testar o código gerado para PIC/AVR num STM usando Keil,e um erro ja aparece...
src\main.c(525): error: #142: expression must have pointer-to-object type
Rotina:

Código: Selecionar todos

void MAX7219_displayText(char* text)
{
     u8 chip = 0;
     u8 x,y;
    
  for(x=0;x<8;x++)
  {
     for(y=0;y<16;y++)
     {
       MAX7219_write(8-x,caracter[*(text+y) - 32][x],chip);
       chip++;
     }
     chip = 0;
  }        
}

Tabela:

Código: Selecionar todos

unsigned u8 const caracter[97][8]={
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, etc

erro:

Código: Selecionar todos

...
                 MAX7219_write(8-x,caracter[*(text+y) - 32][x],chip);
...

Presumo que esteja faltando indicar o endereço com '&':

Código: Selecionar todos

MAX7219_write(8-x,caracter[*(&text+y) - 32][x],chip);

Também pode ser que tenha de multiplicar o y por algo tipo sizeof(text) ou algo parecido.