🚀 go-pugleaf

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