lms2012.c

Go to the documentation of this file.

/*
 * LEGO® MINDSTORMS EV3
 *
 * Copyright (C) 2010-2013 The LEGO Group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */


#include  "lms2012.h"
#include  "c_math.h"
#include  "c_move.h"
#include  "c_branch.h"
#include  "c_compare.h"
#include  "c_timer.h"
#include  "c_output.h"
#include  "c_input.h"
#include  "c_ui.h"
#include  "c_memory.h"
#include  "c_com.h"
#include  "c_sound.h"
#ifndef Linux_X86
#include  "c_bt.h"
#include  "c_i2c.h"
#endif
#include  "validate.h"

#if       (HARDWARE != SIMULATION)

#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include  <unistd.h>
#include  <time.h>
#include  <syslog.h>
#include  <math.h>

#include  <dirent.h>
#include  <sys/stat.h>
#include  <sys/statvfs.h>
#include  <sys/types.h>
#include  <sys/time.h>
#include  <fcntl.h>
#include  <sys/ioctl.h>

#include  <sys/mman.h>


#endif

#ifdef    DEBUG_VM
#define   DEBUG
#endif

#ifdef    DEBUG
#define   DEBUG_TRACE_TASK
#define   DEBUG_TRACE_VM
#endif

// Buttons are mapped differently in the enum BUTTONTYPE and in ButtonState.
#define IDX_BACK_BUTTON BACK_BUTTON-1

//*****************************************************************************
// UI bootloader
//*****************************************************************************

UBYTE     UiImage[] =
{
  // IMAGE header
  PROGRAMHeader(0,1,0),                 // VersionInfo,Objects,GlobalBytes
  VMTHREADHeader(0,1),                  // OffsetToInstructions,LocalBytes

  opFILE,LC0(LOAD_IMAGE),LC0(GUI_SLOT),GV0(0),LV0(4),LV0(0),
  opPROGRAM_START,LC0(GUI_SLOT),LC0(0),LV0(0),LC0(0),
  opOBJECT_END,

};

#if       (HARDWARE != SIMULATION)
  GLOBALS VMInstance;
#else
  GLOBALS * gInstance;

  void setInstance(GLOBALS * _Instance)
  {
    gInstance= _Instance;
  }

  GLOBALS* getInstance()
  {
    return gInstance;
  }

#endif
//*****************************************************************************
// Forward declarations
//*****************************************************************************
#define   PRIMDISPATHTABLE_SIZE   256

extern PRIM      PrimDispatchTabel[PRIMDISPATHTABLE_SIZE];          

void      Error(void);
void      Nop(void);
void      ObjectStop(void);
void      ObjectStart(void);
void      ObjectTrig(void);
void      ObjectWait(void);
void      ObjectCall(void);
void      ObjectReturn(void);
void      ObjectEnd(void);
void      ProgramStart(void);
void      ProgramStop(void);
void      Sleep(void);
void      ProgramInfo(void);
void      DefLabel(void);
void      Do(void);
void      Probe(void);
void      BreakPoint(void);
void      BreakSet(void);
void      Random(void);
void      Info(void);
void      Strings(void);
void      MemoryWrite(void);
void      MemoryRead(void);
void      cBranchJr(void);
void      PortCnvOutput(void);
void      PortCnvInput(void);
void      NoteToFreq(void);
void      System(void);
void      Monitor(void);

void      TstClose(void);
void      Tst(void);


//*****************************************************************************
// Interface for shared libraries
//*****************************************************************************

OBJID         CallingObjectId(void)
{
  return (VMInstance.ObjectId);
}


PRGID     CurrentProgramId(void)
{
  return (VMInstance.ProgramId);
}


OBJSTAT   ProgramStatus(PRGID PrgId)
{
  return (VMInstance.Program[PrgId].Status);
}


OBJSTAT   ProgramStatusChange(PRGID PrgId)
{
  OBJSTAT Status;

  Status  =  (DATA8)VMInstance.Program[PrgId].StatusChange;
  VMInstance.Program[PrgId].StatusChange  =  0;

  return (Status);
}


IP        GetImageStart(void)
{
  return (VMInstance.pImage);
}


void      SetDispatchStatus(DSPSTAT DspStat)
{
  VMInstance.DispatchStatus  =  DspStat;

  if (VMInstance.DispatchStatus != NOBREAK)
  {
    VMInstance.Priority  =  0;
  }

}


void      SetInstructions(ULONG Instructions)
{
  if (Instructions <= PRG_PRIORITY)
  {
    VMInstance.Priority  =  Instructions;
  }
}


void      AdjustObjectIp(IMOFFS Value)
{
  VMInstance.ObjectIp += Value;
}


IP        GetObjectIp(void)
{
  return (VMInstance.ObjectIp);
}


void      SetObjectIp(IP Ip)
{
  VMInstance.ObjectIp  =  Ip;
}


ULONG     GetTime(void)
{
  return (cTimerGetuS() - VMInstance.Program[VMInstance.ProgramId].RunTime);
}


ULONG     GetTimeMS(void)
{
  return (cTimerGetmS());
}


ULONG     GetTimeUS(void)
{
  return (cTimerGetuS());
}


ULONG     CurrentObjectIp(void)
{
  return ((ULONG)(VMInstance.ObjectIp - VMInstance.pImage));
}


void      VmPrint(char *pString)
{
  if (VMInstance.TerminalEnabled)
  {
    printf("%s",pString);
  }
}


void      SetTerminalEnable(DATA8 Value)
{
  VMInstance.TerminalEnabled  =  Value;
}


DATA8     GetTerminalEnable(void)
{
  return (VMInstance.TerminalEnabled);
}


void      GetResourcePath(char *pString,DATA8 MaxLength)
{
  cMemoryGetResourcePath(VMInstance.ProgramId,pString,MaxLength);
}


void*     VmMemoryResize(HANDLER Handle,DATA32 Elements)
{
  return (cMemoryResize(VMInstance.ProgramId,Handle,Elements));
}


void      SetVolumePercent(DATA8 Volume)
{
  VMInstance.NonVol.VolumePercent  =  Volume;
}


DATA8     GetVolumePercent(void)
{
  return(VMInstance.NonVol.VolumePercent);
}


void      SetSleepMinutes(DATA8 Minutes)
{
  VMInstance.NonVol.SleepMinutes  =  Minutes;
}


DATA8     GetSleepMinutes(void)
{
  return (VMInstance.NonVol.SleepMinutes);
}


void      SetUiUpdate(void)
{
  UiInstance.UiUpdate   =  1;
}


#define   ERROR(ErrorCode)    [ErrorCode]  =  #ErrorCode

char      ErrString[ERRORS][ERR_STRING_SIZE] =
{

  ERROR(TOO_MANY_ERRORS_TO_BUFFER),
  ERROR(TYPEDATA_TABEL_FULL),
  ERROR(TYPEDATA_FILE_NOT_FOUND),
  ERROR(ANALOG_DEVICE_FILE_NOT_FOUND),
  ERROR(ANALOG_SHARED_MEMORY),
  ERROR(UART_DEVICE_FILE_NOT_FOUND),
  ERROR(UART_SHARED_MEMORY),
  ERROR(IIC_DEVICE_FILE_NOT_FOUND),
  ERROR(IIC_SHARED_MEMORY),
  ERROR(DISPLAY_SHARED_MEMORY),
  ERROR(UI_SHARED_MEMORY),
  ERROR(UI_DEVICE_FILE_NOT_FOUND),
  ERROR(LCD_DEVICE_FILE_NOT_FOUND),
  ERROR(OUTPUT_SHARED_MEMORY),
  ERROR(COM_COULD_NOT_OPEN_FILE),
  ERROR(COM_NAME_TOO_SHORT),
  ERROR(COM_NAME_TOO_LONG),
  ERROR(COM_INTERNAL),
  ERROR(VM_INTERNAL),
  ERROR(VM_PROGRAM_VALIDATION),
  ERROR(VM_PROGRAM_NOT_STARTED),
  ERROR(VM_PROGRAM_FAIL_BREAK),
  ERROR(VM_PROGRAM_INSTRUCTION_BREAK),
  ERROR(VM_PROGRAM_NOT_FOUND),
  ERROR(SOUND_DEVICE_FILE_NOT_FOUND),
  ERROR(SOUND_SHARED_MEMORY),
  ERROR(FILE_OPEN_ERROR),
  ERROR(FILE_READ_ERROR),
  ERROR(FILE_WRITE_ERROR),
  ERROR(FILE_CLOSE_ERROR),
  ERROR(FILE_GET_HANDLE_ERROR),
  ERROR(FILE_NAME_ERROR),
  ERROR(USB_SHARED_MEMORY),
  ERROR(OUT_OF_MEMORY),

};


void      LogErrorNumber(ERR Err)
{
  UBYTE   Tmp;

  if (Err > TOO_MANY_ERRORS_TO_BUFFER)
  {
    Tmp  =  VMInstance.ErrorIn;
    if (++Tmp >= ERROR_BUFFER_SIZE)
    {
      Tmp  =  0;
    }
    if (Tmp != VMInstance.ErrorOut)
    {
      VMInstance.Errors[VMInstance.ErrorIn]   =  Err;
      VMInstance.ErrorIn                      =  Tmp;
    }
    else
    {
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"\r\n#### %s ####\r\n\n",ErrString[TOO_MANY_ERRORS_TO_BUFFER]);
      VmPrint(VMInstance.PrintBuffer);
    }
  }
}


DATA8     LogErrorNumberExists(ERR Error)
{
  DATA8   Result = 0;
  UBYTE   Tmp;

  Tmp  =  VMInstance.ErrorOut;
  while ((Tmp != VMInstance.ErrorIn) && (Result == 0))
  {
    if (VMInstance.Errors[Tmp] == Error)
    {
      Result  =  1;
    }
    else
    {
      if (++Tmp >= ERROR_BUFFER_SIZE)
      {
        Tmp  =  0;
      }
    }
  }

  return (Result);
}


ERR       LogErrorGet(void)
{
  ERR     Number =  0;

  if (VMInstance.ErrorIn != VMInstance.ErrorOut)
  {
    Number  =  VMInstance.Errors[VMInstance.ErrorOut];
    if (++VMInstance.ErrorOut >= ERROR_BUFFER_SIZE)
    {
      VMInstance.ErrorOut  =  0;
    }
  }

  return (Number);
}


void      CleanLogErrors(void)
{
  VMInstance.ErrorIn    =  0;
  VMInstance.ErrorOut   =  0;
}


DSPSTAT   ExecuteByteCode(IP pByteCode,GP pGlobals,LP pLocals)
{
  DSPSTAT Result;
  ULONG   Time;

  // Save running object parameters
  VMInstance.ObjIpSave            =  VMInstance.ObjectIp;
  VMInstance.ObjGlobalSave        =  VMInstance.pGlobal;
  VMInstance.ObjLocalSave         =  VMInstance.ObjectLocal;
  VMInstance.DispatchStatusSave   =  VMInstance.DispatchStatus;
  VMInstance.PrioritySave         =  VMInstance.Priority;

  // InitExecute special byte code stream
  VMInstance.ObjectIp             =  pByteCode;
  VMInstance.pGlobal              =  pGlobals;
  VMInstance.ObjectLocal          =  pLocals;
  VMInstance.Priority             =  1;

  // Execute special byte code stream
  UiInstance.ButtonState[IDX_BACK_BUTTON] &= ~BUTTON_LONGPRESS;
  while ((*VMInstance.ObjectIp != opOBJECT_END) && (!(UiInstance.ButtonState[IDX_BACK_BUTTON] & BUTTON_LONGPRESS)))
  {
    VMInstance.DispatchStatus       =  NOBREAK;
    VMInstance.Priority             =  C_PRIORITY;

    while ((VMInstance.Priority) && (*VMInstance.ObjectIp != opOBJECT_END))
    {
      VMInstance.Priority--;
      PrimDispatchTabel[*(VMInstance.ObjectIp++)]();
    }

    VMInstance.NewTime  =  GetTimeMS();

    Time  =  VMInstance.NewTime - VMInstance.OldTime1;

    if (Time >= UPDATE_TIME1)
    {
      VMInstance.OldTime1 +=  Time;

      cComUpdate();
      cSoundUpdate();
    }

    Time  =  VMInstance.NewTime - VMInstance.OldTime2;

    if (Time >= UPDATE_TIME2)
    {
      VMInstance.OldTime2 +=  Time;

      usleep(10);
      cInputUpdate((UWORD)Time);
      cUiUpdate((UWORD)Time);
    }
  }
  Result                          =  VMInstance.DispatchStatus;

  UiInstance.ButtonState[IDX_BACK_BUTTON] &= ~BUTTON_LONGPRESS;

  // Restore running object parameters
  VMInstance.Priority             =  VMInstance.PrioritySave;
  VMInstance.DispatchStatus       =  VMInstance.DispatchStatusSave;
  VMInstance.ObjectLocal          =  VMInstance.ObjLocalSave;
  VMInstance.pGlobal              =  VMInstance.ObjGlobalSave;
  VMInstance.ObjectIp             =  VMInstance.ObjIpSave;

  return (Result);
}


void*     PrimParPointer(void)
{
  void*   Result;
  IMGDATA Data;

  Result              =  (void*)&VMInstance.Value;
  Data                = *((IMGDATA*)VMInstance.ObjectIp++);
  VMInstance.Handle   =  -1;

  if (Data & PRIMPAR_LONG)
  { // long format

    if (Data & PRIMPAR_VARIABEL)
    { // variabel

      switch(Data & PRIMPAR_BYTES)
      {

        case PRIMPAR_1_BYTE :
        { // One byte to follow

          VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
        }
        break;

        case PRIMPAR_2_BYTES :
        { // Two bytes to follow

          VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
          VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 8);
        }
        break;

        case PRIMPAR_4_BYTES :
        { // Four bytes to follow

          VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
          VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 8);
          VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 16);
          VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 24);
        }

      }
      if (Data & PRIMPAR_GLOBAL)
      { // global

        Result  =  (void*)(&VMInstance.pGlobal[VMInstance.Value]);
      }
      else
      { // local

        Result  =  (void*)(&VMInstance.ObjectLocal[VMInstance.Value]);
      }
    }
    else
    { // constant

      if (Data & PRIMPAR_LABEL)
      { // label

        VMInstance.Value      =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);

        if ((VMInstance.Value > 0) && (VMInstance.Value < MAX_LABELS))
        {
          VMInstance.Value    =  (ULONG)VMInstance.Program[VMInstance.ProgramId].Label[VMInstance.Value].Addr;
          VMInstance.Value   -=  ((ULONG)VMInstance.ObjectIp - (ULONG)VMInstance.Program[VMInstance.ProgramId].pImage);
          Result              =  (void*)&VMInstance.Value;
        }
      }
      else
      { // value

        switch(Data & PRIMPAR_BYTES)
        {
          case PRIMPAR_STRING_OLD :
          case PRIMPAR_STRING :
          { // Zero terminated

            Result   =  (DATA8*)VMInstance.ObjectIp;
            while (*((IMGDATA*)VMInstance.ObjectIp++))
            { // Adjust Ip
            }
          }
          break;

          case PRIMPAR_1_BYTE :
          { // One byte to follow

            VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
            if (VMInstance.Value & 0x00000080)
            { // Adjust if negative

              VMInstance.Value |=  0xFFFFFF00;
            }
          }
          break;

          case PRIMPAR_2_BYTES :
          { // Two bytes to follow

            VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
            VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 8);
            if (VMInstance.Value & 0x00008000)
            { // Adjust if negative

              VMInstance.Value |=  0xFFFF0000;
            }
          }
          break;

          case PRIMPAR_4_BYTES :
          { // Four bytes to follow

            VMInstance.Value    =  (ULONG)*((IMGDATA*)VMInstance.ObjectIp++);
            VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 8);
            VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 16);
            VMInstance.Value   |=  ((ULONG)*((IMGDATA*)VMInstance.ObjectIp++)  << 24);
          }

        }
      }
    }
    if (Data & PRIMPAR_HANDLE)
    {
      VMInstance.Handle  =  *(HANDLER*)Result;
      cMemoryArraryPointer(VMInstance.ProgramId,VMInstance.Handle,&Result);
    }
    else
    {
      if (Data & PRIMPAR_ADDR)
      {
        Result  =  (void*)*(DATA32*)Result;
        VMInstance.Value  =  (DATA32)Result;
      }
    }
  }
  else
  { // short format

    if (Data & PRIMPAR_VARIABEL)
    { // variabel

      VMInstance.Value  =  (ULONG)(Data & PRIMPAR_INDEX);

      if (Data & PRIMPAR_GLOBAL)
      { // global

        Result  =  (void*)(&VMInstance.pGlobal[VMInstance.Value]);
      }
      else
      { // local

        Result  =  (void*)(&VMInstance.ObjectLocal[VMInstance.Value]);
      }
    }
    else
    { // constant

      VMInstance.Value  =  (ULONG)(Data & PRIMPAR_VALUE);

      if (Data & PRIMPAR_CONST_SIGN)
      { // Adjust if negative

        VMInstance.Value |= ~(ULONG)(PRIMPAR_VALUE);
      }
    }
  }

  return (Result);
}


