MikroBasic code omzetten naar MikroC code

[huub8]

Ik heb een lcd scherm met touchscreen gekocht op ebay, maar er is geen standaard library voor de mikroc compiler die de driver van dit scherm ondersteund. Iemand heeft wel een eigen driver geschreven, maar in mikrobasic:

http://www.mikroe.com/forum/viewtopic.php?f=160&t=46901

Ik ben echter niet echt bekend met mikrobasic en weet van een aantal zaken niet hoe ik ze om kan zetten in mikroc:

- het word data type, is dit gelijk aan een int in mikroc? dus kan ik dit: const Black as word = 0x0000,
vervangen door: int black = 0x0000; ?

- is dim TFT_DP_Lo as byte sfr external, hetzelfde als: extern sfr sbit TFT_DP_Lo;

- wat betekend de ^ in: Dat is de pointer notatie zie ik net

code:

sub procedure TFT_Image(dim pos_x,pos_y,dim_x,dim_y as word,dim const picture as ^byte)
dim k,i,x,y,temp as word
  TFT_CS  = 0
  x =pos_x
  y =pos_y

  temp = picture^
  picture = picture +1
  temp = (temp << 8)
  temp = temp + picture^
  picture = picture +1

  TFT_Set_Address(pos_x,pos_y,dim_x,dim_y)

  for k = 0 to dim_y - 1
   for i = 0 to dim_x - 1

    TFT_Set_Address(x,y,x,y)
    Write_Data(temp)
    temp = picture^
    picture = picture +1
    temp = (temp << 8)
    temp = temp + picture^
    picture = picture +1
    inc(x)
   next i
    x = 0
    inc(y)
  next k
  TFT_CS  = 1
end sub

[Reptile209]

Pak er eens een reference voor MicroBasic bij:
- Op p. 21 staat uitgelegd wat pointers zijn ( ^ )
- Op p. 17 staan de datatypes, waarvoor je dan het C-equivalent kunt opzoeken
- enz...

[huub8]

Daar heb ik het in opgezocht (daar heb ik de alternatieven vandaan), maar maar ik wilde weten of ik inderdaad word door int kon vervangen, het tweede punt kon ik ook niet echt bevestigen.

Bestaat er verder een variant voor mikroc op de @ van basic, die het volgende doet:
The @ operator returns the adress of a variable or routine; that is, @ constructs a pointer to its operand.

Ik kon hier namelijk niet zoiets vinden, of is dit gelijk aan de *?

Edit: ja, dit is de &

[ Voor 63% gewijzigd door huub8 op 17-06-2012 19:07 ]

[huub8]

Door een boel uit te proberen heb ik nu bijna alles werkend, op het weergeven van plaatjes na. Ik heb een .bmp afbeelding in photoshop gemaakt, opgeslagen als 16bit r5 g6 b5 bmp formaat, en deze geladen in winhex. Volgens de websites met informatie hierover die ik kon vinden heb ik voor de char array van het plaatje enkel de hex codes na offset 46 tot het eind nodig. Echter is dat een langere array dan verwacht (ik verwachte een x * y * 2 lengte array).

Hoe komt dit/wat doe ik fout?

De afbeelding ziet er nu als een willekeurige verzameling pixels uit op het scherm, de code van de driver (niet door mij geschreven, enkel omgezet in C):

code:

void TFT_Image(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,const char *picture)
{
unsigned int k,i,x,y,temp;
  TFT_CS  = 0;
  x =pos_x;
  y =pos_y;

  temp = *picture;
  picture = picture +1;
  temp = (temp << 8);
  temp = temp + *picture;
  picture = picture +1;

  TFT_Set_Address(pos_x,pos_y,dim_x,dim_y);

  for(k = 0; k <= dim_y - 1; k++)
  {
   for(i = 0; i <= dim_x - 1; i++)
    {
      TFT_Set_Address(x,y,x,y);
      Write_Data(temp);
      temp = *picture;
      picture = picture +1;
      temp = (temp << 8);
      temp = temp + *picture;
      picture = picture +1;
      x++;
     }
    x = 0;
    y++;
  }
  TFT_CS = 1;
}

[Infant]

Die code ziet er onnodig lomp uit.

Wat doet Write_Data precies? Alsin, wat verwacht hij als argument? BMP's kun je volgens mij op meerdere manieren encoden.

Maar als hij in R5 G6 B5 moet, dan krijg ik in ieder geval netjes een 512 bytes lange unit, die inderdaad op ofset 0x46 begint, en vervolgens dus 512 bytes aan 16-bit data bevat.

Wel interessant is dat hij bij mij alles omgekeerd opslaat.... ALLES! Het pixeltje rechts onder, verschijnt op positie 0x46 en 0x47, en is Big Endian opgeslagen. Jouw code lijkt er op het als Little Endian te interpreteren.

0,0,255 = blauw = 0x1F00
0,0,128 = donker blauw = 0x1000

