🚀 go-pugleaf

Ik weet niet met welke compiler/CPU je werkt zodat opmerking 1
mogelijk niet van toepassing is.

1) Als ik mij niet vergis is een char niet gegarandeerd 8 bits.  De
breedte is zodanig dat deze geschikt is om 8 bits in op te bergen (kan
dus perfect 12,16, 32 bits zijn). Dit hangt volldig af van de
gebruikte CPU en de creativiteit van de gebruikte C compiler. Dit
maakt ��n en ander nog leuker om porteerbare code te schrijven.
2) Je zegt zelf dat de variabele TypFixSize een aray voorstelt.
Volgens je definitie is dit niet het geval. Ik raad je aan om de
definitie als volgt te wijzigen:

extern INT8U TypFixSize[256]; /* Flash array 256 bytes */tie ; /*
Flash array 256 bytes */

Mogelijk is dit van invloed op de gegenereerde code.

Patrick 

On Fri, 31 Aug 2001 21:02:13 GMT, erno@freegates.be (a183824) wrote:

>Als C-newbie heb ik vooral problemen met de syntax van C (ik ga nog
>altijd op assembly-niveau kijken wat 'm er van bakt om te weten of de
>C-code juist is).
>Een van de varianten die -net als de andere- niet goed werkt:
>
>          TypePointer += *((INT8U*) ((&TypFixSize) + type)));
>
>/*********************************************************************************
> * Wat moet er gebeuren:
> * Met &TypFixSize wordt base-pointer bekomen.  Dat is Ok.
> * Maar de offset "type" wordt vermenigvuldigd alsof het een word
> * betreft, terwijl het volgens mij toch allemaal byte-spul is.
> * Al diverse cast's geprobeerd, maar het blijft mis lopen.
> * Weet er iemand hoe je een byte-variabele gewoon optelt bij een
> * pointer naar byte?  Bedoeling is dus: als pointer x gelijk is aan
>$1000, en integer of byte y is $10, moet ik de pointer op $1010
>krijgen.  Als ik een constante optel gaat het goed.  Ik heb zelfs al
>geprobeerd met een pointer naar de lowbyte van de variabele, maar die
>werd na het binnenhalen naar links geshift (=*2) voor het optellen.
>
>**********************************************************************************
> */
>
>Voor wie het volledige verhaal wil:
>
>Ik zit met een aantal byte-tabellen die op assembly niveau
>gedeclareerd zijn (dat is nodig omdat het voor een MCU bestemd is: dat
>betekend dus dat het in specifieke fysieke addressen (de juiste Flash
>sector of RAM) moet zitten.  Dat is binnen C nog niet gelukt.  Er zijn
>twee size-tabellen van 256-bytes in Flash.  Per pin-type geven die de
>size weer van de pin-descriptor (gevonden in een variable-size tabel)
>en de benodigde RAM voor het beheer van de pin.  De 3de ROM-tabel is
>16-bytes groot en bevat masks welke MCU-I/O pinnen een
>typebeschrijving hebben.  Een 4de tabel (variable size) geeft in
>volgorde van maskering aan wat de pin-type (= functiie) is.  In RAM
>staan er nog twee tabellen van elk 256 bytes: die bevatten voor elk
>van de 256 mogelijke pin types het aantal gevonden "channels".  Dit is
>immers variabel in functie tot een add-on printplaat.
>Eens de hoogste nummer van elke pin-type gevonden, kan de RAM per
>pin-type gealloceerd (#channels * size die gelezen wordt uit de 2de
>tabel).  De beschrijvingstabel van de pin-types zelf is ook variabel,
>en de size hiervan wordt uit de 1ste lookup table van 256 bytes
>gehaald.  Door die bij te tellen bij de hiudige pointer, kom ik
>terecht op de volgende pin-type descriptor.  Dit systeem maakt het
>mogelijk dat op dezelfde microcontroller met dezelfde software een
>UART ingang tot 4 functies kan hebben: binary-out, binary-in, LED-out
>(met eigen knipperrepeater) en UART-in.  Dit volledig in functie tot
>de opsteekprintplaat die in functie van het gewenste resultaat pinnen
>totaal anders kan initialiseren.  Het pin-beheer wordt dan geregeld
>door assembly-code (snelheid) terwijl er tegelijk een (assembly)
>script interpreter loopt die gekoppeld is naar het I/O
>pinbeheerssysteem.  De init van  het pinbeheersyssteem zie ik liever
>in C, omdat het later leesbaarder blijft dan alles in assembly.
>
>INT8U is een unsigned char, enz...  Dat zit allemaal goed.
>
>Alle externe brol zit op assembly-niveau.
>
>extern INT8U  CntApinType 
>	/* eerste byte van 256 byte RAM array */
>extern INT8U  CntRpinType; /* idem, voor relatieve count */
>
>extern __far INT8U  MPinTypMask; 
>	/* Flash array 16 mask-bytes, er ook een EEPROM variant voor
>de relatieve count */
>
>extern __far INT8U  MPinType; /* Pin Type descriptor table */
>
>/* Labels zijn eerste byte van de array */
>extern INT8U TypFixSize; /* Flash array 256 bytes */
>
>extern INT8U TypRamSize; /*Flash array 256 bytes */
>
>extern void*   CntPinType;
>
>
>INT16U PinChannelCount(INT16U Mode)
>{
>  __far INT8U* TypePointer = (__far INT8U*) &MPinType;
>  __far INT8U* MaskPointer = (__far INT8U*) &MPinTypMask; 
>  INT16U change = 0;
>  register INT16U channel;
>  register INT16U defpinmask;
>  register INT8U type;
>  register INT16U a;
>  register INT16U b;
>  INT8U* p;
>
>  if(Mode == TRUE)
>  {
>   /* Assembly routine die in 1 instructie geheugen cleared ipv een
>loop */
>    ZeroMem((INT8U*) &CntApinType, 256);
>    ZeroMem((INT8U*) &CntRpinType, 256);
>  }
>  else
>  {
>    for(a = 0; a != 16; a++)
>    {
>      defpinmask = *MaskPointer++;
>      for(b = 1; b < 256;  b = (b << 1))
>      {
>        if((defpinmask & b) !=0)
>        {
>	/* eerste byte is pin-type */
>          type = *(TypePointer++);
>	/* 2de byte is type-channel */
>          channel = *(TypePointer++);
>
>	/* Zet RAM pointer op hoogst gevonden channelnummer */
>          if((Mode & 0x01) == 0)
>          {
>            p = (INT8U*) (&CntApinType) + type;
>          }
>          else
>          {
>            p = (INT8U*) (&CntRpinType) + type; 
>          }
>
>          if(*p <= channel)
>          {
>            *p = (channel + 1);
>            change++;
>          }
>
>/*********************************************************************************
> * Hier loopt het fout:
>
>**********************************************************************************
> */
>          TypePointer += *((INT8U*) ((&TypFixSize) + type)));
>        }
>      }
>    }
>  }
>  return change;
>}
>