void      PrimParAdvance(void)
{
  IMGDATA Data;

  Data      = *((IMGDATA*)VMInstance.ObjectIp++);

  if (Data & PRIMPAR_LONG)
  { // long format

    if (Data & PRIMPAR_VARIABEL)
    { // variabel

      switch(Data & PRIMPAR_BYTES)
      {

        case PRIMPAR_1_BYTE :
        { // One byte to follow

          VMInstance.ObjectIp++;
        }
        break;

        case PRIMPAR_2_BYTES :
        { // Two bytes to follow

          VMInstance.ObjectIp++;
          VMInstance.ObjectIp++;
        }
        break;

        case PRIMPAR_4_BYTES :
        { // Four bytes to follow

          VMInstance.ObjectIp++;
          VMInstance.ObjectIp++;
          VMInstance.ObjectIp++;
          VMInstance.ObjectIp++;
        }

      }
    }
    else
    { // constant

      if (Data & PRIMPAR_LABEL)
      { // label

        VMInstance.ObjectIp++;

      }
      else
      { // value

        switch(Data & PRIMPAR_BYTES)
        {
          case PRIMPAR_STRING_OLD :
          case PRIMPAR_STRING :
          { // Zero terminated

            while (*((IMGDATA*)VMInstance.ObjectIp++))
            { // Adjust Ip
            }
          }
          break;

          case PRIMPAR_1_BYTE :
          { // One byte to follow

            VMInstance.ObjectIp++;
          }
          break;

          case PRIMPAR_2_BYTES :
          { // Two bytes to follow

            VMInstance.ObjectIp++;
            VMInstance.ObjectIp++;
          }
          break;

          case PRIMPAR_4_BYTES :
          { // Four bytes to follow

            VMInstance.ObjectIp++;
            VMInstance.ObjectIp++;
            VMInstance.ObjectIp++;
            VMInstance.ObjectIp++;
          }

        }
      }
    }
  }
}