Ik denk dat de code wat netter maken, het probleem zou kunnen oplossen. Je mixt nu ints en bytes van onbepaalde grootte (wat is de architectuur?) en die haal je door een gehaktmolen en dan poef.

Over TFT_Set_Address(x,y,x,y) heb ik ook wel wat twijfels. Zou dat niet iets met i en k moeten zijn?

C: TFTImage.c

#include <stdint.h>
void TFT_Image(uint16_t pos_x,uint16_t pos_y,uint16_t dim_x,
        uint16_t dim_y,uint16_t *picture){
        
    uint16_t k,i,x,y,temp;
    TFT_CS  = 0;
    x = pos_x;
    y = pos_y;
    
    TFT_Set_Address(pos_x,pos_y,dim_x,dim_y);
    for(k = 0; k < dim_y; k++){
        for(i = 0; i < dim_x; i++){
            temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);           
            x++;
        }
        x = 0;
        y++;
    }
    TFT_CS = 1;
}

Helpt dit?

[huub8]

Volgens mij doe ik ook wat fout bij het maken van de character array, dus voordat ik jou code uit kan proberen moet ik dit goed krijgen. Ik heb nu een bestand gemaakt van 1 bij 1 pixel (zwarte pixel). Deze opgeslagen met photoshop als bmp, 5 6 5, winhex geeft dan dit als geheel:

code:

unsigned AnsiChar data[76] = {
    0x42, 0x4D, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x38, 0x00, 
    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x03, 0x00, 
    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x1F, 0x00, 
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00
};

Welk deel moet ik hiervan dan hebben?

Dit is de write data functie:

code:

void Write_Data(unsigned int Wdata)
{
  TFT_RD = 1;
  TFT_RS = 1 ;
  TFT_DP_Hi = Wdata >>8 ;
  TFT_DP_Lo = wdata;
  TFT_WR = 0;
  TFT_WR = 1 ;
}

en de set adress functie

code:

void TFT_Set_Address(unsigned int PX1,unsigned int PY1,unsigned int PX2,unsigned int PY2)
{
  Write_Command_Data(68,(PX2 << 8) + PX1 );  //Column address start2
  Write_Command_Data(69,PY1);      //Column address start1
  Write_Command_Data(70,Py2);  //Column address end2
  Write_Command_Data(78,PX1);      //Column address end1
  Write_Command_Data(79,PY1);  //Row address start2
  Write_Command(34);
}

Edit:
Ik heb jou code uitgeprobeerd met deze array:

code:

unsigned int picture[] =
{
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};

Met als aanroep:
TFT_Image(0,0,5,30,*picture);

Dit gaf een rechthoek die voor het grootste deel zwart was, maar bovenin zaten wat grijze pixels. Ik verwachte een helemaal zwarte rechthoek. De code die ik gaf voor het tonen van een afbeelding gaf overigens een schijnbaar willekeurig gekleurde verzameling pixels.

Edit 2: een array van alleen maar 0x00 geeft bij jouw functie ook een zwart beeld, waarin allen bovenin wat anders gekleurde pixels zitten.

[ Voor 42% gewijzigd door huub8 op 18-06-2012 17:22 ]

[Infant]

Okee,

In de datascheet staat:

"R44h Specify the start/end positions of the window address in the horizontal direction by an address unit."

0xEF zou ook 239 zijn, en daar kun je 240 pixels mee adresseren.

En R45 en 46 zijn voor de verticale pixels, die tot 0x13F mogen... wat 319 is.

Ik denk dat je dus iets wilt zeggen in de trand van:

Lijn 1/240.
Pixel 1 tm pixel 1.
En dan data.

Wij zeggen nu (PX2 <<8) + PX1. Als je dus TFT_Image(0,0,5,30,*picture); zegt wordt dat:

(5<<8) + 0 = 1280.... which makes no sense at all.

Er gebeurt kennelijk wel iets.

[huub8]

Ik snap zelf ook de bitmap array nog niet, ik dacht dat je 2 bytes per pixel nodig had, dus dat de totale array hoogte * breedte * 2 groot moest zijn. Echter heb ik met behulp van visual tft (een programma van mikroe) een array van een bitmap gemaakt die er als volgt uitziet :

code:

