• internal representation of variables


• storing/accessing variables


• speeding up sequential memory access


• reentrancy

• precompiled libs should be compiled with ICD debug option, not release, or final user won't be able to use ICD
• FloatToStr procedure requires the string parameter to be of at least 11 chars long (or more, for numbers with integer part larger than 5 digits). Following the example in Help, where the string parameter is declared as string[10], will lead to overwriting of any variable placed in RAM after the string - or reversly, which is even more dangerous.
• 'at' keyword cannot be used with local declarations
• 'sbit' type may be used with GPRs, but cannot be used with local variables

Internal representation of variables

Multi-byte variables are stored in RAM as little endian, i.e. least significant byte is first, followed by more significant ones. Mostly, one does not need to concern oneself with it as there are operators allowing to access single bytes of a muli-byte variable (Lo, Hi, Higher, and Highest).

Arrays are stored by elements, with multi-dimensional arrays most inner dimension elements stored first (most inner are the ones indexed by the latest index, i.e. in arr[j][i], i is the index pointing to most inner elements). For example, elements of an array declared as

arr: array[2] of array[3] of byte;

are stored in following order

[0][0]  [0][1]  [0][2]  [1][0]  [1][1]   [1][2]

Strings and arrays of characters are stored in the order of their elements (characters) with added termination char equal zero. This means that both string[10] and array[10] of char need 11 bytes of RAM. If a string assigned to string variable (array of char) is shorter than the declared variable size, then terminating char will follow last assigned character. For example

   st:='abc';

st[0]='a', at[1]='b', st[3]='c', st[4]=0

     x = +/-m * 2^exp

bit #    31         23 22                  0
         | Exponent |S|       Mantissa      |     
                     1.d1        ...      d23 (binary rational number)

  Lo(x) -> least significant byte of mantissa (bits d16..d23)
  Hi(x) -> less significant byte of mantissa (bits d8..d15) 
  Higher(x) or $80 -> most significant byte of mantissa (1.d1d2d3d4d5d6d7)
   Higher(x).7 -> sign bit (0 - positive, 1 - negative) 
  Highest(x) -> exponent, offset by 127 

                  1.10001011000010100011111 x 2^3

                  1100.01011000010100011111

  EEPROM_Write(Address,Lo(x));
  EEPROM_Write(Address+1,Hi(x));  
  EEPROM_Write(Address+2,Higher(x));
  EEPROM_Write(Address+3,Highest(x));
  
  Lo(x):=EEPROM_Read(Address);
  Hi(x):=EEPROM_Read(Address+1);
  Higher(x):=EEPROM_Read(Address+2);
  Highest(x):=EEPROM_Read(Address+3);

 var x: real;
     ax: array[4] of byte at x;

  for i:=0 to 3 do EEPROM_Write(Address+i,ax[i]);

  for i:=0 to 3 do ax[i]:=EEPROM_Read(Address+i);

 var x: real;
     px: ^byte;
	 
  px:=^byte(@x);
  for i:=1 to 4 do
   begin
    EEPROM_Write(Address,px^);
    inc(px);
    inc(Address);
   end;	

  i:=0;
  while st[i]<>0 do
   begin
    st[i]:=' ';
    inc(i);
   end; 

  FSR0ptr:=@st;
  while INDF0<>0 do POSTINC0:=' ';

  FSR0ptr:=@st;
  FSR0:=word(@st);

  POSTINC0:=POSTDEC1;

procedure FSRcontext;
 begin
  asm
    movf FSR0L,F
    movf FSR1L,F
    movf FSR2L,F
  end;
 End;{FSRcontext}

program Reentrancy;

type Tproc = procedure(dr:byte); // procedure type identical to PWMx_Set_Duty 

var bb1,bb2: byte;
    
procedure PWM_dummy(dr:byte); forward; // intermediate procedures
procedure PWM_main(dr:byte);  forward; // allowing to call PWM1_Set_Duty
procedure PWM_inter(dr:byte); forward; // both from main and ISR

procedure interrupt; 
 begin
  PWM_inter(127);  // set PWM1 to 127
 End;{interrupt}
    
procedure PWM_dummy(dr:byte);
 begin
  dr:=dr;  // to avoid compiler hint
 End;{PWM_dummy}
    
procedure PWM_main(dr:byte);  // to be called from main program
 var ProcPtr: ^Tproc;
     S_INTCON: byte;
 begin
  SetFuncCall(PWM1_Set_Duty); // not really necessary
  ProcPtr:=@PWM1_Set_Duty;
  S_INTCON:=INTCON.GIE;       // main code may call PWM1_Set_Duty only with
  INTCON.GIE:=0;              // interrupts blocked
  ProcPtr^(dr);             
  INTCON.GIE:=S_INTCON;
 End;{PWM_main}

procedure PWM_inter(dr:byte); // to be called from ISR
 var ProcPtr: ^Tproc;
 begin
  SetFuncCall(PWM_dummy);     // make linker believe PWM_dummy will be called
  ProcPtr:=@PWM1_Set_Duty;    // while calling PWM1_Set_Duty from ISR
  ProcPtr^(dr);
 End;{PWM_inter}

BEGIN
 PWM1_Init(5000); // PWM initialisation
 PWM1_Start;
 PWM_main(0);     // set PWM1 to 0

 while True do
  begin
                  // main program loop
  end; 
END.