void      CopyParsToLocals(OBJID Id)
{
  IP      TmpIp;      // Save calling Ip
  IP      TypeIp;     // Called Ip
  void*   pLocals;    // Called locals
  PARS    NoOfPars;   // Called no of parameters
  IMGDATA Type;       // Coded type
  void*   Result;     // Pointer to value
  DATA32  Size;
  DATA8   Flag;

  TmpIp       =  VMInstance.ObjectIp;
  TypeIp      =  VMInstance.Program[VMInstance.ProgramId].pImage;
  TypeIp      =  &TypeIp[(ULONG)VMInstance.pObjHead[Id].OffsetToInstructions];
  pLocals     =  (*VMInstance.pObjList[Id]).pLocal;

  NoOfPars    =  (PARS)*((IMGDATA*)TypeIp++);

  while (NoOfPars--)
  {
    // Get type from sub preamble
    Type      =  (IMGDATA)*((IMGDATA*)TypeIp++);

    // Get pointer to value and increment VMInstance.ObjectIP

    Result    =  PrimParPointer();

    if ((Type & CALLPAR_IN))
    { // Input

      switch (Type & CALLPAR_TYPE)
      {

        case CALLPAR_DATA8 :
        {
          (*(DATA8*)pLocals)   =  *(DATA8*)Result;
          pLocals              =  ((DATA8*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATA16 :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 1) & ~1);
#endif
          (*(DATA16*)pLocals)  =  *(DATA16*)Result;
          pLocals              =  ((DATA16*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATA32 :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
          (*(DATA32*)pLocals)  =  *(DATA32*)Result;
          pLocals              =  ((DATA32*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATAF :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
          (*(DATAF*)pLocals)   =  *(DATAF*)Result;
          pLocals              =  ((DATAF*)pLocals) + 1;
        }
        break;

        case CALLPAR_STRING :
        {
          Size                 =  (DATA32)*((IMGDATA*)TypeIp++);
          Flag                 =  1;
          while (Size)
          {
            if (Flag)
            {
              Flag              =  *(DATA8*)Result;
            }
            (*(DATA8*)pLocals)  =  Flag;
            Result              =  ((DATA8*)Result) + 1;
            pLocals             =  ((DATA8*)pLocals) + 1;
            Size--;
          }
          pLocals               =  ((DATA8*)pLocals) - 1;
          (*(DATA8*)pLocals)    =  0;
          pLocals               =  ((DATA8*)pLocals) + 1;
        }
        break;

      }
    }
    else
    {
      if ((Type & CALLPAR_OUT))
      { // Output

        switch (Type & CALLPAR_TYPE)
        {

          case CALLPAR_DATA8 :
          {
            pLocals              =  ((DATA8*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATA16 :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 1) & ~1);
#endif
            pLocals              =  ((DATA16*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATA32 :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
            pLocals              =  ((DATA32*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATAF :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
            pLocals              =  ((DATAF*)pLocals) + 1;
          }
          break;

          case CALLPAR_STRING :
          {
            Size                 =  (DATA32)*((IMGDATA*)TypeIp++);
            pLocals              =  ((DATA8*)pLocals) + Size;
          }
          break;

        }
      }
    }
  }
  (*VMInstance.pObjList[Id]).Ip  =  TypeIp;

  // Rewind caller Ip
  VMInstance.ObjectIp  =  TmpIp;
}


void      CopyLocalsToPars(OBJID Id)
{
  IP      TmpIp;      // Calling Ip
  IP      TypeIp;     // Called Ip
  void*   pLocals;    // Called locals
  PARS    NoOfPars;   // Called no of parameters
  IMGDATA Type;       // Coded type
  void*   Result;     // Pointer to value
  DATA32  Size;
  DATA8   Flag;

  // Point to start of parameters
  TmpIp               =  VMInstance.ObjectIp;
  VMInstance.ObjectIp    =  (*VMInstance.pObjList[Id]).Ip;

  // Point to start of sub
  TypeIp      =  VMInstance.Program[VMInstance.ProgramId].pImage;
  TypeIp      =  &TypeIp[(ULONG)VMInstance.pObjHead[VMInstance.ObjectId].OffsetToInstructions];
  pLocals     =  (*VMInstance.pObjList[VMInstance.ObjectId]).pLocal;

  NoOfPars    =  (PARS)*((IMGDATA*)TypeIp++);

  while (NoOfPars--)
  {
    // Get type from sub preamble
    Type      =  (IMGDATA)*((IMGDATA*)TypeIp++);

    // Get pointer to value and increment VMInstance.ObjectIp
    Result    =  PrimParPointer();

    if ((Type & CALLPAR_OUT))
    { // Output

      switch (Type & CALLPAR_TYPE)
      {

        case CALLPAR_DATA8 :
        {
          *(DATA8*)Result      =  (*(DATA8*)pLocals);
          pLocals              =  ((DATA8*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATA16 :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 1) & ~1);
#endif
          *(DATA16*)Result     =  (*(DATA16*)pLocals);
          pLocals              =  ((DATA16*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATA32 :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
          *(DATA32*)Result     =  (*(DATA32*)pLocals);
          pLocals              =  ((DATA32*)pLocals) + 1;
        }
        break;

        case CALLPAR_DATAF :
        {
#ifndef DISABLE_PAR_ALIGNMENT
          pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
          *(DATAF*)Result      =  (*(DATAF*)pLocals);
          pLocals              =  ((DATAF*)pLocals) + 1;
        }
        break;

        case CALLPAR_STRING :
        {
          Size                 =  (DATA32)*((IMGDATA*)TypeIp++);
          Flag                 =  1;
          while (Size)
          {
            if (Flag)
            {
              Flag              =  (*(DATA8*)pLocals);
            }
            *(DATA8*)Result     =  Flag;
            Result              =  ((DATA8*)Result) + 1;
            pLocals             =  ((DATA8*)pLocals) + 1;
            Size--;
          }
          Result                =  ((DATA8*)Result) - 1;
          *(DATA8*)Result       =  0;
        }
        break;

      }
    }
    else
    {
      if ((Type & CALLPAR_IN))
      { // Input

        switch (Type & CALLPAR_TYPE)
        {

          case CALLPAR_DATA8 :
          {
            pLocals              =  ((DATA8*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATA16 :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 1) & ~1);
#endif
            pLocals              =  ((DATA16*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATA32 :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
            pLocals              =  ((DATA32*)pLocals) + 1;
          }
          break;

          case CALLPAR_DATAF :
          {
#ifndef DISABLE_PAR_ALIGNMENT
            pLocals  =  (void*)(((IMINDEX)pLocals + 3) & ~3);
#endif
            pLocals              =  ((DATAF*)pLocals) + 1;
          }
          break;

          case CALLPAR_STRING :
          {
            Size                 =  (DATA32)*((IMGDATA*)TypeIp++);
            pLocals              =  ((DATA8*)pLocals) + Size;
          }
          break;

        }
      }
    }
  }

  // Adjust caller Ip
  (*VMInstance.pObjList[Id]).Ip       =  VMInstance.ObjectIp;
  // Restore calling Ip
  VMInstance.ObjectIp                 =  TmpIp;
}


//*****************************************************************************
// VM routines
//*****************************************************************************

void      ObjectReset(OBJID ObjId)
{
  (*VMInstance.pObjList[ObjId]).Ip              =  &VMInstance.pImage[(ULONG)VMInstance.pObjHead[ObjId].OffsetToInstructions];

  (*VMInstance.pObjList[ObjId]).u.TriggerCount  =  VMInstance.pObjHead[ObjId].TriggerCount;
}


GBINDEX   GetAmountOfRamForImage(IP pI)
{
  GBINDEX Bytes = 0;
  OBJID   NoOfObj;
  OBJID   ObjId;
  OBJHEAD *pHead;

  NoOfObj    =  (*(IMGHEAD*)pI).NumberOfObjects;

  Bytes     +=  (*(IMGHEAD*)pI).GlobalBytes;
  Bytes      =  (Bytes + 3)  & 0xFFFFFFFC;
  Bytes     +=  sizeof(VMInstance.pObjList) * (NoOfObj + 1);

  pHead      =  (OBJHEAD*)&pI[sizeof(IMGHEAD)];

  for (ObjId = 1;ObjId <= NoOfObj;ObjId++)
  {
    Bytes    =  (Bytes + 3)  & 0xFFFFFFFC;
    Bytes   +=  sizeof(OBJ) + (*pHead).LocalBytes;
    pHead++;
  }

  Bytes      =  0;

  NoOfObj    =  (*(IMGHEAD*)pI).NumberOfObjects;

  Bytes     +=  (*(IMGHEAD*)pI).GlobalBytes;
  Bytes      =  (Bytes + 3)  & 0xFFFFFFFC;
  Bytes     +=  sizeof(VMInstance.pObjList) * (NoOfObj + 1);

  pHead      =  (OBJHEAD*)&pI[sizeof(IMGHEAD) - sizeof(OBJHEAD)];

  for (ObjId = 1;ObjId <= NoOfObj;ObjId++)
  {
    Bytes    =  (Bytes + 3)  & 0xFFFFFFFC;
    Bytes   +=  sizeof(OBJ) + pHead[ObjId].LocalBytes;
  }

  return (Bytes);
}


RESULT    ProgramReset(PRGID PrgId,IP pI,GP pG,UBYTE Deb)
{

  RESULT  Result = FAIL;
  GBINDEX Index;
  GBINDEX RamSize;
  VARDATA *pData;
  OBJID   ObjIndex;
  DATA8   No;

  VMInstance.Program[PrgId].Status          =  STOPPED;
  VMInstance.Program[PrgId].StatusChange    =  STOPPED;
  VMInstance.Program[PrgId].Result          =  FAIL;

  if (pI != NULL)
  {

    // Allocate memory for globals and objects

    RamSize       =  GetAmountOfRamForImage(pI);

    if (cMemoryOpen(PrgId,RamSize,(void**)&pData) == OK)
    { // Memory reserved

      // Save start of image
      if (Deb == 1)
      {
        VMInstance.Program[PrgId].Debug        =  1;
      }
      else
      {
        VMInstance.Program[PrgId].Debug        =  0;
      }
      VMInstance.Program[PrgId].pImage       =  pI;

      if (cValidateProgram(PrgId,pI,VMInstance.Program[PrgId].Label,VMInstance.TerminalEnabled) != OK)
      {
        if (PrgId != CMD_SLOT)
        {
          LogErrorNumber(VM_PROGRAM_VALIDATION);
        }
      }
      else
      {

        // Clear memory

        for (Index = 0;Index < RamSize;Index++)
        {
          pData[Index]  =  0;
        }

        for (No = 0;No < MAX_BREAKPOINTS;No++)
        {
          VMInstance.Program[PrgId].Brkp[No].Addr    =  0;
          VMInstance.Program[PrgId].Brkp[No].OpCode  =  0;
        }

        // Get VMInstance.Objects

        VMInstance.Program[PrgId].Objects      =  (*(IMGHEAD*)pI).NumberOfObjects;

        // Allocate GlobalVariables

        VMInstance.Program[PrgId].pData        =  pData;
        if (pG != NULL)
        {
          VMInstance.Program[PrgId].pGlobal    =  pG;
        }
        else
        {
          VMInstance.Program[PrgId].pGlobal    =  pData;
        }

        pData                       =  &pData[(*(IMGHEAD*)pI).GlobalBytes];

        // Align & allocate ObjectPointerList (+1)

        pData                       =  (VARDATA*)(((ULONG)pData + 3) & 0xFFFFFFFC);
        VMInstance.Program[PrgId].pObjList     =  (OBJ**)pData;
        pData                       =  &pData[sizeof(VMInstance.Program[PrgId].pObjList) * (VMInstance.Program[PrgId].Objects + 1)];

        // Make pointer to access object headers starting at one (not zero)

        VMInstance.Program[PrgId].pObjHead     =  (OBJHEAD*)&pI[sizeof(IMGHEAD) - sizeof(OBJHEAD)];

        for (ObjIndex = 1;ObjIndex <= VMInstance.Program[PrgId].Objects;ObjIndex++)
        {
          // Align

          pData       =  (VARDATA*)(((ULONG)pData + 3) & 0xFFFFFFFC);

          // Save object pointer in Object list

          VMInstance.Program[PrgId].pObjList[ObjIndex]   =  (OBJ*)pData;

          // Initialise instruction pointer, trigger counts and status

          (*VMInstance.Program[PrgId].pObjList[ObjIndex]).Ip              =  &pI[(ULONG)VMInstance.Program[PrgId].pObjHead[ObjIndex].OffsetToInstructions];

          (*VMInstance.Program[PrgId].pObjList[ObjIndex]).u.TriggerCount  =  VMInstance.Program[PrgId].pObjHead[ObjIndex].TriggerCount;

          if (((*VMInstance.Program[PrgId].pObjList[ObjIndex]).u.TriggerCount) || (ObjIndex > 1))
          {
            (*VMInstance.Program[PrgId].pObjList[ObjIndex]).ObjStatus     =  STOPPED;
          }
          else
          {
            if (Deb == 2)
            {
              (*VMInstance.Program[PrgId].pObjList[ObjIndex]).ObjStatus   =  WAITING;
            }
            else
            {
              (*VMInstance.Program[PrgId].pObjList[ObjIndex]).ObjStatus   =  RUNNING;
            }
          }

#ifndef DISABLE_NEW_CALL_MUTEX
          (*VMInstance.Program[PrgId].pObjList[ObjIndex]).Blocked  =  0;
#endif
          if (VMInstance.Program[PrgId].pObjHead[ObjIndex].OwnerObjectId)
          {
            (*VMInstance.Program[PrgId].pObjList[ObjIndex]).pLocal  =  (*VMInstance.Program[PrgId].pObjList[VMInstance.Program[PrgId].pObjHead[ObjIndex].OwnerObjectId]).Local;
          }
          else
          {
            (*VMInstance.Program[PrgId].pObjList[ObjIndex]).pLocal  =  (*VMInstance.Program[PrgId].pObjList[ObjIndex]).Local;
          }

          // Advance data pointer

          pData                =  &pData[sizeof(OBJ) + VMInstance.Program[PrgId].pObjHead[ObjIndex].LocalBytes];
        }

        VMInstance.Program[PrgId].ObjectId        =  1;
        VMInstance.Program[PrgId].Status          =  RUNNING;
        VMInstance.Program[PrgId].StatusChange    =  RUNNING;

        VMInstance.Program[PrgId].Result          =  BUSY;

        Result  =  OK;

        if (PrgId == USER_SLOT)
        {

          if (VMInstance.RefCount == 0)
          {
            Result     =  0;
            Result    |=  cUiOpen();
            Result    |=  cOutputOpen();
            Result    |=  cInputOpen();
            Result    |=  cComOpen();
            Result    |=  cSoundOpen();
          }
          VMInstance.RefCount++;
        }
        VMInstance.Program[PrgId].InstrCnt        =  0;
        VMInstance.Program[PrgId].StartTime       =  GetTimeMS();
        VMInstance.Program[PrgId].RunTime         =  cTimerGetuS();
      }
    }
  }

  return (Result);
}


void      ProgramEnd(PRGID PrgId)
{
  if (VMInstance.Program[PrgId].Status != STOPPED)
  {

    VMInstance.Program[PrgId].InstrTime       =  cTimerGetuS() - VMInstance.Program[PrgId].RunTime;

    VMInstance.Program[PrgId].Objects         =  0;
    VMInstance.Program[PrgId].Status          = STOPPED;
    VMInstance.Program[PrgId].StatusChange    =  STOPPED;
    if (PrgId != 0)
    {
      if (PrgId != VMInstance.ProgramId)
      {
        VMInstance.Program[PrgId].InstrCnt +=  VMInstance.InstrCnt;
      }
    }

    if (PrgId == USER_SLOT)
    {
      if (VMInstance.RefCount)
      {
        VMInstance.RefCount--;
      }
      if (VMInstance.RefCount == 0)
      {
        cSoundClose();
        cComClose();
        cInputClose();
        cOutputClose();
        cUiClose();
      }
    }

    cMemoryClose(PrgId);

    if (PrgId == VMInstance.ProgramId)
    {
      SetDispatchStatus(PRGBREAK);
    }

    VMInstance.Program[PrgId].Result          =  OK;
  }
}


void      ProgramInit(void)
{
  PRG     *pProgram;

  if (VMInstance.ProgramId < MAX_PROGRAMS)
  {
    pProgram       =  &VMInstance.Program[VMInstance.ProgramId];

    if (((*pProgram).Status == RUNNING) || ((*pProgram).Status == WAITING))
    {
      VMInstance.pGlobal        =  (*pProgram).pGlobal;
      VMInstance.pImage         =  (*pProgram).pImage;
      VMInstance.pObjHead       =  (*pProgram).pObjHead;
      VMInstance.pObjList       =  (*pProgram).pObjList;
      VMInstance.Objects        =  (*pProgram).Objects;
      VMInstance.ObjectId       =  (*pProgram).ObjectId;
      VMInstance.ObjectIp       =  (*pProgram).ObjectIp;
      VMInstance.ObjectLocal    =  (*pProgram).ObjectLocal;
      VMInstance.InstrCnt       =  0;
      VMInstance.Debug          =  (*pProgram).Debug;

    }
  }
}


void      ProgramExit(void)
{
  PRG     *pProgram;

  if (VMInstance.ProgramId < MAX_PROGRAMS)
  {
    pProgram                  =  &VMInstance.Program[VMInstance.ProgramId];
    (*pProgram).pGlobal       =  VMInstance.pGlobal;
    (*pProgram).pImage        =  VMInstance.pImage;
    (*pProgram).pObjHead      =  VMInstance.pObjHead;
    (*pProgram).pObjList      =  VMInstance.pObjList;
    (*pProgram).Objects       =  VMInstance.Objects;
    (*pProgram).ObjectId      =  VMInstance.ObjectId;
    (*pProgram).ObjectIp      =  VMInstance.ObjectIp;
    (*pProgram).ObjectLocal   =  VMInstance.ObjectLocal;
    (*pProgram).InstrCnt     +=  VMInstance.InstrCnt;
    (*pProgram).Debug         =  VMInstance.Debug;

    VMInstance.InstrCnt       =  0;
    (*pProgram).Debug         =  VMInstance.Debug;
  }
}


RESULT   ProgramExec(void)
{
  RESULT  Result = STOP;
  OBJID   TmpId  = 0;


  for (TmpId = 0;(TmpId < MAX_PROGRAMS) && (Result == STOP);TmpId++)
  {
    if (VMInstance.Program[TmpId].Status != STOPPED)
    {
      Result  =  OK;
    }
  }
  if (Result == OK)
  {
    do
    {
      // next program

      if (++VMInstance.ProgramId >= MAX_PROGRAMS)
      {
        // wrap around

        VMInstance.ProgramId  =  0;
      }

    }
    while (VMInstance.Program[VMInstance.ProgramId].Status == STOPPED);
  }


  return (Result);
}


DSPSTAT   ObjectInit(void)
{
  DSPSTAT Result = STOPBREAK;

  if ((VMInstance.ObjectId > 0) && (VMInstance.ObjectId <= VMInstance.Objects))
  { // object valid

    if ((*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus == RUNNING)
    { // Restore object context

      VMInstance.ObjectIp        =  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip;

      VMInstance.ObjectLocal     =  (*VMInstance.pObjList[VMInstance.ObjectId]).pLocal;

      Result  =  NOBREAK;
    }
  }

  if((VMInstance.ProgramId == GUI_SLOT) || (VMInstance.ProgramId == DEBUG_SLOT))
  { // UI

    VMInstance.Priority  =  UI_PRIORITY;
  }
  else
  { // user program

    VMInstance.Priority  =  PRG_PRIORITY;
  }

  return (Result);
}


void      ObjectExit(void)
{
  if ((VMInstance.ObjectId > 0) && (VMInstance.ObjectId <= VMInstance.Objects) && (VMInstance.Program[VMInstance.ProgramId].Status != STOPPED))
  { // object valid

    if ((*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus == RUNNING)
    { // Save object context

      (*VMInstance.pObjList[VMInstance.ObjectId]).Ip      =  VMInstance.ObjectIp;
    }
  }
}


RESULT    ObjectExec(void)
{
  RESULT  Result = OK;
  OBJID   TmpId  = 0;


  if ((VMInstance.ProgramId == GUI_SLOT) && (VMInstance.Program[USER_SLOT].Status != STOPPED))
  { // When user program is running - only schedule UI background task

    if ((VMInstance.Objects>= 3) && (VMInstance.Program[GUI_SLOT].Status != STOPPED))
    {
      if (VMInstance.ObjectId != 2)
      {
        VMInstance.ObjectId  =  2;
      }
      else
      {
        VMInstance.ObjectId  =  3;
      }
    }
  }
  else
  {
    do
    {
      // Next object
      if (++VMInstance.ObjectId > VMInstance.Objects)
      {
        // wrap around

        VMInstance.ObjectId  =  1;
      }

      if (++TmpId > VMInstance.Objects)
      {
        // no programs running

        Result  =  STOP;
      }

    }
    while ((Result == OK) && ((*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus != RUNNING));
  }

  return (Result);
}


void      ObjectEnQueue(OBJID Id)
{
  if ((Id > 0) && (Id <= VMInstance.Objects))
  {
    (*VMInstance.pObjList[Id]).ObjStatus        =  RUNNING;
    (*VMInstance.pObjList[Id]).Ip               = &VMInstance.pImage[(ULONG)VMInstance.pObjHead[Id].OffsetToInstructions];
    (*VMInstance.pObjList[Id]).u.TriggerCount   =  VMInstance.pObjHead[Id].TriggerCount;
  }
}


void      ObjectDeQueue(OBJID Id)
{
  if ((Id > 0) && (Id <= VMInstance.Objects))
  {
    (*VMInstance.pObjList[Id]).Ip         =  VMInstance.ObjectIp;
    (*VMInstance.pObjList[Id]).ObjStatus  =  STOPPED;

    SetDispatchStatus(STOPBREAK);
  }
}


DATA8     CheckSdcard(DATA8 *pChanged,DATA32 *pTotal,DATA32 *pFree,DATA8 Force)
{
  DATA8   Result = 0;
  DATAF   Tmp;
  char    Name[vmNAMESIZE];
  char    Buffer[250];

  *pChanged   =  0;
  *pTotal     =  0;
  *pFree      =  0;

#ifndef DISABLE_SDCARD_SUPPORT
  ULONG   Time;
  struct  statvfs Status;

  Time  =  VMInstance.NewTime - VMInstance.SdcardTimer;

  if ((Time >= UPDATE_SDCARD) || (VMInstance.SdcardTimer == 0) || (Force))
  { // Update values

    VMInstance.SdcardTimer +=  Time;

    if (cMemoryGetMediaName("m",Name) == OK)
    {
      if (VMInstance.SdcardOk == 0)
      {
        VMInstance.SdcardOk  =  1;
        snprintf(Buffer,250,"ln -s /media/card %s &> /dev/null",vmSDCARD_FOLDER);
        system(Buffer);
        sync();
        *pChanged  =  1;
#ifdef DEBUG_SDCARD
        printf("system(%s)\r\n",Buffer);
#endif
      }
      snprintf(Buffer,250,"/media/card");
      statvfs(Buffer,&Status);
#ifdef DEBUG_SDCARD
      if (*pChanged)
      {
        printf("statvfs(%s)\r\n",Buffer);

        printf("f_bsize   %ld\r\n",Status.f_bsize);
        printf("f_frsize  %ld\r\n",Status.f_frsize);
        printf("f_blocks  %ld\r\n",Status.f_blocks);
        printf("f_bavail  %ld\r\n",Status.f_bavail);
        printf("f_files   %ld\r\n",Status.f_files);
        printf("f_ffree   %ld\r\n",Status.f_ffree);
        printf("f_favail  %ld\r\n",Status.f_favail);
        printf("f_fside   %ld\r\n",Status.f_fsid);
        printf("f_flag    %ld\r\n",Status.f_flag);
        printf("f_namemax %ld\r\n",Status.f_namemax);
      }
#endif
      Tmp  =  (DATAF)Status.f_blocks;
      Tmp  =  (Tmp + (DATAF)(KB - 1)) / (DATAF)KB;
      Tmp *=  (DATAF)Status.f_bsize;
      VMInstance.SdcardSize  =  (DATA32)Tmp;
      Tmp  =  (DATAF)Status.f_bavail;
      Tmp  =  (Tmp + (DATAF)(KB - 1)) / (DATAF)KB;
      Tmp *=  (DATAF)Status.f_bsize;

#ifdef DEBUG_SDCARD
      if(VMInstance.SdcardFree != (DATA32)Tmp)
      {
        printf("%d T=%-8d F=%-8d\r\n",VMInstance.SdcardOk,VMInstance.SdcardSize,VMInstance.SdcardFree);
      }
#endif
      VMInstance.SdcardFree  =  (DATA32)Tmp;
    }
    else
    {
      if (VMInstance.SdcardOk == 1)
      {
        VMInstance.SdcardOk  =  0;
        snprintf(Buffer,250,"rm -r %s &> /dev/null",vmSDCARD_FOLDER);
        system(Buffer);
        *pChanged  =  1;
#ifdef DEBUG_SDCARD
        if (*pChanged)
        {
          printf("system(%s)\r\n",Buffer);
        }
#endif
      }
      VMInstance.SdcardSize  =  0;
      VMInstance.SdcardFree  =  0;
    }
#ifdef DEBUG_SDCARD
    if (*pChanged)
    {
      printf("%d T=%-8d F=%-8d\r\n",VMInstance.SdcardOk,VMInstance.SdcardSize,VMInstance.SdcardFree);
    }
#endif
  }
  *pTotal   =  VMInstance.SdcardSize;
  *pFree    =  VMInstance.SdcardFree;
  Result    =  VMInstance.SdcardOk;
#endif

  return (Result);
}


DATA8     CheckUsbstick(DATA8 *pChanged,DATA32 *pTotal,DATA32 *pFree,DATA8 Force)
{
  DATA8   Result = 0;

  *pChanged   =  0;
  *pTotal     =  0;
  *pFree      =  0;

#ifndef DISABLE_USBSTICK_SUPPORT
  ULONG   Time;
  struct  statvfs Status;
  DATAF   Tmp;
  char    Name[vmNAMESIZE];
  char    Buffer[250];

  Time  =  VMInstance.NewTime - VMInstance.UsbstickTimer;

  if ((Time >= UPDATE_USBSTICK) || (VMInstance.UsbstickTimer == 0) || (Force))
  { // Update values

    VMInstance.UsbstickTimer +=  Time;

    if (cMemoryGetMediaName("s",Name) == OK)
    {
      if (VMInstance.UsbstickOk == 0)
      {
        VMInstance.UsbstickOk  =  1;
        snprintf(Buffer,250,"ln -s /media/usb %s &> /dev/null",vmUSBSTICK_FOLDER);
        system(Buffer);
        sync();
        *pChanged  =  1;
#ifdef DEBUG_USBSTICK
        printf("system(%s)\r\n",Buffer);
#endif
      }
      snprintf(Buffer,250,"/media/usb");
      statvfs(Buffer,&Status);
#ifdef DEBUG_USBSTICK
      if (*pChanged)
      {
        printf("statvfs(%s)\r\n",Buffer);

        printf("f_bsize   %ld\r\n",Status.f_bsize);
        printf("f_frsize  %ld\r\n",Status.f_frsize);
        printf("f_blocks  %ld\r\n",Status.f_blocks);
        printf("f_bavail  %ld\r\n",Status.f_bavail);
        printf("f_files   %ld\r\n",Status.f_files);
        printf("f_ffree   %ld\r\n",Status.f_ffree);
        printf("f_favail  %ld\r\n",Status.f_favail);
        printf("f_fside   %ld\r\n",Status.f_fsid);
        printf("f_flag    %ld\r\n",Status.f_flag);
        printf("f_namemax %ld\r\n",Status.f_namemax);
      }
#endif
      Tmp  =  (DATAF)Status.f_blocks;
      Tmp  =  (Tmp + (DATAF)(KB - 1)) / (DATAF)KB;
      Tmp *=  (DATAF)Status.f_bsize;
      VMInstance.UsbstickSize  =  (DATA32)Tmp;
      Tmp  =  (DATAF)Status.f_bavail;
      Tmp  =  (Tmp + (DATAF)(KB - 1)) / (DATAF)KB;
      Tmp *=  (DATAF)Status.f_bsize;

#ifdef DEBUG_USBSTICK
      if(VMInstance.UsbstickFree != (DATA32)Tmp)
      {
        printf("%d T=%-8d F=%-8d\r\n",VMInstance.UsbstickOk,VMInstance.UsbstickSize,VMInstance.UsbstickFree);
      }
#endif
      VMInstance.UsbstickFree  =  (DATA32)Tmp;
    }
    else
    {
      if (VMInstance.UsbstickOk == 1)
      {
        VMInstance.UsbstickOk  =  0;
        snprintf(Buffer,250,"rm -r %s &> /dev/null",vmUSBSTICK_FOLDER);
        system(Buffer);
        *pChanged  =  1;
#ifdef DEBUG_USBSTICK
        if (*pChanged)
        {
          printf("system(%s)\r\n",Buffer);
        }
#endif
      }
      VMInstance.UsbstickSize  =  0;
      VMInstance.UsbstickFree  =  0;
    }
#ifdef DEBUG_USBSTICK
//    if (*pChanged)
    {
      printf("%d T=%-8d F=%-8d\r\n",VMInstance.UsbstickOk,VMInstance.UsbstickSize,VMInstance.UsbstickFree);
    }
#endif
  }
  *pTotal   =  VMInstance.UsbstickSize;
  *pFree    =  VMInstance.UsbstickFree;
  Result    =  VMInstance.UsbstickOk;
#endif

  return (Result);
}


RESULT    mSchedInit(int argc,char *argv[])
{
  DATA32  Result = OK;
  PRGID   PrgId;
  IMGHEAD *pImgHead;
  DATA16  Loop;
  DATA8   Ok;
  DATA32  Total;
  DATA32  Free;
  float   Tmp;
  int     File;
  char    PrgNameBuf[vmFILENAMESIZE];
  char    ParBuf[255];

#ifndef Linux_X86
  struct  timeval tv;
#endif

#ifdef ENABLE_STATUS_TEST
  VMInstance.Status  =  0x00;
#endif

#ifndef DISABLE_PREEMPTED_VM
  ANALOG  *pAdcTmp;

  VMInstance.pAnalog     =  &VMInstance.Analog;
  VMInstance.AdcFile     =  open(ANALOG_DEVICE_NAME,O_RDWR | O_SYNC);

  if (VMInstance.AdcFile >= MIN_HANDLE)
  {
    pAdcTmp  =  (ANALOG*)mmap(0, sizeof(ANALOG), PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, VMInstance.AdcFile, 0);

    if (pAdcTmp == MAP_FAILED)
    {
//#ifndef Linux_X86
      LogErrorNumber(ANALOG_SHARED_MEMORY);
//#endif
    }
    else
    {
      VMInstance.pAnalog  =  pAdcTmp;
    }
    close(VMInstance.AdcFile);
  }
  else
  {
//#ifndef Linux_X86
    LogErrorNumber(ANALOG_DEVICE_FILE_NOT_FOUND);
//#endif
  }
#endif

  // Reset time
#ifndef Linux_X86
  tv.tv_sec   =  0;
  tv.tv_usec  =  0;
  settimeofday(&tv,NULL);
#endif

  // Fill holes in PrimDispatchTabel
  for (Loop = 0;Loop < PRIMDISPATHTABLE_SIZE;Loop++)
  {
    if (PrimDispatchTabel[Loop] == NULL)
    {
      PrimDispatchTabel[Loop]  =  &Error;
    }
  }

  // Be sure necessary folders exist
  if (mkdir(vmSETTINGS_DIR,DIRPERMISSIONS) == 0)
  {
    chmod(vmSETTINGS_DIR,DIRPERMISSIONS);
  }

  CheckUsbstick(&Ok,&Total,&Free,0);
  CheckSdcard(&Ok,&Total,&Free,0);

  // Be sure necessary files exist
  Ok  =  0;
  snprintf(PrgNameBuf,vmFILENAMESIZE,"%s/%s%s",vmSETTINGS_DIR,vmWIFI_FILE_NAME,vmEXT_TEXT);
  File  =  open(PrgNameBuf,O_CREAT | O_WRONLY | O_TRUNC,SYSPERMISSIONS);
  if (File >= MIN_HANDLE)
  {
    sprintf(ParBuf,"-\t");
    write(File,ParBuf,strlen(ParBuf));
    close(File);
  }

  Ok  =  0;
  snprintf(PrgNameBuf,vmFILENAMESIZE,"%s/%s%s",vmSETTINGS_DIR,vmBLUETOOTH_FILE_NAME,vmEXT_TEXT);
  File  =  open(PrgNameBuf,O_RDONLY);
  if (File >= MIN_HANDLE)
  {
    close(File);
  }
  else
  {
    File  =  open(PrgNameBuf,O_CREAT | O_WRONLY | O_TRUNC,SYSPERMISSIONS);
    if (File >= MIN_HANDLE)
    {
      sprintf(ParBuf,"-\t");
      write(File,ParBuf,strlen(ParBuf));
      close(File);
    }
  }

  Ok  =  0;
  snprintf(PrgNameBuf,vmFILENAMESIZE,"%s/%s%s",vmSETTINGS_DIR,vmSLEEP_FILE_NAME,vmEXT_TEXT);
  File  =  open(PrgNameBuf,O_RDONLY);
  if (File >= MIN_HANDLE)
  {
    ParBuf[0]  =  0;
    read(File,ParBuf,sizeof(ParBuf));
    if (sscanf(ParBuf,"%f",&Tmp) > 0)
    {
      if ((Tmp >= (float)0) && (Tmp <= (float)127))
      {
        SetSleepMinutes((DATA8)Tmp);
        Ok  =  1;
      }
    }
    else
    {
      ParBuf[5]  =  0;
      if (strcmp(ParBuf,"never") == 0)
      {
        SetSleepMinutes(0);
        Ok  =  1;
      }
    }
    close(File);
  }
  if (!Ok)
  {
    File  =  open(PrgNameBuf,O_CREAT | O_WRONLY | O_TRUNC,SYSPERMISSIONS);
    if (File >= MIN_HANDLE)
    {
      SetSleepMinutes((DATA8)DEFAULT_SLEEPMINUTES);
      sprintf(ParBuf,"%dmin\t",DEFAULT_SLEEPMINUTES);
      write(File,ParBuf,strlen(ParBuf));
      close (File);
    }
  }

  Ok  =  0;
  snprintf(PrgNameBuf,vmFILENAMESIZE,"%s/%s%s",vmSETTINGS_DIR,vmVOLUME_FILE_NAME,vmEXT_TEXT);
  File  =  open(PrgNameBuf,O_RDONLY);
  if (File >= MIN_HANDLE)
  {
    ParBuf[0]  =  0;
    read(File,ParBuf,sizeof(ParBuf));
    if (sscanf(ParBuf,"%f",&Tmp) > 0)
    {
      if ((Tmp >= (float)0) && (Tmp <= (float)100))
      {
        SetVolumePercent((DATA8)Tmp);
        Ok  =  1;
      }
    }
    close (File);
  }
#ifdef DISABLE_SOUND
  SetVolumePercent((DATA8)0);
  File  =  open(PrgNameBuf,O_CREAT | O_WRONLY | O_TRUNC,SYSPERMISSIONS);
  if (File >= MIN_HANDLE)
  {
    sprintf(ParBuf,"%d%%\t",0);
    write(File,ParBuf,strlen(ParBuf));
    close (File);
  }
#else
  if (!Ok)
  {
    SetVolumePercent((DATA8)DEFAULT_VOLUME);
    File  =  open(PrgNameBuf,O_CREAT | O_WRONLY | O_TRUNC,SYSPERMISSIONS);
    if (File >= MIN_HANDLE)
    {
      sprintf(ParBuf,"%d%%\t",DEFAULT_VOLUME);
      write(File,ParBuf,strlen(ParBuf));
      close (File);
    }
  }
#endif

  VMInstance.RefCount  =  0;

  Result |=  cOutputInit();
  Result |=  cInputInit();
  Result |=  cUiInit();
  Result |=  cMemoryInit();
  Result |=  cComInit();
  Result |=  cSoundInit();

  cValidateInit();

  for (PrgId = 0;PrgId < MAX_PROGRAMS;PrgId++)
  {
    VMInstance.Program[PrgId].Status        =  STOPPED;
    VMInstance.Program[PrgId].StatusChange  =  0;
  }

  SetTerminalEnable(TERMINAL_ENABLED);

  VMInstance.Test         =  0;

  VmPrint("\r\n\n\n\n\n\nLMS2012 VM STARTED\r\n{\r\n");
  VMInstance.ProgramId    =  DEBUG_SLOT;
  pImgHead                =  (IMGHEAD*)UiImage;
  (*pImgHead).ImageSize   =  sizeof(UiImage);

#if (HARDWARE != SIMULATION)
  openlog(PROJECT,LOG_NDELAY,LOG_USER);
  syslog(LOG_INFO,"VM Started");

  if (argc >= 2)
  {
    snprintf((char*)VMInstance.FirstProgram,MAX_FILENAME_SIZE,"%s",argv[1]);
  }
  else
  {
    snprintf((char*)VMInstance.FirstProgram,MAX_FILENAME_SIZE,DEFAULT_UI);
  }

#else
  //TBD
#endif

  ProgramReset(VMInstance.ProgramId,UiImage,(GP)VMInstance.FirstProgram,0);

  return (RESULT)(Result);
}


RESULT    mSchedCtrl(UBYTE *pRestart)
{
  RESULT  Result   = FAIL;
  ULONG   Time;
  IP      TmpIp;
#ifdef DEBUG_TRACE_VM
  IMINDEX Index;
#endif
#ifdef DEBUG_TRACE_FREEZE
  static  ULONG   Timer;
  IMINDEX Addr;
#endif


  if (VMInstance.DispatchStatus != STOPBREAK)
  {
    ProgramInit();
  }

  SetDispatchStatus(ObjectInit());

#ifdef DEBUG_TRACE_TASK
  if (VMInstance.Program[USER_SLOT].Status != STOPPED)
  {
    printf("\r\n  %d  %2d",VMInstance.ProgramId,VMInstance.ObjectId);
  }
#endif

#ifdef ENABLE_PERFORMANCE_TEST
  Time  =  cTimerGetuS();
  Time -=  VMInstance.PerformTimer;
  VMInstance.PerformTime *=  (DATAF)199;
  VMInstance.PerformTime +=  (DATAF)Time;
  VMInstance.PerformTime /=  (DATAF)200;
#endif

/*** Execute BYTECODES *******************************************************/

#ifdef DEBUG_BYTECODE_TIME
  VMInstance.InstrCnt  =  0;
#endif

#ifndef DISABLE_PREEMPTED_VM
  (*VMInstance.pAnalog).PreemptMilliSeconds  =  0;

  while ((VMInstance.Priority) && ((*VMInstance.pAnalog).PreemptMilliSeconds < 2))
#else
  while (VMInstance.Priority)
#endif
  {
    if (VMInstance.Debug)
    {
      Monitor();
    }
    else
    {
      VMInstance.Priority--;
#ifdef DEBUG_TRACE_VM
      if (VMInstance.ProgramId != GUI_SLOT)
      {
        Index  =  (IMINDEX)VMInstance.ObjectIp - (IMINDEX)VMInstance.pImage;
        cValidateDisassemble(VMInstance.pImage,&Index,VMInstance.Program[VMInstance.ProgramId].Label);
      }
#endif
      PrimDispatchTabel[*(VMInstance.ObjectIp++)]();
      VMInstance.InstrCnt++;
#ifdef DEBUG_TRACE_TASK
      if (VMInstance.Program[USER_SLOT].Status != STOPPED)
      {
        printf(".");
      }
#endif
    }
  }

/*****************************************************************************/

#ifdef ENABLE_PERFORMANCE_TEST
  VMInstance.PerformTimer  =  cTimerGetuS();
#endif

  VMInstance.NewTime  =  GetTimeMS();

  Time  =  VMInstance.NewTime - VMInstance.OldTime1;

  if (Time >= UPDATE_TIME1)
  {
    VMInstance.OldTime1 +=  Time;

#ifdef DEBUG_BYTECODE_TIME
#ifndef DISABLE_PREEMPTED_VM
    if (Time >= 3)
    {
      printf("%-6d %-3d %-3d\r\n",Time,(*VMInstance.pAnalog).PreemptMilliSeconds,VMInstance.InstrCnt);
    }
#else
    if (Time >= 3)
    {
      printf("%-6d %-3d\r\n",Time,VMInstance.InstrCnt);
    }
#endif
#endif
    cComUpdate();
    cSoundUpdate();
  }


  Time  =  VMInstance.NewTime - VMInstance.OldTime2;

  if (Time >= UPDATE_TIME2)
  {
    VMInstance.OldTime2 +=  Time;

#ifdef DEBUG_TRACE_FREEZE

    Timer +=  Time;
    if (Timer >= 100)
    {
      Timer -=  100;
      Addr   =  (IMINDEX)VMInstance.ObjectIp - (IMINDEX)VMInstance.pImage;

      printf("%10.3f P=%-1d A=%5d \r\n",(float)VMInstance.NewTime / (float)1000,VMInstance.ProgramId,Addr);

    }
#endif
    usleep(10);
    cInputUpdate((UWORD)Time);
    cUiUpdate((UWORD)Time);

    if (VMInstance.Test)
    {
      if (VMInstance.Test > (UWORD)Time)
      {
        VMInstance.Test -=  (UWORD)Time;
      }
      else
      {
        TstClose();
      }
    }
  }

  if (VMInstance.DispatchStatus == FAILBREAK)
  {
    if (VMInstance.ProgramId != GUI_SLOT)
    {
      if (VMInstance.ProgramId != CMD_SLOT)
      {
        UiInstance.Warning |=  WARNING_DSPSTAT;
      }
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"}\r\nPROGRAM \"%d\" FAIL BREAK just before %lu!\r\n",VMInstance.ProgramId,(unsigned long)(VMInstance.ObjectIp - VMInstance.Program[VMInstance.ProgramId].pImage));
      VmPrint(VMInstance.PrintBuffer);
      ProgramEnd(VMInstance.ProgramId);
      VMInstance.Program[VMInstance.ProgramId].Result          =  FAIL;
    }
    else
    {
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"UI FAIL BREAK just before %lu!\r\n",(unsigned long)(VMInstance.ObjectIp - VMInstance.Program[VMInstance.ProgramId].pImage));
      VmPrint(VMInstance.PrintBuffer);
      LogErrorNumber(VM_INTERNAL);
      *pRestart  =  1;
    }
  }
  else
  {

    if (VMInstance.DispatchStatus == INSTRBREAK)
    {
      if (VMInstance.ProgramId != CMD_SLOT)
      {
        LogErrorNumber(VM_PROGRAM_INSTRUCTION_BREAK);
      }
      TmpIp  =  VMInstance.ObjectIp - 1;
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"\r\n%4u [%2d] ",(UWORD)(((ULONG)TmpIp) - (ULONG)VMInstance.pImage),VMInstance.ObjectId);
      VmPrint(VMInstance.PrintBuffer);
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"VM       ERROR    [0x%02X]\r\n",*TmpIp);
      VmPrint(VMInstance.PrintBuffer);
      VMInstance.Program[VMInstance.ProgramId].Result          =  FAIL;
    }

    ObjectExit();

    Result  =  ObjectExec();

    if (Result == STOP)
    {
      ProgramExit();
      ProgramEnd(VMInstance.ProgramId);
      VMInstance.DispatchStatus  =  NOBREAK;
    }
    else
    {
      if (VMInstance.DispatchStatus != STOPBREAK)
      {
        ProgramExit();
      }
    }
  }

  if (VMInstance.DispatchStatus != STOPBREAK)
  {
    Result  =  ProgramExec();
  }

  if (*pRestart == 1)
  {
    Result  =  FAIL;
  }

#ifdef Linux_X86
  usleep(1);
#endif

  return (Result);
}


RESULT    mSchedExit(void)
{
  DATA32  Result = OK;

  VmPrint("}\r\nVM STOPPED\r\n\n");

#ifndef DISABLE_SDCARD_SUPPORT
  char    SDBuffer[250];
  if (VMInstance.SdcardOk == 1)
  {
    sync();
    VMInstance.SdcardOk  =  0;
    snprintf(SDBuffer,250,"rm -r %s &> /dev/null",vmSDCARD_FOLDER);
    system(SDBuffer);
  }
#endif

#ifndef DISABLE_USBSTICK_SUPPORT
  char    USBBuffer[250];
  if (VMInstance.UsbstickOk == 1)
  {
    sync();
    VMInstance.UsbstickOk  =  0;
    snprintf(USBBuffer,250,"rm -r %s &> /dev/null",vmUSBSTICK_FOLDER);
    system(USBBuffer);
  }
#endif

  Result    |=  cValidateExit();
  Result    |=  cSoundExit();
  Result    |=  cComExit();
  Result    |=  cMemoryExit();
  Result    |=  cUiExit();
  Result    |=  cInputExit();
  Result    |=  cOutputExit();

#if (HARDWARE != SIMULATION)
  closelog();
#else
//TBD
#endif

#ifndef DISABLE_PREEMPTED_VM
  VMInstance.AdcFile     =  open(ANALOG_DEVICE_NAME,O_RDWR | O_SYNC);
  if (VMInstance.AdcFile >= MIN_HANDLE)
  {
    munmap(VMInstance.pAnalog,sizeof(ANALOG));
    close(VMInstance.AdcFile);
  }
#endif

  return (RESULT)(Result);
}


#if (HARDWARE != SIMULATION)
int       main(int argc,char *argv[])
{
  RESULT  Result = FAIL;
  UBYTE   Restart;

  do
  {
    Restart  =  0;
    Result   =  mSchedInit(argc,argv);

    if (Result == OK)
    {
      do
      {
        Result  =  mSchedCtrl(&Restart);
/*
        if ((*UiInstance.pUi).State[BACK_BUTTON] & BUTTON_LONGPRESS)
        {
          Restart  =  1;
          Result   =  FAIL;
        }
*/
      }
      while (Result == OK);

      Result  =  mSchedExit();
    }
    else
    {
//TCP      system("reboot");
    }
  }
  while (Restart);

  return ((int)Result);
}

#endif


PRIM      PrimDispatchTabel[PRIMDISPATHTABLE_SIZE] =
{
  [opERROR]               =   &Error,
  [opNOP]                 =   &Nop,
  [opPROGRAM_STOP]        =   &ProgramStop,
  [opPROGRAM_START]       =   &ProgramStart,
  [opOBJECT_STOP]         =   &ObjectStop,
  [opOBJECT_START]        =   &ObjectStart,
  [opOBJECT_TRIG]         =   &ObjectTrig,
  [opOBJECT_WAIT]         =   &ObjectWait,
  [opRETURN]              =   &ObjectReturn,
  [opCALL]                =   &ObjectCall,
  [opOBJECT_END]          =   &ObjectEnd,
  [opSLEEP]               =   &Sleep,
  [opPROGRAM_INFO]        =   &ProgramInfo,
  [opLABEL]               =   &DefLabel,
  [opPROBE]               =   &Probe,
  [opDO]                  =   &Do,
  [opADD8]                =   &cMathAdd8,
  [opADD16]               =   &cMathAdd16,
  [opADD32]               =   &cMathAdd32,
  [opADDF]                =   &cMathAddF,
  [opSUB8]                =   &cMathSub8,
  [opSUB16]               =   &cMathSub16,
  [opSUB32]               =   &cMathSub32,
  [opSUBF]                =   &cMathSubF,
  [opMUL8]                =   &cMathMul8,
  [opMUL16]               =   &cMathMul16,
  [opMUL32]               =   &cMathMul32,
  [opMULF]                =   &cMathMulF,
  [opDIV8]                =   &cMathDiv8,
  [opDIV16]               =   &cMathDiv16,
  [opDIV32]               =   &cMathDiv32,
  [opDIVF]                =   &cMathDivF,
  [opOR8]                 =   &cMathOr8,
  [opOR16]                =   &cMathOr16,
  [opOR32]                =   &cMathOr32,

  [opAND8]                =   &cMathAnd8,
  [opAND16]               =   &cMathAnd16,
  [opAND32]               =   &cMathAnd32,

  [opXOR8]                =   &cMathXor8,
  [opXOR16]               =   &cMathXor16,
  [opXOR32]               =   &cMathXor32,

  [opRL8]                 =   &cMathRl8,
  [opRL16]                =   &cMathRl16,
  [opRL32]                =   &cMathRl32,
  [opINIT_BYTES]          =   &cMoveInitBytes,
  [opMOVE8_8]             =   &cMove8to8,
  [opMOVE8_16]            =   &cMove8to16,
  [opMOVE8_32]            =   &cMove8to32,
  [opMOVE8_F]             =   &cMove8toF,
  [opMOVE16_8]            =   &cMove16to8,
  [opMOVE16_16]           =   &cMove16to16,
  [opMOVE16_32]           =   &cMove16to32,
  [opMOVE16_F]            =   &cMove16toF,
  [opMOVE32_8]            =   &cMove32to8,
  [opMOVE32_16]           =   &cMove32to16,
  [opMOVE32_32]           =   &cMove32to32,
  [opMOVE32_F]            =   &cMove32toF,
  [opMOVEF_8]             =   &cMoveFto8,
  [opMOVEF_16]            =   &cMoveFto16,
  [opMOVEF_32]            =   &cMoveFto32,
  [opMOVEF_F]             =   &cMoveFtoF,
  [opJR]                  =   &cBranchJr,
  [opJR_FALSE]            =   &cBranchJrFalse,
  [opJR_TRUE]             =   &cBranchJrTrue,
  [opJR_NAN]              =   &cBranchJrNan,
  [opCP_LT8]              =   &cCompareLt8,
  [opCP_LT16]             =   &cCompareLt16,
  [opCP_LT32]             =   &cCompareLt32,
  [opCP_LTF]              =   &cCompareLtF,
  [opCP_GT8]              =   &cCompareGt8,
  [opCP_GT16]             =   &cCompareGt16,
  [opCP_GT32]             =   &cCompareGt32,
  [opCP_GTF]              =   &cCompareGtF,
  [opCP_EQ8]              =   &cCompareEq8,
  [opCP_EQ16]             =   &cCompareEq16,
  [opCP_EQ32]             =   &cCompareEq32,
  [opCP_EQF]              =   &cCompareEqF,
  [opCP_NEQ8]             =   &cCompareNEq8,
  [opCP_NEQ16]            =   &cCompareNEq16,
  [opCP_NEQ32]            =   &cCompareNEq32,
  [opCP_NEQF]             =   &cCompareNEqF,
  [opCP_LTEQ8]            =   &cCompareLtEq8,
  [opCP_LTEQ16]           =   &cCompareLtEq16,
  [opCP_LTEQ32]           =   &cCompareLtEq32,
  [opCP_LTEQF]            =   &cCompareLtEqF,
  [opCP_GTEQ8]            =   &cCompareGtEq8,
  [opCP_GTEQ16]           =   &cCompareGtEq16,
  [opCP_GTEQ32]           =   &cCompareGtEq32,
  [opCP_GTEQF]            =   &cCompareGtEqF,
  [opSELECT8]             =   &cCompareSelect8,
  [opSELECT16]            =   &cCompareSelect16,
  [opSELECT32]            =   &cCompareSelect32,
  [opSELECTF]             =   &cCompareSelectF,
  [opSYSTEM]              =   &System,
  [opPORT_CNV_OUTPUT]     =   &PortCnvOutput,
  [opPORT_CNV_INPUT]      =   &PortCnvInput,
  [opNOTE_TO_FREQ]        =   &NoteToFreq,

  [opJR_LT8]              =   &cBranchJrLt8,
  [opJR_LT16]             =   &cBranchJrLt16,
  [opJR_LT32]             =   &cBranchJrLt32,
  [opJR_LTF]              =   &cBranchJrLtF,
  [opJR_GT8]              =   &cBranchJrGt8,
  [opJR_GT16]             =   &cBranchJrGt16,
  [opJR_GT32]             =   &cBranchJrGt32,
  [opJR_GTF]              =   &cBranchJrGtF,
  [opJR_EQ8]              =   &cBranchJrEq8,
  [opJR_EQ16]             =   &cBranchJrEq16,
  [opJR_EQ32]             =   &cBranchJrEq32,
  [opJR_EQF]              =   &cBranchJrEqF,
  [opJR_NEQ8]             =   &cBranchJrNEq8,
  [opJR_NEQ16]            =   &cBranchJrNEq16,
  [opJR_NEQ32]            =   &cBranchJrNEq32,
  [opJR_NEQF]             =   &cBranchJrNEqF,
  [opJR_LTEQ8]            =   &cBranchJrLtEq8,
  [opJR_LTEQ16]           =   &cBranchJrLtEq16,
  [opJR_LTEQ32]           =   &cBranchJrLtEq32,
  [opJR_LTEQF]            =   &cBranchJrLtEqF,
  [opJR_GTEQ8]            =   &cBranchJrGtEq8,
  [opJR_GTEQ16]           =   &cBranchJrGtEq16,
  [opJR_GTEQ32]           =   &cBranchJrGtEq32,
  [opJR_GTEQF]            =   &cBranchJrGtEqF,
  [opINFO]                =   &Info,
  [opSTRINGS]             =   &Strings,
  [opMEMORY_WRITE]        =   &MemoryWrite,
  [opMEMORY_READ]         =   &MemoryRead,
  [opUI_FLUSH]            =   &cUiFlush,
  [opUI_READ]             =   &cUiRead,
  [opUI_WRITE]            =   &cUiWrite,
  [opUI_BUTTON]           =   &cUiButton,
  [opUI_DRAW]             =   &cUiDraw,
  [opTIMER_WAIT]          =   &cTimerWait,
  [opTIMER_READY]         =   &cTimerReady,
  [opTIMER_READ]          =   &cTimerRead,
  [opBP0]                 =   &BreakPoint,
  [opBP1]                 =   &BreakPoint,
  [opBP2]                 =   &BreakPoint,
  [opBP3]                 =   &BreakPoint,
  [opBP_SET]              =   &BreakSet,
  [opMATH]                =   &cMath,
  [opRANDOM]              =   &Random,
  [opTIMER_READ_US]       =   &cTimerReaduS,
  [opKEEP_ALIVE]          =   &cUiKeepAlive,
  [opCOM_READ]            =   &cComRead,
  [opCOM_WRITE]           =   &cComWrite,
  [opSOUND]               =   &cSoundEntry,
  [opSOUND_TEST]          =   &cSoundTest,
  [opSOUND_READY]         =   &cSoundReady,
  [opINPUT_SAMPLE]        =   &cInputSample,
  [opINPUT_DEVICE_LIST]   =   &cInputDeviceList,
  [opINPUT_DEVICE]        =   &cInputDevice,
  [opINPUT_READ]          =   &cInputRead,
  [opINPUT_TEST]          =   &cInputTest,
  [opINPUT_READY]         =   &cInputReady,
  [opINPUT_READSI]        =   &cInputReadSi,
  [opINPUT_READEXT]       =   &cInputReadExt,
  [opINPUT_WRITE]         =   &cInputWrite,
  [opOUTPUT_SET_TYPE]     =   &cOutputSetType,
  [opOUTPUT_RESET]        =   &cOutputReset,
  [opOUTPUT_STOP]         =   &cOutputStop,
  [opOUTPUT_POWER]        =   &cOutputPower,
  [opOUTPUT_SPEED]        =   &cOutputSpeed,
  [opOUTPUT_START]        =   &cOutputStart,
  [opOUTPUT_POLARITY]     =   &cOutputPolarity,
  [opOUTPUT_READ]         =   &cOutputRead,
  [opOUTPUT_TEST]         =   &cOutputTest,
  [opOUTPUT_READY]        =   &cOutputReady,
  [opOUTPUT_STEP_POWER]   =   &cOutputStepPower,
  [opOUTPUT_TIME_POWER]   =   &cOutputTimePower,
  [opOUTPUT_STEP_SPEED]   =   &cOutputStepSpeed,
  [opOUTPUT_TIME_SPEED]   =   &cOutputTimeSpeed,
  [opOUTPUT_STEP_SYNC]    =   &cOutputStepSync,
  [opOUTPUT_TIME_SYNC]    =   &cOutputTimeSync,
  [opOUTPUT_CLR_COUNT]    =   &cOutputClrCount,
  [opOUTPUT_GET_COUNT]    =   &cOutputGetCount,
  [opOUTPUT_PRG_STOP]     =   &cOutputPrgStop,
  [opFILE]                =   &cMemoryFile,
  [opARRAY]               =   &cMemoryArray,
  [opARRAY_WRITE]         =   &cMemoryArrayWrite,
  [opARRAY_READ]          =   &cMemoryArrayRead,
  [opARRAY_APPEND]        =   &cMemoryArrayAppend,
  [opMEMORY_USAGE]        =   &cMemoryUsage,
  [opFILENAME]            =   &cMemoryFileName,
  [opREAD8]               =   &cMoveRead8,
  [opREAD16]              =   &cMoveRead16,
  [opREAD32]              =   &cMoveRead32,
  [opREADF]               =   &cMoveReadF,
  [opWRITE8]              =   &cMoveWrite8,
  [opWRITE16]             =   &cMoveWrite16,
  [opWRITE32]             =   &cMoveWrite32,
  [opWRITEF]              =   &cMoveWriteF,
  [opCOM_READY]           =   &cComReady,
  [opCOM_READDATA]        =   &Error,
  [opCOM_WRITEDATA]       =   &Error,
  [opCOM_GET]             =   &cComGet,
  [opCOM_SET]             =   &cComSet,
  [opCOM_TEST]            =   &cComTest,
  [opCOM_REMOVE]          =   &cComRemove,
  [opCOM_WRITEFILE]       =   &cComWriteFile,
  [opMAILBOX_OPEN]        =   &cComOpenMailBox,
  [opMAILBOX_WRITE]       =   &cComWriteMailBox,
  [opMAILBOX_READ]        =   &cComReadMailBox,
  [opMAILBOX_TEST]        =   &cComTestMailBox,
  [opMAILBOX_READY]       =   &cComReadyMailBox,
  [opMAILBOX_CLOSE]       =   &cComCloseMailBox,

  [opTST]                 =   &Tst
};

//******* BYTE CODE SNIPPETS **************************************************


void      Error(void)
{
  ProgramEnd(VMInstance.ProgramId);
  VMInstance.Program[VMInstance.ProgramId].Result          =  FAIL;
  SetDispatchStatus(INSTRBREAK);
}


void      Nop(void)
{
}


void      ProgramStop(void)
{
  DATA16  PrgId;

  PrgId    =  *(DATA16*)PrimParPointer();

  if (PrgId == GUI_SLOT)
  {
    PrgId  =  MAX_PROGRAMS;
    do
    {
      PrgId--;
      ProgramEnd(PrgId);
    }
    while (PrgId);
  }
  else
  {
    if (PrgId == CURRENT_SLOT)
    {
      PrgId  =  CurrentProgramId();
    }
    ProgramEnd(PrgId);
  }
}


void      ProgramStart(void)
{
  PRGID   PrgId;
  PRGID   TmpPrgId;
  IP      pI;
  UBYTE   DB;
  UBYTE   Flag = 0;


  PrgId  =  *(PRGID*)PrimParPointer();

  // Dummy
  pI     =  *(IP*)PrimParPointer();

  pI     =  *(IP*)PrimParPointer();
  DB     =  *(DATA8*)PrimParPointer();


  if (VMInstance.Program[PrgId].Status == STOPPED)
  {
    TmpPrgId  =  CurrentProgramId();

    if ((TmpPrgId == CMD_SLOT) || (TmpPrgId == TERM_SLOT))
    { // Direct command starting a program

      if ((VMInstance.Program[USER_SLOT].Status == STOPPED) && (VMInstance.Program[DEBUG_SLOT].Status == STOPPED))
      { // User and debug must be stooped

        if (ProgramReset(PrgId,pI,NULL,DB) == OK)
        {
          Flag  =  1;
        }
      }
    }
    else
    { // Gui, user or debug starting a program

      if (ProgramReset(PrgId,pI,NULL,DB) == OK)
      {
        Flag  =  1;
      }
    }
  }
  if (!Flag)
  {
//    LogErrorNumber(VM_PROGRAM_NOT_STARTED);
  }
}


void      ObjectStop(void)
{
  ObjectDeQueue(*(OBJID*)PrimParPointer());
}


void      ObjectStart(void)
{
  ObjectEnQueue(*(OBJID*)PrimParPointer());
}


void      ObjectTrig(void)
{
  OBJID   TmpId;

  TmpId  =  *(OBJID*)PrimParPointer();

  (*VMInstance.pObjList[TmpId]).ObjStatus  =  WAITING;
  if ((*VMInstance.pObjList[TmpId]).u.TriggerCount)
  {
    ((*VMInstance.pObjList[TmpId]).u.TriggerCount)--;
    if ((*VMInstance.pObjList[TmpId]).u.TriggerCount == 0)
    {
      ObjectReset(TmpId);
      ObjectEnQueue(TmpId);
/*
  #ifdef OLDCALL
      ObjectEnQueue(TmpId);
  #else
      (*VMInstance.pObjList[VMInstance.ObjectId]).Ip      =  VMInstance.ObjectIp;
      VMInstance.ObjectId                                 =  TmpId;
      (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus  =  RUNNING;
      VMInstance.ObjectIp        =  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip;
      VMInstance.ObjectLocal     =  (*VMInstance.pObjList[VMInstance.ObjectId]).pLocal;
  #endif
*/
    }
  }
}


void      ObjectWait(void)
{
  OBJID   TmpId;
  IP      TmpIp;

  TmpIp  =  VMInstance.ObjectIp;
  TmpId  =  *(OBJID*)PrimParPointer();

  if ((*VMInstance.pObjList[TmpId]).ObjStatus != STOPPED)
  {
    VMInstance.ObjectIp        =  TmpIp - 1;
    SetDispatchStatus(BUSYBREAK);
  }
}


void      ObjectReturn(void)
{
  OBJID   ObjectIdCaller;

  // Get caller id from saved
  ObjectIdCaller  =  (*VMInstance.pObjList[VMInstance.ObjectId]).u.CallerId;

  // Copy local variables to parameters
  VMInstance.ObjectLocal =  (*VMInstance.pObjList[ObjectIdCaller]).pLocal;
  CopyLocalsToPars(ObjectIdCaller);

  // Stop called object and start calling object
#ifdef OLDCALL
  ObjectDeQueue(VMInstance.ObjectId);
  ObjectEnQueue(ObjectIdCaller);
#else
  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip          =  VMInstance.ObjectIp;
  (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus   =  STOPPED;

#ifndef DISABLE_NEW_CALL_MUTEX
  if ((*VMInstance.pObjList[VMInstance.ObjectId]).Blocked)
  {
    (*VMInstance.pObjList[VMInstance.ObjectId]).Blocked  =  0;
    SetDispatchStatus(STOPBREAK);
  }
#endif
  VMInstance.ObjectId                                     =  ObjectIdCaller;
  (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus   =  RUNNING;
  VMInstance.ObjectIp        =  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip;
  VMInstance.ObjectLocal     =  (*VMInstance.pObjList[VMInstance.ObjectId]).pLocal;
#endif
}


void      ObjectCall(void)
{
  IP      TmpIp;
  OBJID   ObjectIdToCall;

  // Save IP in case object are locked
  TmpIp   =  GetObjectIp();

  // Get object to call from byte stream
  ObjectIdToCall  =  *(OBJID*)PrimParPointer();
  if ((*VMInstance.pObjList[ObjectIdToCall]).ObjStatus == STOPPED)
  { // Object free

    // Get number of parameters
    PrimParPointer();

    // Initialise  object
    ObjectReset(ObjectIdToCall);

    // Save mother id
    (*VMInstance.pObjList[ObjectIdToCall]).u.CallerId    =  VMInstance.ObjectId;

    // Copy parameters to local variables
    CopyParsToLocals(ObjectIdToCall);

    // Halt calling object
    (*VMInstance.pObjList[VMInstance.ObjectId]).Ip          =  VMInstance.ObjectIp;
    (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus   =  HALTED;

    // Start called object
#ifdef OLDCALL
    SetDispatchStatus(STOPBREAK);
    ObjectEnQueue(ObjectIdToCall);
#else
    VMInstance.ObjectId                                     =  ObjectIdToCall;
    (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus   =  RUNNING;
    VMInstance.ObjectIp        =  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip;
    VMInstance.ObjectLocal     =  (*VMInstance.pObjList[VMInstance.ObjectId]).pLocal;
#endif

  }
  else
  { // Object locked - rewind IP

#ifdef DEBUG
  printf("SUBCALL %u BUSY status = %u\r\n",ObjectIdToCall,(*VMInstance.pObjList[ObjectIdToCall]).ObjStatus);
#endif
    SetObjectIp(TmpIp - 1);
    SetDispatchStatus(BUSYBREAK);
#ifndef DISABLE_NEW_CALL_MUTEX
    (*VMInstance.pObjList[ObjectIdToCall]).Blocked  =  1;
#endif
  }
}


void      ObjectEnd(void)
{
  (*VMInstance.pObjList[VMInstance.ObjectId]).Ip          =  &VMInstance.Program[VMInstance.ProgramId].pImage[(ULONG)VMInstance.Program[VMInstance.ProgramId].pObjHead[VMInstance.ObjectId].OffsetToInstructions];
  (*VMInstance.pObjList[VMInstance.ObjectId]).ObjStatus   =  STOPPED;
  SetDispatchStatus(STOPBREAK);
}


void      Sleep(void)
{
  SetDispatchStatus(SLEEPBREAK);
}


void      ProgramInfo(void)
{
  DATA8   Cmd;
  DATA16  Instr;
  PRGID   PrgId;
  OBJID   ObjIndex;

  Cmd             =  *(DATA8*)PrimParPointer();
  PrgId           =  *(PRGID*)PrimParPointer();

  switch (Cmd)
  {
    case OBJ_STOP :
    {
      ObjIndex    =  *(OBJID*)PrimParPointer();
      if ((ObjIndex > 0) && (ObjIndex <= VMInstance.Program[PrgId].Objects) && (VMInstance.Program[PrgId].Status != STOPPED))
      {
        (*VMInstance.Program[PrgId].pObjList[ObjIndex]).ObjStatus  =  STOPPED;
      }
    }
    break;

    case OBJ_START :
    {
      ObjIndex    =  *(OBJID*)PrimParPointer();
      if ((ObjIndex > 0) && (ObjIndex <= VMInstance.Program[PrgId].Objects) && (VMInstance.Program[PrgId].Status != STOPPED))
      {
        if (ObjIndex == 1)
        {
          VMInstance.Program[PrgId].StartTime                           =  GetTimeMS();
          VMInstance.Program[PrgId].RunTime                             =  cTimerGetuS();
        }
        (*VMInstance.Program[PrgId].pObjList[ObjIndex]).ObjStatus       =  RUNNING;
        (*VMInstance.Program[PrgId].pObjList[ObjIndex]).Ip              = &VMInstance.Program[PrgId].pImage[(ULONG)VMInstance.Program[PrgId].pObjHead[ObjIndex].OffsetToInstructions];
        (*VMInstance.Program[PrgId].pObjList[ObjIndex]).u.TriggerCount  =  VMInstance.Program[PrgId].pObjHead[ObjIndex].TriggerCount;
      }
    }
    break;

    case GET_STATUS :
    {
      *(DATA8*)PrimParPointer()               =  (DATA8)VMInstance.Program[PrgId].Status;
    }
    break;

    case GET_PRGRESULT :
    {
      *(DATA8*)PrimParPointer()               =  (DATA8)VMInstance.Program[PrgId].Result;
    }
    break;

    case GET_SPEED :
    {
      *(DATA32*)PrimParPointer()              =  (DATA32)(((float)VMInstance.Program[PrgId].InstrCnt  * (float)1000000) / (float)VMInstance.Program[PrgId].InstrTime);
    }
    break;

    case SET_INSTR :
    {
      Instr  =  *(DATA16*)PrimParPointer();
      SetInstructions((ULONG)Instr);
    }
    break;

    default :
    {
      SetDispatchStatus(FAILBREAK);
    }
    break;

  }
}


void      DefLabel(void)
{
  PrimParPointer();
}


void      Probe(void)
{
  PRGID   PrgId;
  OBJID   ObjId;
  GBINDEX RamOffset;
  VARDATA *Ram;
  GBINDEX Size;
  GBINDEX Tmp;
  GBINDEX Lng;

  PrgId       =  *(PRGID*)PrimParPointer();
  ObjId       =  *(OBJID*)PrimParPointer();
  RamOffset   =  *(GBINDEX*)PrimParPointer();
  Size        =  *(GBINDEX*)PrimParPointer();

  if (VMInstance.Program[PrgId].Status != STOPPED)
  {
    if (ObjId == 0)
    {
      Ram  =  VMInstance.Program[PrgId].pGlobal;
      Lng  =  (*(IMGHEAD*)VMInstance.Program[PrgId].pImage).GlobalBytes;
    }
    else
    {
      Ram  =  (*VMInstance.Program[PrgId].pObjList[ObjId]).pLocal;
      Lng  =  VMInstance.Program[PrgId].pObjHead[ObjId].LocalBytes;
    }
    Ram   +=  RamOffset;
    if (Size == 0)
    {
      Size  =  Lng;
    }
    if (Size)
    {
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"    PROBE  Prg=%d Obj=%d Offs=%ld Lng=%ld\r\n    {\r\n  ",PrgId,ObjId,(long unsigned int)RamOffset,(long unsigned int)Size);
      VmPrint(VMInstance.PrintBuffer);

      for (Tmp = 0;(Tmp < Size) && (Tmp < Lng) && (Tmp < 1024);Tmp++)
      {
        if ((Tmp & 0x0F) == 0)
        {
          snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"    %08lX ",(long unsigned int)(RamOffset + (GBINDEX)Tmp));
          VmPrint(VMInstance.PrintBuffer);
        }
        snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"%02X ",(UBYTE)(*Ram & 0xFF));
        VmPrint(VMInstance.PrintBuffer);
        if (((Tmp & 0x0F) == 0xF) && (Tmp < (Size - 1)))
        {
          VmPrint("\r\n    ");
        }
        Ram++;
      }

      VmPrint("\r\n    }\r\n");
    }
  }
}


void      Do(void)
{
  DATA16  PrgId;
  DATA32  pImage;
  DATA32  pGlobal;

  PrgId       =  *(DATA16*)PrimParPointer();
  pImage      =  *(DATA32*)PrimParPointer();
  pGlobal     =  *(DATA32*)PrimParPointer();

  if (ProgramStatus(PrgId) != STOPPED)
  {
    ProgramEnd(PrgId);
  }
  if (ProgramStatus(PrgId) == STOPPED)
  {
    if (ProgramReset(PrgId,(IP)pImage,(GP)pGlobal,0) != OK)
    {
      if (PrgId != CMD_SLOT)
      {
        LogErrorNumber(VM_PROGRAM_NOT_STARTED);
      }
    }
  }
  cUiAlive();

}


void      BreakPoint(void)
{
  IP      TmpIp;
  DATA8   No;
  float   Instr;

  TmpIp   =  (--VMInstance.ObjectIp);
  No      =  *(DATA8*)TmpIp;

  if (VMInstance.Program[VMInstance.ProgramId].Brkp[No & 0x03].OpCode)
  {
    *(DATA8*)TmpIp  =  VMInstance.Program[VMInstance.ProgramId].Brkp[No & 0x03].OpCode;
  }
  else
  {
    VMInstance.ObjectIp++;
  }

  if ((No & 0x03) == 3)
  {
    cUiTestpin(1);
    cUiTestpin(0);
  }
  else
  {
    Instr  =  VMInstance.Program[VMInstance.ProgramId].InstrCnt +  VMInstance.InstrCnt;

    snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"\r\nBREAKPOINT #%d (%.0f)",No & 0x03,Instr);
    VmPrint(VMInstance.PrintBuffer);

    VMInstance.Debug  =  1;
  }
  PrimDispatchTabel[*(VMInstance.ObjectIp++)]();
  *(DATA8*)TmpIp  =  No;
}


void      BreakSet(void)
{
  PRGID   PrgId;
  DATA8   No;
  DATA32  Addr;

  PrgId   =  *(PRGID*)PrimParPointer();
  No      =  *(DATA8*)PrimParPointer();
  Addr    =  *(IMINDEX*)PrimParPointer();

  if (No < MAX_BREAKPOINTS)
  {
    if (VMInstance.Program[PrgId].Status != STOPPED)
    {
      if (Addr)
      {
        VMInstance.Program[PrgId].Brkp[No].Addr     =  Addr;
        VMInstance.Program[PrgId].Brkp[No].OpCode   =  (OP)VMInstance.Program[PrgId].pImage[Addr];
        VMInstance.Program[PrgId].pImage[Addr]      =  opBP0 + No;
      }
      else
      {
        if ((VMInstance.Program[PrgId].Brkp[No].Addr != 0) && (VMInstance.Program[PrgId].Brkp[No].OpCode != 0))
        {
          Addr  =  VMInstance.Program[PrgId].Brkp[No].Addr;
          VMInstance.Program[PrgId].pImage[Addr]  =  VMInstance.Program[PrgId].Brkp[No].OpCode;
        }
        VMInstance.Program[PrgId].Brkp[No].Addr     =  0;
        VMInstance.Program[PrgId].Brkp[No].OpCode   =  0;
      }
    }
  }
}


void      Random(void)
{
  DATA16  Min;
  DATA16  Max;
  DATA16  Result;

  Min     =  *(DATA16*)PrimParPointer();
  Max     =  *(DATA16*)PrimParPointer();

  Result  =  (DATA16)rand();

  if (Result < 0)
  {
    Result  =  0 - Result;
  }

  Result  =  (((Result * (Max - Min)) + 16383) / 32767);
  Result +=  Min;

  *(DATA16*)PrimParPointer()  =  Result;
}


void      Info(void)
{
  DATA8   Cmd;
  DATA8   Tmp;
  DATA8   Length;
  DATA8   *pDestination;
  DATA8   Number;

  Cmd           =  *(DATA8*)PrimParPointer();
  switch (Cmd)
  { // Function

    case SET_ERROR :
    {
      LogErrorNumber(*(DATA8*)PrimParPointer());
    }
    break;

    case GET_ERROR :
    {
      *(DATA8*)PrimParPointer()  =  LogErrorGet();
    }
    break;

    case ERRORTEXT :
    {
      Number          =  *(DATA8*)PrimParPointer();
      Length          =  *(DATA8*)PrimParPointer();
      pDestination    =  (DATA8*)PrimParPointer();

      if (VMInstance.Handle >= 0)
      {
        if (Number < ERRORS)
        {
          Tmp  =  (DATA8)strlen(ErrString[Number]) + 1;
        }
        else
        {
          Tmp  =  10;
        }
        if ((Length > Tmp) || (Length == -1))
        {
          Length  =  Tmp;
        }
        pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,(DATA32)Length);
      }
      if (pDestination != NULL)
      {
        *pDestination   =  0;

        if (Number)
        {
          if (Number < ERRORS)
          {
            snprintf((char*)pDestination,Length,"%s",ErrString[Number]);
          }
          else
          {
            snprintf((char*)pDestination,Length,"Number %02d",Number);
          }
        }
      }
    }
    break;

    case GET_VOLUME :
    {
      *(DATA8*)PrimParPointer()  =  GetVolumePercent();
    }
    break;

    case SET_VOLUME :
    {
      SetVolumePercent(*(DATA8*)PrimParPointer());
    }
    break;

    case GET_MINUTES :
    {
      *(DATA8*)PrimParPointer()  =  GetSleepMinutes();
    }
    break;

    case SET_MINUTES :
    {
      SetSleepMinutes(*(DATA8*)PrimParPointer());
    }
    break;

  }
}


void      Strings(void)
{
  DATA8   Cmd;
  DATA8   *pSource1;
  DATA8   *pSource2;
  DATA8   *pDestination;
  DATAF   DataF;
  DATA16  Data16;
  DATA32  Data32;
  DATA32  Start;
  DATA8   Tmp;
  DATA8   Figures;
  DATA8   Decimals;
  char    Buffer[1024];

  Cmd           =  *(DATA8*)PrimParPointer();
  switch (Cmd)
  { // Function

    case GET_SIZE :
    {
      pSource1                    =  (DATA8*)PrimParPointer();
      *(DATA16*)PrimParPointer()  =  (DATA16)strlen((char*)pSource1);
    }
    break;

    case ADD :
    {
      pSource1                    =  (DATA8*)PrimParPointer();
      pSource2                    =  (DATA8*)PrimParPointer();
      pDestination                =  (DATA8*)PrimParPointer();
      if (VMInstance.Handle >= 0)
      {
        Data32        =  (DATA32)strlen((char*)pSource1);
        Data32       +=  (DATA32)strlen((char*)pSource2);
        Data32       +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        sprintf((char*)pDestination,"%s%s",(char*)pSource1,(char*)pSource2);
      }
    }
    break;

    case COMPARE :
    {
      pSource1                    =  (DATA8*)PrimParPointer();
      pSource2                    =  (DATA8*)PrimParPointer();

      if (strcmp((char*)pSource1,(char*)pSource2) == 0)
      {
        *(DATA8*)PrimParPointer()  =  1;
      }
      else
      {
        *(DATA8*)PrimParPointer()  =  0;
      }
    }
    break;

    case DUPLICATE :
    {
      pSource1                    =  (DATA8*)PrimParPointer();
      pDestination                =  (DATA8*)PrimParPointer();
      if (VMInstance.Handle >= 0)
      {
        Data32        =  (DATA32)strlen((char*)pSource1);
        Data32       +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        strcpy((char*)pDestination,(char*)pSource1);
      }
    }
    break;

    case VALUE_TO_STRING :
    {
      DataF         =  *(DATAF*)PrimParPointer();
      Figures       =  *(DATA8*)PrimParPointer();
      Decimals      =  *(DATA8*)PrimParPointer();
      pDestination  =  (DATA8*)PrimParPointer();
      if (VMInstance.Handle >= 0)
      {
        if (Figures >= 0)
        {
          Data32        =  (DATA32)Figures;
        }
        else
        {
          Data32        =  (DATA32)(0 - Figures);
        }
        Data32       +=  2;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        if (isnan(DataF))
        {
          if (Figures < 0)
          { // "----    "
            Figures  =  0 - Figures;

            Tmp  =  0;
            while ((Tmp < 4) && (Tmp < Figures))
            {
              pDestination[Tmp]  =  '-';
              Tmp++;
            }
            while (Tmp < Figures)
            {
              pDestination[Tmp]  =  ' ';
              Tmp++;
            }
          }
          else
          { // "    ----"

            Tmp  =  0;
            while (Tmp < (Figures - 4))
            {
              pDestination[Tmp]  =  ' ';
              Tmp++;
            }
            while (Tmp < Figures)
            {
              pDestination[Tmp]  =  '-';
              Tmp++;
            }
          }
          pDestination[Tmp]  =  0;
        }
        else
        {
          if (Figures >= 0)
          {
            snprintf((char*)pDestination,Figures + 1,"%*.*f",Figures,Decimals,DataF);
          }
          else
          {
            Figures  =  0 - Figures;
            snprintf((char*)pDestination,Figures + 1,"%.*f",Decimals,DataF);
          }
          if (Decimals)
          { // Strip trailing zeroes

            Figures  =  (DATA8)strlen((char*)pDestination);

            while ((Figures) && ((pDestination[Figures] == '0') || (pDestination[Figures] == 0)))
            {
              pDestination[Figures]  =  0;
              Figures--;
            }
            if (pDestination[Figures] == '.')
            {
              pDestination[Figures]  =  0;
            }
          }
        }
      }
    }
    break;

    case NUMBER_TO_STRING :
    {
      Data16        =  *(DATA16*)PrimParPointer();
      Figures       =  *(DATA8*)PrimParPointer();
      pDestination  =  (DATA8*)PrimParPointer();
      if (VMInstance.Handle >= 0)
      {
        Data32        =  (DATA32)Figures;
        Data32       +=  2;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        snprintf((char*)pDestination,Figures + 1,"%0*d",Figures,Data16);
      }
    }
    break;

    case STRING_TO_VALUE :
    {
      pSource1    =  (DATA8*)PrimParPointer();

      Data16      =  0;
      while (pSource1[Data16])
      {
        if (pSource1[Data16] == ',')
        {
          pSource1[Data16]  =  '.';
        }
        Data16++;
      }

      sscanf((char*)pSource1,"%f",&DataF);

      *(DATAF*)PrimParPointer()  =  DataF;
    }
    break;

    case STRIP :
    {
      pSource1      =  (DATA8*)PrimParPointer();
      pDestination  =  (DATA8*)PrimParPointer();
      if (VMInstance.Handle >= 0)
      {
        Data32        =  (DATA32)strlen((char*)pSource1);
        Data32       +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        while (*pSource1)
        {
          if ((*pSource1 != ' '))
          {
            *pDestination  =  *pSource1;
            pDestination++;
          }
          pSource1++;
        }
        *pDestination  =  *pSource1;
      }
    }
    break;

    case SUB :
    {
      pSource1                    =  (DATA8*)PrimParPointer();
      pSource2                    =  (DATA8*)PrimParPointer();
      pDestination                =  (DATA8*)PrimParPointer();

      Start                       =  (DATA32)strlen((char*)pSource2);
      if (VMInstance.Handle >= 0)
      {
        Data32        =  (DATA32)strlen((char*)pSource1);
        Data32       +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
      }
      if (pDestination != NULL)
      {
        snprintf(Buffer,1024,"%s",strstr((char*)pSource1,(char*)pSource2));
        sprintf((char*)pDestination,"%s",&Buffer[(DATA16)Start]);
      }
    }
    break;

    case VALUE_FORMATTED :
    {
      DataF         =  *(DATAF*)PrimParPointer();
      pSource1      =  (DATA8*)PrimParPointer();
      Figures       =  *(DATA8*)PrimParPointer();
      pDestination  =  (DATA8*)PrimParPointer();

      snprintf(Buffer,1024,(char*)pSource1,DataF);
      if (VMInstance.Handle >= 0)
      {
        Data32      =  (DATA32)strlen((char*)Buffer);
        Data32     +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
        Figures     =  (DATA8)Data32;
      }
      if (pDestination != NULL)
      {
        snprintf((char*)pDestination,Figures,"%s",Buffer);
      }

    }
    break;

    case NUMBER_FORMATTED :
    {
      Data32        =  *(DATA32*)PrimParPointer();
      pSource1      =  (DATA8*)PrimParPointer();
      Figures       =  *(DATA8*)PrimParPointer();
      pDestination  =  (DATA8*)PrimParPointer();

      snprintf(Buffer,1024,(char*)pSource1,Data32);
      if (VMInstance.Handle >= 0)
      {
        Data32      =  (DATA32)strlen((char*)Buffer);
        Data32     +=  1;
        if (Data32 > MIN_ARRAY_ELEMENTS)
        {
          pDestination  =  (DATA8*)VmMemoryResize(VMInstance.Handle,Data32);
        }
        Figures     =  (DATA8)Data32;
      }
      if (pDestination != NULL)
      {
        snprintf((char*)pDestination,Figures,"%s",Buffer);
      }

    }
    break;

  }
}


void      MemoryWrite(void)
{
  PRGID   PrgId;
  OBJID   ObjId;
  GBINDEX Offset;
  GBINDEX Size;
  DATA8   *pArray;
  VARDATA *Ram;
  GBINDEX Tmp;
  GBINDEX Lng;

  PrgId       =  *(PRGID*)PrimParPointer();
  ObjId       =  *(OBJID*)PrimParPointer();
  Offset      =  *(GBINDEX*)PrimParPointer();
  Size        =  *(GBINDEX*)PrimParPointer();
  pArray      =   (DATA8*)PrimParPointer();

//  printf("p=%-1d o=%-2d f=%-4d s=%-4d d=0x%02X\r\n",PrgId,ObjId,Offset,Size,*pArray);

  if (PrgId < MAX_PROGRAMS)
  {
    if (VMInstance.Program[PrgId].Status != STOPPED)
    {
      if ((ObjId >= 0) && (ObjId <= VMInstance.Program[PrgId].Objects))
      {
        if (ObjId == 0)
        {
          Ram  =  VMInstance.Program[PrgId].pGlobal;
          Lng  =  (*(IMGHEAD*)VMInstance.Program[PrgId].pImage).GlobalBytes;
        }
        else
        {
          Ram  =  (*VMInstance.Program[PrgId].pObjList[ObjId]).pLocal;
          Lng  =  VMInstance.Program[PrgId].pObjHead[ObjId].LocalBytes;
        }

        for (Tmp = 0;Tmp < Size;Tmp++)
        {
          if ((Tmp + Offset) < Lng)
          {
            Ram[Tmp + Offset]  =  pArray[Tmp];
          }
        }
      }
    }
  }
}


void      MemoryRead(void)
{
  PRGID   PrgId;
  OBJID   ObjId;
  GBINDEX Offset;
  GBINDEX Size;
  DATA8   *pArray;
  VARDATA *Ram;
  GBINDEX Tmp;
  GBINDEX Lng;

  PrgId       =  *(PRGID*)PrimParPointer();
  ObjId       =  *(OBJID*)PrimParPointer();
  Offset      =  *(GBINDEX*)PrimParPointer();
  Size        =  *(GBINDEX*)PrimParPointer();
  pArray      =   (DATA8*)PrimParPointer();

  if (PrgId < MAX_PROGRAMS)
  {
    if (VMInstance.Program[PrgId].Status != STOPPED)
    {
      if ((ObjId >= 0) && (ObjId <= VMInstance.Program[PrgId].Objects))
      {
        if (ObjId == 0)
        {
          Ram  =  VMInstance.Program[PrgId].pGlobal;
          Lng  =  (*(IMGHEAD*)VMInstance.Program[PrgId].pImage).GlobalBytes;
        }
        else
        {
          Ram  =  (*VMInstance.Program[PrgId].pObjList[ObjId]).pLocal;
          Lng  =  VMInstance.Program[PrgId].pObjHead[ObjId].LocalBytes;
        }

        for (Tmp = 0;Tmp < Size;Tmp++)
        {
          if ((Tmp + Offset) < Lng)
          {
            pArray[Tmp]  =  Ram[Tmp + Offset];
          }
          else
          {
            pArray[Tmp]  =  0;
          }
        }
      }
    }
  }
}


void PortCnvOutput(void)
{
  DATA32 Ports = *(DATA32*)PrimParPointer();
  DATA32 inputPorts = Ports;
  DATA8 secondPortBitfield = (DATA8) 1 << ((inputPorts % 10) - 1);
  inputPorts /= 10;
  DATA8 firstPortBitfield = (DATA8) 1 << ((inputPorts % 10) - 1);
  inputPorts /= 10;
  DATA8 layer = (DATA8)(inputPorts % 10) - 1;
  if (layer < 0)
  {
    layer = 0;
  }
  DATA8 bitfield = firstPortBitfield | secondPortBitfield;
  *(DATA8*)PrimParPointer() = layer;
  *(DATA8*)PrimParPointer() = bitfield;
  *(DATA8*)PrimParPointer() = firstPortBitfield > secondPortBitfield;
}


void PortCnvInput(void)
{
  DATA32 inputPorts = *(DATA32*)PrimParPointer();
  DATA8 port = (DATA8) (inputPorts % 10) - 1;
  inputPorts /= 100;
  DATA8 layer = (DATA8)(inputPorts % 10) - 1;
  if (layer < 0)
  {
    layer = 0;
  }
  *(DATA8*)PrimParPointer() = layer;
  *(DATA8*)PrimParPointer() = port;
}


typedef   struct
{
  DATA8   Note[4];
  DATA16  Freq;
}
NOTEFREQ;

#define   NOTES     36

NOTEFREQ  NoteFreq[NOTES] =
{
  { "C4"  ,  262 },
  { "D4"  ,  294 },
  { "E4"  ,  330 },
  { "F4"  ,  349 },
  { "G4"  ,  392 },
  { "A4"  ,  440 },
  { "B4"  ,  494 },
  { "C5"  ,  523 },
  { "D5"  ,  587 },
  { "E5"  ,  659 },
  { "F5"  ,  698 },
  { "G5"  ,  784 },
  { "A5"  ,  880 },
  { "B5"  ,  988 },
  { "C6"  , 1047 },
  { "D6"  , 1175 },
  { "E6"  , 1319 },
  { "F6"  , 1397 },
  { "G6"  , 1568 },
  { "A6"  , 1760 },
  { "B6"  , 1976 },

  { "C#4" ,  277 },
  { "D#4" ,  311 },

  { "F#4" ,  370 },
  { "G#4" ,  415 },
  { "A#4" ,  466 },

  { "C#5" ,  554 },
  { "D#5" ,  622 },

  { "F#5" ,  740 },
  { "G#5" ,  831 },
  { "A#5" ,  932 },

  { "C#6" , 1109 },
  { "D#6" , 1245 },

  { "F#6" , 1480 },
  { "G#6" , 1661 },
  { "A#6" , 1865 }
};


void NoteToFreq(void)
{
  DATA8   *pNote;
  DATA16  Freq;
  DATA8   Note;

  Freq  =  440;

  pNote  =  (DATA8*)PrimParPointer();

  for (Note = 0;Note < NOTES;Note++)
  {
    if (strcmp((char*)NoteFreq[Note].Note,(char*)pNote) == 0)
    {
      Freq  =  NoteFreq[Note].Freq;
    }
  }

  *(DATA16*)PrimParPointer()  =  Freq;
}

#ifndef DISABLE_SYSTEM_BYTECODE

#endif
void  System(void)
{
  DATA32  Status = -1;
  DATA8   *pCmd;

  pCmd    =  (DATA8*)PrimParPointer();

#ifndef DISABLE_SYSTEM_BYTECODE
  Status  =  (DATA32)system((char*)pCmd);
#endif
  sync();

  *(DATA32*)PrimParPointer()  =  Status;
}


//*****************************************************************************

void      Monitor(void)
{
  static  ULONG SavedPriority;
  IMINDEX Index;
  LBINDEX Lv,Ln;
  OBJID   ObjId;
  OBJID   OwnerObjId;
  LP      pObjectLocal;
  char    ObjStat;
  DATA8   Esc;


  if (VMInstance.Debug == 1)
  {
    SavedPriority  =  VMInstance.Priority;

    snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"\r\n         %d %2d IP=%08lX -> ",VMInstance.ProgramId,VMInstance.ObjectId,(unsigned long)VMInstance.ObjectIp);
    VmPrint(VMInstance.PrintBuffer);

    Ln  =  16;

    for (Lv = 0;Lv < Ln;Lv++)
    {
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"%02X ",VMInstance.ObjectIp[Lv] & 0xFF);
      VmPrint(VMInstance.PrintBuffer);
      if (((Lv & 0x3) == 0x3) && ((Lv & 0xF) != 0xF))
      {
        VmPrint(" ");
      }
      if (((Lv & 0xF) == 0xF) && (Lv < (Ln - 1)))
      {
        VmPrint("\r\n");
      }
    }
    VmPrint("\r\n");

    snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"              GV=%08lX -> ",(unsigned long)VMInstance.pGlobal);
    VmPrint(VMInstance.PrintBuffer);

    Ln  =  (*(IMGHEAD*)VMInstance.pImage).GlobalBytes;

    for (Lv = 0;Lv < Ln;Lv++)
    {
      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"%02X ",VMInstance.pGlobal[Lv] & 0xFF);
      VmPrint(VMInstance.PrintBuffer);
      if (((Lv & 0x3) == 0x3) && ((Lv & 0xF) != 0xF))
      {
        VmPrint(" ");
      }
      if (((Lv & 0xF) == 0xF) && (Lv < (Ln - 1)))
      {
        VmPrint("\r\n                             ");
      }
    }
    VmPrint("\r\n");

    for (ObjId = 1;ObjId <= VMInstance.Objects;ObjId++)
    {
      switch ((*VMInstance.pObjList[ObjId]).ObjStatus)
      {
        case RUNNING :
        {
          ObjStat  =  'r';
        }
        break;

        case WAITING :
        {
          ObjStat  =  'w';
        }
        break;

        case STOPPED :
        {
          ObjStat  =  's';
        }
        break;

        case HALTED :
        {
          ObjStat  =  'h';
        }
        break;

        default :
        {
          ObjStat  =  '?';
        }
        break;

      }
      if (ObjId == VMInstance.ObjectId)
      {
        ObjStat  =  '>';
      }

      OwnerObjId      =  VMInstance.pObjHead[ObjId].OwnerObjectId;
      pObjectLocal    =  (*VMInstance.pObjList[ObjId]).pLocal;

      if (OwnerObjId)
      { // Reuse locals from owner

        Ln                       =  VMInstance.pObjHead[OwnerObjId].LocalBytes;

      }
      else
      { // Use local allocated to object

        Ln                       =  VMInstance.pObjHead[ObjId].LocalBytes;
      }



      snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"         %c %2d LV=%08lX -> ",ObjStat,ObjId,(unsigned long)pObjectLocal);
      VmPrint(VMInstance.PrintBuffer);

      for (Lv = 0;Lv < Ln;Lv++)
      {
        snprintf(VMInstance.PrintBuffer,PRINTBUFFERSIZE,"%02X ",pObjectLocal[Lv] & 0xFF);
        VmPrint(VMInstance.PrintBuffer);
        if (((Lv & 0x3) == 0x3) && ((Lv & 0xF) != 0xF))
        {
          VmPrint(" ");
        }
        if (((Lv & 0xF) == 0xF) && (Lv < (Ln - 1)))
        {
          VmPrint("\r\n                             ");
        }
      }
      VmPrint("\r\n");

    }

    VmPrint("\r\n");

    Index  =  (IMINDEX)VMInstance.ObjectIp - (IMINDEX)VMInstance.pImage;
    cValidateDisassemble(VMInstance.pImage,&Index,VMInstance.Program[VMInstance.ProgramId].Label);
    VMInstance.Debug++;
    cUiEscape();
  }
  if (VMInstance.Debug == 2)
  {
    Esc  =  cUiEscape();
    switch (Esc)
    {
      case ' ' :
      {
        VMInstance.Priority  =  SavedPriority;
        VMInstance.Priority--;
        PrimDispatchTabel[*(VMInstance.ObjectIp++)]();
        VMInstance.Debug--;
      }
      break;

      case '<' :
      {
        VMInstance.Priority  =  SavedPriority;
        VMInstance.Priority--;
        PrimDispatchTabel[*(VMInstance.ObjectIp++)]();
        VMInstance.Debug     =  0;
      }
      break;

      default :
      {
        VMInstance.Priority  =  0;
      }
      break;

    }
  }
}


RESULT    TstOpen(UWORD Time)
{
  RESULT  Result = FAIL;
  int     File;

  if ((Time > 0) && (Time <= 30000))
  {
    if (VMInstance.Test == 0)
    {
      File        =  open(TEST_PIN_DEVICE_NAME,O_RDWR | O_SYNC);
      if (File >= MIN_HANDLE)
      {
        ioctl(File,TST_PIN_ON,NULL);
        close(File);

        File        =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
        if (File >= MIN_HANDLE)
        {
          ioctl(File,TST_UART_ON,NULL);
          close(File);
          VMInstance.Test   =  Time;
          Result            =  OK;
        }
      }
    }
    else
    {
      VMInstance.Test     =  Time;
      Result              =  OK;
    }
  }

  return (Result);
}


void      TstClose(void)
{
  int     File;

  if (VMInstance.Test != 0)
  {
    File        =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
    if (File >= MIN_HANDLE)
    {
      ioctl(File,TST_UART_OFF,NULL);
      close(File);

      File        =  open(TEST_PIN_DEVICE_NAME,O_RDWR | O_SYNC);
      if (File >= MIN_HANDLE)
      {
        ioctl(File,TST_PIN_OFF,NULL);
        close(File);
        VMInstance.Test   =  0;
      }
    }
  }
}


void      Tst(void)
{
  DATA8   Cmd;
  DATA8   *pPins;
  DATA8   Index;
  DATA8   Data8;
  DATA16  Value;
  DATA8   Buffer[2];
  TSTPIN  Tstpin;
  TSTUART Tstuart;
  int     File;

  Cmd  =  *(DATA8*)PrimParPointer();

  if (Cmd == TST_OPEN)
  { // Test open

    TstOpen(10000);
  }
  else
  {
    if (VMInstance.Test)
    {
      TstOpen(10000);

      switch (Cmd)
      { // Function

        case TST_READ_PINS :
        { // Read pins

          Tstpin.Port     =  *(DATA8*)PrimParPointer();
          Tstpin.Length   =  *(DATA8*)PrimParPointer();
          pPins           =   (DATA8*)PrimParPointer();

          File            =  open(TEST_PIN_DEVICE_NAME,O_RDWR | O_SYNC);
          if (File >= 0)
          {
            ioctl(File,TST_PIN_READ,&Tstpin);
            close(File);
            for (Index = 0;Index < Tstpin.Length;Index++)
            {
              pPins[Index]  =  Tstpin.String[Index];
            }
          }
        }
        break;

        case TST_WRITE_PINS :
        { // Write to pins

          Tstpin.Port     =  *(DATA8*)PrimParPointer();
          Tstpin.Length   =  *(DATA8*)PrimParPointer();
          pPins           =   (DATA8*)PrimParPointer();

          for (Index = 0;Index < Tstpin.Length;Index++)
          {
            Tstpin.String[Index]  =  pPins[Index];
          }
          File        =  open(TEST_PIN_DEVICE_NAME,O_RDWR | O_SYNC);
          if (File >= MIN_HANDLE)
          {
            ioctl(File,TST_PIN_WRITE,&Tstpin);
            close(File);
          }

        }
        break;

        case TST_READ_ADC :
        {
          Index       =  *(DATA8*)PrimParPointer();
          Value       =  DATA16_NAN;

          if ((Index >= 0) && (Index < 4))
          {
            Value  =  (*InputInstance.pAnalog).InPin1[Index];
          }
          if ((Index >= 4) && (Index < 8))
          {
            Value  =  (*InputInstance.pAnalog).InPin6[Index - 4];
          }
          if ((Index >= 8) && (Index < 12))
          {
            Value  =  (*InputInstance.pAnalog).OutPin5[Index - 8];
          }
          if (Index == 12)
          {
            Value  =  (*InputInstance.pAnalog).BatteryTemp;
          }
          if (Index == 13)
          {
            Value  =  (*InputInstance.pAnalog).MotorCurrent;
          }
          if (Index == 14)
          {
            Value  =  (*InputInstance.pAnalog).BatteryCurrent;
          }
          if (Index == 15)
          {
            Value  =  (*InputInstance.pAnalog).Cell123456;
          }

          *(DATA16*)PrimParPointer()  =  Value;
        }
        break;

        case TST_ENABLE_UART :
        {
          Tstuart.Bitrate   =  *(DATA32*)PrimParPointer();
          File              =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
          if (File >= 0)
          {
            ioctl(File,TST_UART_EN,&Tstuart);
            close(File);
          }
        }
        break;

        case TST_DISABLE_UART :
        {
          File              =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
          if (File >= MIN_HANDLE)
          {
            ioctl(File,TST_UART_DIS,&Tstuart);
            close(File);
          }
        }
        break;

        case TST_WRITE_UART :
        {
          Tstuart.Port      =  *(DATA8*)PrimParPointer();
          Tstuart.Length    =  *(DATA8*)PrimParPointer();
          pPins             =   (DATA8*)PrimParPointer();

          if (Tstuart.Port < INPUTS)
          {
            for (Index = 0;(Index < Tstuart.Length) && (Index < TST_UART_LENGTH);Index++)
            {
              Tstuart.String[Index]  =  pPins[Index];
            }
            File        =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
            if (File >= MIN_HANDLE)
            {
              ioctl(File,TST_UART_WRITE,&Tstuart);
              close(File);
            }
          }
        }
        break;

        case TST_READ_UART :
        {
          Tstuart.Port      =  *(DATA8*)PrimParPointer();
          Tstuart.Length    =  *(DATA8*)PrimParPointer();
          pPins             =   (DATA8*)PrimParPointer();

          for (Index = 0;(Index < Tstuart.Length) && (Index < TST_UART_LENGTH);Index++)
          {
            Tstuart.String[Index]  =  0;
          }
          if (Tstuart.Port < INPUTS)
          {
            File            =  open(TEST_UART_DEVICE_NAME,O_RDWR | O_SYNC);
            if (File >= MIN_HANDLE)
            {
              ioctl(File,TST_UART_READ,&Tstuart);
              close(File);
            }
          }
          for (Index = 0;(Index < Tstuart.Length) && (Index < TST_UART_LENGTH);Index++)
          {
            pPins[Index]  =  Tstuart.String[Index];
          }
        }
        break;

        case TST_ACCU_SWITCH :
        {
          Data8  =  0;
          if (UiInstance.PowerFile >= MIN_HANDLE)
          {
            read(UiInstance.PowerFile,Buffer,2);
            if (Buffer[0] == '1')
            {
              Data8  =  1;
            }
          }
          *(DATA8*)PrimParPointer()  =  Data8;
        }
        break;

#ifndef Linux_X86
        case TST_BOOT_MODE2:
        {
          I2cStart();
        }
        break;

        case TST_POLL_MODE2:
        {
          Data8 = I2cGetBootStatus();
          *(DATA8*)PrimParPointer() = Data8;
        }
        break;

        case TST_CLOSE_MODE2:
        {
          I2cStop();
        }
        break;
#endif

        case TST_RAM_CHECK:
        {
          ULONG      RamCheckFile;
          UBYTE      RamStatus[2];

          RamCheckFile  =  open(UPDATE_DEVICE_NAME,O_RDWR);
          Data8 = FAIL;
          if (RamCheckFile >= 0)
          {
            read(RamCheckFile,RamStatus,2);
            close(RamCheckFile);

            if ((RamStatus[0] == ((UBYTE)(~(RamStatus[1])))) && (0 == RamStatus[0]))
            {
              Data8 = OK;
            }
          }
          *(DATA8*)PrimParPointer() = Data8;
        }
        break;

        default :
        { // Test close

          TstClose();
        }
        break;

      }
    }
    else
    {
      ProgramEnd(VMInstance.ProgramId);
      VMInstance.Program[VMInstance.ProgramId].Result          =  FAIL;
      SetDispatchStatus(INSTRBREAK);
    }
  }
}

#ifdef BUFPRINTSIZE

#include  <stdarg.h>

void      BufPrint(char Cmd,char *pFormat, ...)
{
  static  char Buf[BUFPRINTSIZE];
  static  ULONG BufIn = 0;
  static  char Full = 0;
  char    Format[16];
  int     FormatIn = 0;
  int     FormatOut = 0;
  char    Par = 0;
  char    Char;
#ifdef DEBUG_D_UART_ERROR
  int     File;
#endif
  va_list pArg;

  va_start(pArg,pFormat);

  switch (Cmd)
  {
    case 'p' :
    {
      if (!Full)
      {
        while ((pFormat[FormatIn]) && (BufIn < (BUFPRINTSIZE - 250)))
        {
          Char  =  pFormat[FormatIn];
          if ((Char != '%') && (Par == 0))
          {
            Buf[BufIn]  =  Char;
            BufIn++;
            FormatIn++;
          }
          else
          {
            Par                 =  1;
            Format[FormatOut]   =  Char;
            FormatOut++;
            FormatIn++;
            Format[FormatOut]   =  0;
            switch (Char)
            {
              case 'c' :
              case 'd' :
              case 'x' :
              case 'X' :
              {
                BufIn  +=  sprintf(&Buf[BufIn],"%-3d",va_arg(pArg, int));
                Par     =  0;
              }
              break;

              case 'f' :
              {
                BufIn  +=  sprintf(&Buf[BufIn],Format,va_arg(pArg, double));
                Par     =  0;
              }
              break;

              case 's' :
              {
                BufIn  +=  sprintf(&Buf[BufIn],Format,va_arg(pArg, char *));
                Par     =  0;
              }
              break;

              default :
              {

              }
              break;

            }
            if (Par == 0)
            {
              FormatOut  =  0;
            }
          }
        }
        if (BufIn >= (BUFPRINTSIZE - 250))
        {
          sprintf(&Buf[BufIn],"\r\nBUFFER FULL\r\n");
        }
      }
    }
    break;

    case 'w' :
    {
      Buf[BufIn]  =  0;
      printf("\r\n------------------------------------------------------------\r\n");
      printf("%s",Buf);
      if ((BufIn > 0) && (Buf[BufIn - 1] != '\n'))
      {
        printf("\r\n");
      }
      printf("------------------------------------------------------------\r\n\n");
      Par         =  0;
      BufIn       =  0;
      FormatOut   =  0;
      Full        =  0;

#ifdef DEBUG_D_UART_ERROR
      Buf[BufIn]  =  0;
      File  =  open(UART_DEVICE_NAME,O_RDONLY);
      if (File >= MIN_HANDLE)
      {
        read(File,Buf,BUFPRINTSIZE);
        printf("%s",Buf);

        close(File);
      }
#endif
    }
    break;

  }

  va_end(pArg);
}

#endif

/*
#define   vmCHARSET_NAME                0x01                          //!< Character set allowed in brick name and raw filenames
#define   vmCHARSET_FILENAME            0x02                          //!< Character set allowed in file names
#define   vmCHARSET_BTPASSKEY           0x04                          //!< Character set allowed in bluetooth pass key
#define   vmCHARSET_WIFIPASSKEY         0x08                          //!< Character set allowed in WiFi pass key
#define   vmCHARSET_WIFISSID            0x10                          //!< Character set allowed in WiFi ssid
*/

DATA8     ValidChars[] =
{
  0x00,   // 0x00      NUL
  0x00,   // 0x01      SOH
  0x00,   // 0x02      STX
  0x00,   // 0x03      ETX
  0x00,   // 0x04      EOT
  0x00,   // 0x05      ENQ
  0x00,   // 0x06      ACK
  0x00,   // 0x07      BEL
  0x00,   // 0x08      BS
  0x00,   // 0x09      TAB
  0x00,   // 0x0A      LF
  0x00,   // 0x0B      VT
  0x00,   // 0x0C      FF
  0x00,   // 0x0D      CR
  0x00,   // 0x0E      SO
  0x00,   // 0x0F      SI
  0x00,   // 0x10      DLE
  0x00,   // 0x11      DC1
  0x00,   // 0x12      DC2
  0x00,   // 0x13      DC3
  0x00,   // 0x14      DC4
  0x00,   // 0x15      NAK
  0x00,   // 0x16      SYN
  0x00,   // 0x17      ETB
  0x00,   // 0x18      CAN
  0x00,   // 0x19      EM
  0x00,   // 0x1A      SUB
  0x00,   // 0x1B      ESC
  0x00,   // 0x1C      FS
  0x00,   // 0x1D      GS
  0x00,   // 0x1E      RS
  0x00,   // 0x1F      US
  0x12,   // 0x20      (space)
  0x00,   // 0x21      !
  0x00,   // 0x22      "
  0x00,   // 0x23      #
  0x00,   // 0x24      $
  0x00,   // 0x25      %
  0x00,   // 0x26      &
  0x00,   // 0x27      '
  0x00,   // 0x28      (
  0x00,   // 0x29      )
  0x00,   // 0x2A      *
  0x00,   // 0x2B      +
  0x00,   // 0x2C      ,
  0x03,   // 0x2D      -
  0x02,   // 0x2E      .
  0x02,   // 0x2F      /
  0x1F,   // 0x30      0
  0x1F,   // 0x31      1
  0x1F,   // 0x32      2
  0x1F,   // 0x33      3
  0x1F,   // 0x34      4
  0x1F,   // 0x35      5
  0x1F,   // 0x36      6
  0x1F,   // 0x37      7
  0x1F,   // 0x38      8
  0x1F,   // 0x39      9
  0x00,   // 0x3A      :
  0x00,   // 0x3B      ;
  0x00,   // 0x3C      <
  0x00,   // 0x3D      =
  0x00,   // 0x3E      >
  0x00,   // 0x3F      ?
  0x00,   // 0x40      @
  0x1F,   // 0x41      A
  0x1F,   // 0x42      B
  0x1F,   // 0x43      C
  0x1F,   // 0x44      D
  0x1F,   // 0x45      E
  0x1F,   // 0x46      F
  0x1F,   // 0x47      G
  0x1F,   // 0x48      H
  0x1F,   // 0x49      I
  0x1F,   // 0x4A      J
  0x1F,   // 0x4B      K
  0x1F,   // 0x4C      L
  0x1F,   // 0x4D      M
  0x1F,   // 0x4E      N
  0x1F,   // 0x4F      O
  0x1F,   // 0x50      P
  0x1F,   // 0x51      Q
  0x1F,   // 0x52      R
  0x1F,   // 0x53      S
  0x1F,   // 0x54      T
  0x1F,   // 0x55      U
  0x1F,   // 0x56      V
  0x1F,   // 0x57      W
  0x1F,   // 0x58      X
  0x1F,   // 0x59      Y
  0x1F,   // 0x5A      Z
  0x00,   // 0x5B      [
  0x00,   // 0x5C      '\'
  0x00,   // 0x5D      ]
  0x00,   // 0x5E      ^
  0x1F,   // 0x5F      _
  0x00,   // 0x60      `
  0x1F,   // 0x61      a
  0x1F,   // 0x62      b
  0x1F,   // 0x63      c
  0x1F,   // 0x64      d
  0x1F,   // 0x65      e
  0x1F,   // 0x66      f
  0x1F,   // 0x67      g
  0x1F,   // 0x68      h
  0x1F,   // 0x69      i
  0x1F,   // 0x6A      j
  0x1F,   // 0x6B      k
  0x1F,   // 0x6C      l
  0x1F,   // 0x6D      m
  0x1F,   // 0x6E      n
  0x1F,   // 0x6F      o
  0x1F,   // 0x70      p
  0x1F,   // 0x71      q
  0x1F,   // 0x72      r
  0x1F,   // 0x73      s
  0x1F,   // 0x74      t
  0x1F,   // 0x75      u
  0x1F,   // 0x76      v
  0x1F,   // 0x77      w
  0x1F,   // 0x78      x
  0x1F,   // 0x79      y
  0x1F,   // 0x7A      z
  0x00,   // 0x7B      {
  0x00,   // 0x7C      |
  0x00,   // 0x7D      }
  0x02,   // 0x7E      ~
  0x00    // 0x7F      
};


RESULT    ValidateChar(DATA8 *pChar,DATA8 Set)
{
  RESULT  Result = OK;

  if ((ValidChars[*pChar] & Set) == 0)
  {
    *pChar  =  '_';
    Result  =  FAIL;
  }

  return (Result);
}


RESULT    ValidateString(DATA8 *pString,DATA8 Set)
{
  RESULT  Result = OK;

  while (*pString)
  {
    Result |=  ValidateChar(pString,Set);
    pString++;
  }

  return (Result);
}