const code char abc[665] = {
0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x01, 0x00, 0x60, 
0x00, 0x60, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x08, 0x06, 0x06, 0x07, 0x06, 0x05, 0x08, 
0x07, 0x07, 0x07, 0x09, 0x09, 0x08, 0x0A, 0x0C, 0x14, 0x0D, 0x0C, 0x0B, 0x0B, 0x0C, 0x19, 0x12, 
0x13, 0x0F, 0x14, 0x1D, 0x1A, 0x1F, 0x1E, 0x1D, 0x1A, 0x1C, 0x1C, 0x20, 0x24, 0x2E, 0x27, 0x20, 
0x22, 0x2C, 0x23, 0x1C, 0x1C, 0x28, 0x37, 0x29, 0x2C, 0x30, 0x31, 0x34, 0x34, 0x34, 0x1F, 0x27, 
0x39, 0x3D, 0x38, 0x32, 0x3C, 0x2E, 0x33, 0x34, 0x32, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x09, 0x09, 
0x09, 0x0C, 0x0B, 0x0C, 0x18, 0x0D, 0x0D, 0x18, 0x32, 0x21, 0x1C, 0x21, 0x32, 0x32, 0x32, 0x32, 
0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 
0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 
0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0xFF, 0xC0, 
0x00, 0x11, 0x08, 0x00, 0x25, 0x00, 0x22, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 
0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 
0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 
0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 
0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 
0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 
0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 
0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 
0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 
0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 
0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 
0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 
0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00, 0x03, 
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 
0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 
0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 
0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 
0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 
0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 
0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 
0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 
0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 
0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 
0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 
0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 
0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00, 0xA5, 
0x45, 0x14, 0x57, 0xE8, 0x07, 0x8E, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 
0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 
0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x7F, 0xFF, 0xD9
};

Deze is dus 665 bytes groot, maar hij moet een afbeelding van 34 bij 37 voorstellen, ik zou dus verwachten dat hij 2516 groot is.

[Infant]

Zullen we anders beginnen met uitvinden hoe dat ding werkt? Dan komen we stap voor stap waar we willen zijn:

Ik neem aan dat je wilt zeggen teken een plaatje van (Hoogte x Breedte) op plek(X,Y). Correct?

Dus laten we eest een punt tekenen op plek x,y.
Vervolgens een kleur geven. En dan.... een plaatje.

Dus, als je alleen maar in plaats van TFT_Image aanroepen, doet:

C:

TFT_Set_Address(32,32,32,32);
Write_Data(0xFFFF); //(of 0x0000) als je een zwart pixeltje wilt.

Dan verwacht ik een wit, of zwart pixeltje op plek 32,32. Wat doet ie?

Een 16-bits R5G6R5 plaatje van 34 x 37 verwacht je inderdaad dat dat 2516bytes is. Dus daar doe je ook iets fout.

[huub8]

Je vergeet dan denk ik nog twee regels, maar zou werkt hij inderdaad:

code:

TFT_CS  = 0;
TFT_Set_Address(32,32,32,32);
Write_Data(0xFFFF); //(of 0x0000) als je een zwart pixeltje wilt.
TFT_CS  = 1;

Hij geeft netjes een zwarte of witte pixel

[ Voor 9% gewijzigd door huub8 op 19-06-2012 16:22 ]

[Infant]

Heel mooi.

En als je dus overal 230 inplaats van 32 van maakt, doet ie ut ook?

[huub8]

Dan doet hij het ook

[Infant]

Dan zou ik zeggen dat in eerste instantie je plaatje functie reduceert tot:

C:

#include <stdint.h>
void TFT_Image(uint16_t pos_x,uint16_t pos_y,uint16_t dim_x,
        uint16_t dim_y,uint16_t *picture){
        
    uint16_t x;
    uint16_t y;
    uint16_t temp;
    
    TFT_CS  = 0;
    
    for(y = pos_y; y < (pos_y+dim_y); y++){
        for(x = pos_x ; x < (pos_x+dim_x); x++){
            temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);           
        }
    }
    TFT_CS = 1;
}

Doet dat wat?

[huub8]

ik heb die functie omgeschreven door uint16_t te vervangen door unsigned int, en in de tweede for loop x = ; te vervangen door x = pos_x (daar miste wat), dus deze functie gebruikt:

code:

void TFT_Image(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){

    unsigned int x;
    unsigned int y;
    unsigned int temp;

    TFT_CS  = 0;

    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);
        }
    }
    TFT_CS = 1;
}

met dit als plaatje:

code:

const code char abc[512] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};

en dit als aanroep:
TFT_Image2(0,0,8,8,abc);

ik krijg dan een vakje met pixels van allerlei kleuren

[Infant]

Hm... op wat draai je het?

[huub8]

een 18f45k22 geplaatst op een easypic v7 board, de andere functies doen het echter wel (lijnen, vierkanten text etc)

[Infant]

Is het vakje trouwens wel 8x8 op plek 0,0?

Het lijkt mij dat hij gewoon random geheugen zit weg te schrijven, en dat je geheugen dus vol is. Kun je zien hoeveel ram er gebruikt is?

Ik hoop dat je bijv. die const FONT_16x16 er niet ingevrot hebt....?

[ Voor 9% gewijzigd door Infant op 19-06-2012 16:49 ]

[huub8]

Used ROM (bytes): 11289 (34%) Free ROM (bytes): 21479 (66%) Used ROM (bytes): 11289 (34%) Free ROM (bytes): 21479 (66%)

Used RAM (bytes): 906 (60%) Free RAM (bytes): 609 (40%) Used RAM (bytes): 906 (60%) Free RAM (bytes): 609 (40%)

als je hiermee: Ik hoop dat je bijv. die const FONT_16x16 er niet ingevrot hebt....?
bedoeld dat ik die in mijn programma heb staan als constant, dan ja

EDIT:

dit werkt wel, er gaat dus denk ik iets fout met temp

code:

void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){

    unsigned int x;
    unsigned int y;
    unsigned int temp;

    TFT_CS  = 0;

    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){

            TFT_Set_Address(x,y,x,y);
            Write_Data(0x0000);
        }
    }
    TFT_CS = 1;
}

[ Voor 38% gewijzigd door huub8 op 19-06-2012 17:09 ]

[Infant]

Je compiler is dan kennelijk lief genoeg om een const in het ROM te proppen. Dat is aardig, behalve dat ik niet zeker weer of je dat zomaar met een pointer kunt adresseren. In een AVR kun je dit bijvoorbeeld niet doen, ik weet niet hoe dat bij PIC's zit....

Het type uint16_t gebruik ik ook niet zomaar. Een unsigned int is meestal namelijk 32-bits. Elke compiler en architectuur maakt hier wat anders van... en zo snapt niemand meer wat er aan de hand is.

Dus... verander het weer eens naar uint16_t's, en probeer eens een plaatje in het ram te zetten, waarschijnlijk zo:

C:

#define HOOGTE  8
#define BREEDTE 8
#define PLAATJE HOOGTE * BREEDTE

volatile uint16_t plaatje[PLAATJE] = {
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000
};

[Infant]

Als tekst het wel normaal doet, maakt het kennelijk niet uit dat het in het ROM staat.

En TFT_FIll kan ook het scherm rood, groen, blauw maken?

[huub8]

ik weet vrij zeker dat alle ints 16bit zijn in mikroc, maar waar kan ik de benodigne .h bestanden vinden?

[Infant]

#include <stdint.h>

Pakt ie dit niet?

[huub8]

nee, maar ik heb even met de debug functie gekeken, het lijkt erop dat temp inderdaad allerlei rare waardes krijgt door temp = *picture++;

Daar gaat het dus denk ik fout

Edit:

Dit werkt wel:

code:

const unsigned int plaatje[64] = {
    0x0000,0xFFFF,0x0000,0xFFFF,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,

    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000
};


void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){

    unsigned int x;
    unsigned int y;
    unsigned int i;

    TFT_CS  = 0;
    i = 0;
    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            //temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(plaatje[i]);
            i++;
        }
    }
    TFT_CS = 1;
}

[ Voor 75% gewijzigd door huub8 op 19-06-2012 17:31 ]

[Infant]

Hm... gaar.

Ook met de uint16_t plaatje[PLAATJE]... dat is raar.

[Infant]

Hm.. als dat wel werkt... dan JEEJ!

Maar ik snap niet waarom het niet met een pointer gaat. Doe eens alleen met *picture, dus zonder ++. Dan zou hij gewoon alles een kleur moeten geven...

[huub8]

dan geeft hij het allemaal een soort donkerblauwe kleur, lijkt dus een willekeurige kleur te zijn

[Infant]

Okee, en gezien je toch een debugger hebt... kun je nu zien wat de waarde van temp is.... en die is?

[huub8]

de eerste keer lijkt hij 2048 te zijn, daarna 2056 en dat blijft hij dan, dit is dus zonder de ++

[ Voor 14% gewijzigd door huub8 op 19-06-2012 17:55 ]

[Infant]

Dat is de eerste keer 2048 is, kan prima. Hij is namelijk niet geinitialiseerd.

En dan denk ik dat het nu interessant word:

Doe eens temp initialiseren op ... 64. Dus:

C:

...
uint16_t temp = 64;
...

//En verderop, laten zoals het nu is. Dus.
...
temp = *picture;
...

Wat is dan de waarde van temp de eerste en 2e keer?

[huub8]

temp is voor de eerste keer deze regel 64: temp = *picture;
daarna de eerste keer 2048
daarna steeds 2056

ik heb overigens nog steeds unsigned int in plaats van uint16

dit is de code

code:

void TFT_Image(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){

    unsigned int x;
    unsigned int y;
    unsigned int temp = 64;

    TFT_CS  = 0;

    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            temp = *picture;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);
        }
    }
    TFT_CS = 1;
}

[ Voor 88% gewijzigd door huub8 op 19-06-2012 18:06 ]

[Infant]

Wat? Dus hij neemt nooit de waarde 64 aan? That makes no sense!

[huub8]

wel, hij is dus 64 tot deze regel:
temp = *picture;

daarna is hij 2048, tot hij voor de tweede keer en alle keren daarna bij die regel aankomt, want dan is hij telkens 2056

hij krijgt dus de waarde 2048 de eerste keer dat hij hier komt: temp = *picture;

[ Voor 73% gewijzigd door huub8 op 19-06-2012 18:08 ]

[Infant]

En als je nog een extra picture in het geheugen plaatst, en die mee geeft aan de functie, i.p.v. plaatje 1.

Het lijkt erop dat 2048 gewoon het adres is, in plaats van daadwerkelijk de waarde. Waarom hij er 8 bij optelt is een beetje een raadsel...

[huub8]

het blijft hetzelfde, het vreemde is ook dat als ik met mijn muis op picture ga staan hij netjes 0x00 00 geeft

als ik de eerste int in het plaatje verander in 0xFFFF en met mijn muis op picture ga staan geeft hij ook netjes 0xFF FF weer, dus het is echt de eerste waarde uit picture, maar op de 1 of andere manier kent hij dus niet de waarde van picture toe aan temp, maar iets anders

[ Voor 59% gewijzigd door huub8 op 19-06-2012 18:28 ]

[Infant]

Als je plaatje op adres 0x0000 begint, dan kan dat. Maar ik zou iets anders verwachten.

Geeft je compiler ergens nog warnings o.i.d?

[Infant]

Ah... Maar je gaat met je muis over *picture heen, of picture...?
Dat zijn twee verschillende dingen.

[huub8]

*picture

[huub8]

in de regel: temp = *picture;

de enige opmerking van de compiler:
114 1508 Implicit conversion of int to ptr lcdproject.c

voor de regel:
TFT_Image(0,0,8,8,*plaatje2);

[ Voor 71% gewijzigd door huub8 op 19-06-2012 18:32 ]

[huub8]

maar wat ik dus raar vind is dat de waarde van temp niet gelijk wordt gemaakt aan de waarde van *picture, maar aan iets anders. De waarde van *picture komt namelijk wel gewoon overeen met een element uit de array.

dus in deze regel:
temp = *picture;

is de waarde van *picture 0x0000, maar na deze regel is de waarde van temp 2048 of 2056, niet 0x0000

[Infant]

Ja, precies. Dus de debugger vind dat alles goed gaat, maar in werkelijkheid totale chaos....

En als we nu voor de gein de pointer kopieren, en daar mee gaan werken:

C:

void TFT_Image(uint16_t pos_x,uint16_t pos_y,uint16_t dim_x,
        uint16_t dim_y,uint16_t *picture){
        
    uint16_t x      = 0;
    uint16_t y      = 0;
    uint16_t temp   = 0;    
    uint16_t *pt    = picture;
    
    
    TFT_CS  = 0;
    
    for(y = pos_y; y<(pos_y+dim_y); y++){
        for(x = pos_x; x<(pos_x+dim_x); x++){
            temp = *pt;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);           
        }
    }
    TFT_CS = 1;
}

Als je dan op regel 7 kijkt, verwacht je dat de debugger in beide gevallen het adres geeft als waarde.

[huub8]

ik heb iets ander geprobeerd, namelijk dit

code:

void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){

    unsigned int x;
    unsigned int y;
    unsigned int temp;

    TFT_CS  = 0;

    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            temp = picture;
        
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);
        }
    }
    TFT_CS = 1;
}

dit werkt in de zin dat inderdaad alles de kleur van het eerste element van de array krijgt, ik krijg de pointer alleen niet opgehoogd

[huub8]

met jouw code geeft hij hier een foutmelding:
unsigned int *pt = picture;
695 375 Const expression expected lcddriver.c

[Infant]

Dan is dus kennelijk picture niet een pointer. Op een of andere manier.

Misschien is ie ergens globaal gedefined?

Het bizarre is dat de rest van de functies gewoon normaal doen, die gebruiken ook gewoon op exact dezelfde manier pointers...

[ Voor 10% gewijzigd door Infant op 19-06-2012 19:02 ]

[huub8]

heel vreemd, ik krijg met geen enkele formulatie picture opgehoogd, de waarde neemt alleen telkens met 2 (dus niet het adres) toe

picture vervangen door het woord afbeelding helpt niet

[ Voor 5% gewijzigd door huub8 op 19-06-2012 19:07 ]

[Infant]

Conclusie: MicroC als development unit ding stinkt. Welke versie is het?

[huub8]

de laatste versie, een week terug gedownload van hun website

[ Voor 3% gewijzigd door huub8 op 19-06-2012 19:10 ]

[Infant]

Tja, je kunt hem dan nog voor de gein zo aan roepen:

TFT_Image2(0,0,8,8,&plaatje);

Wat heeft ie daar over te klagen?

[huub8]

dat is een: 114 384 Illegal pointer conversion lcdproject.c

[Infant]

Jee, dat klopt. Dus hij snapt dat het een pointer is. Waarom dringt dat niet door?

En zo: TFT_Image2(0,0,8,8,(unsigned int*)plaatje);

[huub8]

eveneens: 114 384 Illegal pointer conversion lcdproject.c

[Infant]

Mijn inspiratie is op. Je compiler is stuk.

Hier volgt een quote uit The IT-Crowd:
"Have you tried turning it off and on again?"

[huub8]

ook gedaan, ik heb het maar op het mikroe forum gezet:
http://www.mikroe.com/forum/viewtopic.php?f=88&t=49129&p=190472#p190472

[Lone Gunman]

als ik er zo doorheen lees lijkt het dat je rom en ram pointers doorelkaar gebruikt? ik heb geen ervaring met mikroc voor pic, maar c18 doet ook iets dergelijks.

wat gebeurd er als je het volgende doet:

C:

const unsigned int plaatje[64] = { ... }; // zorg dat je plaatje in rom komt te staan

void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,const unsigned int *picture) {
// "const unsigned int *picture": const is belangrijk hier, dit geeft aan dat de functie een
// pointer naar rom verwacht ipv een pointer naar ram

    unsigned int x;
    unsigned int y;
    unsigned int temp;

    TFT_CS  = 0;
    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            // kopieer van rom naar ram
            temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);
        }
    }
    TFT_CS = 1;
}

ik heb niet alles gelezen dus misschien heb je dit op deze manier al geprobeerd.
toch zou het zo volgens mij moeten werken, zie bv ook http://www.mikroe.com/forum/viewtopic.php?t=8946

[huub8]

als ik die code gebruik dan krijgt *picture lijkt het wel een waarde van 3 bytes (0x00 00 00) en wordt die waarde steeds opgehoogd en niet het adres, net als eerst

(lag tweakers er trouwens net uit?)

[Lone Gunman]

tweakers lag er hier ook even uit ja.

hoe bedoel je *picture lijkt een waarde van 3 bytes?
en wat gebeurd er als je ipv temp = *picture++; er temp = *picture; picture++; van maakt?

als dat laatste niet eens werkt zou je misschien even wat testjes kunnen schrijven, bv een stringcompare die een string uit ram en een string uit rom vergelijkt... om iig wat grip te krijgen op de pointer implementatie van mikroc.

[huub8]

als ik met mijn muis op *picture ga staan geeft hij in plaats van 0x00 00 in de debug mode nu 0x00 00 00

temp = *picture++; er temp = *picture; picture++;
Heb ik al geprobeerd, hielp ook niet. Ik ben nu met je laatste suggestie bezig.

[huub8]

met de help van iemand op het mikroe forum ben ik eruit, dit is de code geworden:

code:

static unsigned int plaatje2[] = {
    0x0000,0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,

    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000
};

TFT_Image2(0, 0, 8, 8, plaatje2);

void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int *picture){
    unsigned int x, y;
    TFT_CS  = 0;

    for( y=pos_y; y<(pos_y + dim_y); y++ ) {
        for( x=pos_x; x<(pos_x + dim_x); x++ ) {
            TFT_Set_Address(x, y, x, y);
            Write_Data(*picture);
            picture++;
        }
    }
    TFT_CS = 1;
}

Heel erg bedankt voor jullie hulp, zonder was ik er niet uitgekomen

[ Voor 3% gewijzigd door huub8 op 19-06-2012 21:00 ]

[biomass]

Ik heb je topic gelezen en wou toch nog vragen: Begrijp je nu ook waarom die code werkt?

C:

const unsigned int plaatje[64] = {
.
.
};


void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,unsigned int*  picture){

    unsigned int x;
    unsigned int y;
    unsigned int i;

    TFT_CS  = 0;
    i = 0;
    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            TFT_Set_Address(x,y,x,y);
            Write_Data(plaatje[i]);
            i++;
        }
    }
    TFT_CS = 1;
}

Dit werkt omdat je je plaatje als array van unsigned ints benaderd. De grootte van het plaatje is beperkt door een eventuele overflow in i.

C:

            temp = *picture++; 
            TFT_Set_Address(x,y,x,y); 
            Write_Data(temp);

Bovenstaande werkt niet omdat je de dan de eerste waarde, waar picture naar wijst, ophoogt en toekent aan temp. Zo krijg je een plaatje in een kleur die afhankelijk is van de eerste int in het array. We schrijven allemaal wel eens iets te snel iets op

Kijk eens http://en.wikipedia.org/wiki/Dereference_operator, dat is wellicht verhelderend. Het enige wat ik zelf anders zou doen is de plaatsing van het sterretje in de declaraties; dan zie je veel makkelijker hoe je de dereference moet doen. Die Engelsman/vrouw doet het trouwens ook: http://www.mikroe.com/for...&t=49129&p=190472#p190470

Zo dus:

C:

int x = 0;
 int* pointer_to_x = &x;
 (*pointer_to_x) += 1;
 //x is now equal to 1

[Infant]

Het grappige is dus, in VS2010 en in GCC doet ie het prima.

Met de statement:

C:

temp = *picture++; 

Bedoel je:
Temp is waarde waar pointer naar wijst.
Vervolgens: Increase de pointer met 1.

Het volgende stukje code produceert bij mij als output:
2
4
1

C:

uint16_t ret(uint16_t *pic){    
    uint16_t temp = *pic++;
    printf("%i\n", temp);
    temp = *pic++;
    printf("%i\n", temp);
    temp = *pic++;
    printf("%i\n", temp);
    return temp;
}

int _tmain(int argc, _TCHAR* argv[]){   
    char bmpdata[6] = {2,0,4,0, 1,0};
    ret((uint16_t*)bmpdata);        
    system("pause");
    return 0;
}

Dus nee, ik snap het nog steeds niet. Of krijg ik nu door een char pointer naar een uint16_t pointer te casten een pointer naar een pointer? Dacht ik niet toch?

[ Voor 8% gewijzigd door Infant op 19-06-2012 21:41 ]

[Lone Gunman]

@biomass: temp = *picture++; is hier gewoon goed, eerst wordt *picture toegekend aan temp en daarna wordt picture opgehoogd (zie ook http://en.wikipedia.org/w...t_and_decrement_operators).

Het probleem zit m toch echt in de soort pointers volgens mij. Ik heb even mikroc geinstalleerd en wat dingen geprobeerd. Het volgende werkt gewoon prima hier (met dezelfde target pic als gebruikt door de ts):

C:

const unsigned int plaatje[] = {
    0xa001,0xa002,0xa003,0xa004,0xa005,0xa006,0xa007,0xa008,
    0xa009,0xa00a,0xa00b,0xa00c,0xa00d,0xa00e,0xa00f,0xa010,
    0xa011,0xa012,0xa013,0xa014,0xa015,0xa016,0xa017,0xa018,
    0xa019,0xa01a,0xa01b,0xa01c,0xa01d,0xa01e,0xa01f,0xa020,
    0xa021,0xa022,0xa023,0xa024,0xa025,0xa026,0xa027,0xa028,
    0xa029,0xa02a,0xa02b,0xa02c,0xa02d,0xa02e,0xa02f,0xa030,
    0xa031,0xa032,0xa033,0xa034,0xa035,0xa036,0xa037,0xa038,
    0xa039,0xa03a,0xa03b,0xa03c,0xa03d,0xa03e,0xa03f,0xa040,
};

static unsigned int mem[128] = { 0 };
static unsigned int pos = 0;

void Write_Data(unsigned int val) {
    mem[pos++] = val;
}

void TFT_Image2(unsigned int pos_x,unsigned int pos_y,unsigned int dim_x,unsigned int dim_y,const unsigned int *picture) {
    unsigned int x;
    unsigned int y;

    //TFT_CS  = 0;
    for(y = pos_y; y < (pos_y + dim_y); y++){
        for(x = pos_x; x < (pos_x + dim_x); x++){
            //TFT_Set_Address(x,y,x,y);
            Write_Data(*picture++);
        }
    }
    //TFT_CS = 1;
}


void main() {
     TFT_Image2(0, 0, 8, 8, plaatje);

     while(1);
}

Als ik dit debug, en de ram map bekijk, wordt alles exact van rom naar ram gezet. Als ik temp toevoeg werkt het ook zoals verwacht. Verder, als ik zowel het plaatje als het laatste argument niet const maak, werkt het ook gewoon zoals verwacht. Pas als ik een mismatch maak tussen plaatje en het laatste argument (de ene const en de andere niet of andersom), krijg ik een melding van de compiler.

Ik snap dus echt niet waarom dit niet werkt in jouw geval, doe je misschien iets raars bij de aanroep van de functie?

[ Voor 7% gewijzigd door Lone Gunman op 19-06-2012 22:06 ]

[Infant]

Volgens de associativity regels zou unairy operators voor dereference gaan. Dus *bla++ kan zoals ik het wou niet apparently?

Het volgende is dus zwaar interessant:

C:

//INCLUDES
#include <util/delay.h>
#include <avr/io.h>
#include <stdlib.h> //itoa
#include <stdio.h>

void TFT_Set_Address(uint16_t PX1,uint16_t PY1,uint16_t PX2,uint16_t PY2){
}

void Write_Data(uint16_t temp){
}   

static uint16_t plaatje[] = {
    1,2,3,4,5,6,7,8
};

void TFT_Image(uint16_t pos_x,uint16_t pos_y,uint16_t dim_x,
        uint16_t dim_y,uint16_t *picture){
        
    uint16_t x      = 0;
    uint16_t y      = 0;
    uint16_t temp   = 0;        

    for(y = pos_y; y<(pos_y+dim_y); y++){
        for(x = pos_x; x<(pos_x+dim_x); x++){
            temp = *picture++;
            TFT_Set_Address(x,y,x,y);
            Write_Data(temp);           
        }
    }
}

int main(){
    TFT_Image(0,0,8,8,plaatje);
    return 0;
}

avr-gcc compiled en optimized dit zeer efficient naar een whopping 86 bytes code. Wauw!

De asm output wordt dan:

GAS:

int main(){
    TFT_Image(0,0,8,8,plaatje);
    return 0;
}
  4c:   80 e0           ldi r24, 0x00   ; 0
  4e:   90 e0           ldi r25, 0x00   ; 0
  50:   08 95           ret

Dus: Hij doet niks.

Maar als ik nu doe:

C:

temp = (*picture)++;

Maakt hij netjes 16 bytes aan data, en 212 bytes code.

Dus.... Microsoft 0 | GCC 1 voor het zich aan de standaard houden?
Ik ga nu wat code reviewen...

[Lone Gunman]

@huub8: als ik de oplossing probeer die je op het mikroe forum gekregen heb, wordt de hele array in het ram geheugen geplaatst. zou je aub toch eens de versie uit mijn laatste post willen proberen? het scheelt iig een hoop ram en ik ben eigenlijk wel benieuwd of deze bij jou ook gewoon werkt.

[huub8]

Ik moet nu naar college, maar als ik terug kom ga ik dat zeker proberen, ik merkte ook al dat het helemaal in het ram geheugen wordt gezet, en dat is voor mij (door het beperkte geheugen van de pic) ook eigenlijk geen oplossing.

[Lone Gunman]

ik heb er toch nog even kort naar gekeken, en opzich is de werking van mikroc pic gewoon logisch:

C:

// const, de data is opgeslagen in rom
const char romdata[] = { 1, 2, 3, 4, 5, 6, 7, 8 };

// niet const, data is opgeslagen in ram EN in rom
// de data wordt bij het opstarten van de mcu automatisch gekopieerd van rom naar ram
char ramdata[] = { 8, 7, 6, 5, 4, 3, 2, 1 };

// functie accepteert alleen rom pointers
void accept_romptr(const char* romptr) {
}

// functie accepteert alleen ram pointers
void accept_ramptr(char* ramptr) {
}

void main() {
     int i;
     char buffer[8] = { 0 };

     // functie verwacht en krijgt een rom pointer
     accept_romptr(romdata); // OK
     accept_romptr(&romdata); // OK
     accept_romptr(&romdata[0]); // OK

     // functie verwacht een rom pointer, maar krijgt een ram pointer
     accept_romptr(ramdata); // Compile error (384 Illegal pointer conversion)
     accept_romptr(&ramdata); // Compile error (384 Illegal pointer conversion)
     accept_romptr(&ramdata[0]); // Compile error (384 Illegal pointer conversion)

     // functie verwacht en krijgt een ram pointer
     accept_ramptr(ramdata); // OK
     accept_ramptr(&ramdata); // OK
     accept_ramptr(&ramdata[0]); // OK

     // functie verwacht een ram pointer, maar krijgt een rom pointer
     accept_ramptr(romdata); // Compile error (384 Illegal pointer conversion)
     accept_ramptr(&romdata); // Compile error (384 Illegal pointer conversion)
     accept_ramptr(&romdata[0]); // Compile error (384 Illegal pointer conversion)

     // kopieer data handmatig van rom naar ram
     for(i = 0; i < sizeof(buffer); i++) {
           buffer[i] = romdata[i];
     }
     
     accept_ramptr(buffer); // OK, buffer is in ram
     accept_romptr(buffer); // Compile error (384 Illegal pointer conversion)
     
     // onderstaande is uiteraard fout en absoluut niet wat je wilt
     // (geeft zelfs warning 1508 Implicit conversion of int to ptr)
     // je pakt namelijk de eerste waarde uit de romdata array (1),
     // en die waarde wordt impliciet geconverteerd naar een ram pointer die verwijst naar adres 0x0001.
     accept_ramptr(*romdata);
     // bovenstaande is gelijk aan:
     accept_ramptr(1);
}

Oftewel, er is gewoon een verschil tussen rom en ram pointers zoals ik al eerder aangaf. Zodra je die door elkaar gaat gebruiken gaat het verkeerd. Waarom het eerder niet bij jou werkte was omdat je de hele tijd de functie verkeerd aanriep, dat was me helaas niet opgevallen bij het lezen van deze thread.

[huub8]

@Lone_Gunman

Bedankt voor je uitleg, ik ga het allemaal nog eens rustig doorlezen als ik de tijd heb (tentamens), maar ik heb net wel even jouw functie geprobeerd en die werkt (inderdaad ook zonder dat het hele plaatje naar de ram wordt verplaatst).

Ik moet nu alleen nog een programma vinden dat bitmaps omzet in een geschikte array, of ik schrijf er zelf een C# programma'tje voor.

edit:

net een programmat'je geschreven dat een plaatje pixel voor pixel omzet in 16b r5 g6 b5 hex formaat, en dit werkt perfect. Nu nog even support voor een sd kaartje toevoegen, want het rom is ook zo vol. Als het geheel af is zal ik het waarschijnlijk op mijn website zetten, dan hebben anderen er ook nog wat aan.

[ Voor 58% gewijzigd door huub8 op 21-06-2012 01:52 ]