plugin.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2016 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
/*
 Raspberry PI GPIO library
 First version : May 2016
 Author : Bastien Bourineau
*/
 
#include "plugin.h"
#include <scolMemoryHelper.hpp>
 
#include "rpiservo.h"
#include "rpilcd.h"
#include "rpishiftdriver.h"
#include "rpipin.h"
#include "rpii2c.h"
#include "rpiPCA9685.h"
#include "rpiecho.h"
 
#ifdef RPI
  #include <unistd.h>
  #include <wiringPi.h>
#endif
 
#ifdef SCOL_STATIC
extern cbmachine ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif
 
//OBJECT
int OBJ_GPIOPIN_SCOL;
int GPIOPIN_NB_CB = 0;
int OBJ_GPIOLCD_SCOL;
int GPIOLCD_NB_CB =0;
int OBJ_GPIOSERVO_SCOL;
int GPIOSERVO_NB_CB = 0;
int OBJ_GPIOSHIFTDRIVER_SCOL;
int GPIOSHIFTDRIVER_NB_CB = 0;
int OBJ_GPIOI2C_SCOL;
int GPIOI2C_NB_CB = 0;
int OBJ_GPIOPCA9685_SCOL;
int GPIOPCA9685_NB_CB = 0;
int OBJ_GPIOECHO_SCOL;
int GPIOECHO_NB_CB = 0;
 
int _GPIOdelay(mmachine m)
{
  int iDelay = MMget(m, 0);
 
  if (iDelay == NIL)
    iDelay = 0;
  else
    iDelay = MTOI(iDelay);
 
#ifdef RPI
  delay(iDelay);
#endif
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOdelayMicroseconds(mmachine m)
{
  int iDelay = MMget(m, 0);
 
  if (iDelay == NIL)
    iDelay = 0;
  else
    iDelay = MTOI(iDelay);
 
#ifdef RPI
  delayMicroseconds(iDelay);
#endif
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _crGPIOpin(mmachine m)
{
  int iMode = MMpull(m);
  int iPin = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOpin error : channel is nil...\n");
    return 0;
  }
 
  if (iPin == NIL || iMode == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOpin error : pin or mode is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iPin = MTOI(iPin);
  iMode = MTOI(iMode);
 
  if (iMode == GPIO_CLOCK && iPin != 4)
  {
    MMechostr(MSKDEBUG, "_setGPIOpinMode error : GPIO_CLOCK is only available for pin 4...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiPin* pinobj = new RpiPin(iPin, iMode);
 
  // create
  if ((MMpushPointer(m, pinobj) != 0))
  {
    SAFE_DELETE(pinobj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOPIN_SCOL, SCOL_PTR pinobj, NIL, 0);
}
 
int _dsGPIOpin(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOpin\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOpin : ObjGpioPin is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOPIN_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _setGPIOpinPullMode (mmachine m)
{
  int iMode = MMpull(m);
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL || iMode == NIL)
  {
          MMechostr (MSKDEBUG, "_setGPIOpinPullMode error : pin object or mode is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iMode = MTOI(iMode);
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioPinObj->SetPullUpDnControl(iMode);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOdigitalWrite (mmachine m)
{
  int iVal = MMpull(m);
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOdigitalWrite error : pin object or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iVal = MTOI(iVal);
 
  if (iVal > 0)
    iVal = HIGH;
  else
    iVal = LOW;
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioPinObj->DigitalWrite(iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOdigitalRead (mmachine m)
{
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOdigitalRead error : pin object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(gpioPinObj->DigitalRead()));
  return 0;
}
 
int _GPIOanalogWrite (mmachine m)
{
  int iVal = MMpull(m);
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOanalogWrite error : pin object or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iVal = MTOI(iVal);
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioPinObj->AnalogWrite(iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOanalogRead (mmachine m)
{
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOanalogRead error : pin object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(gpioPinObj->AnalogRead()));
  return 0;
}
 
int _GPIOpwmWrite(mmachine m)
{
  int iVal = MMpull(m);
  int iPinObj = MMget(m, 0);
 
  if (iPinObj == NIL || iVal == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOpwmWrite error : pin object or value is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iVal = MTOI(iVal);
 
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(iPinObj));
  if (gpioPinObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioPinObj->PwmWrite(iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _crGPIOlcd(mmachine m)
{
  int iD7 = MMpull(m);
  int iD6 = MMpull(m);
  int iD5 = MMpull(m);
  int iD4 = MMpull(m);
  int iD3 = MMpull(m);
  int iD2 = MMpull(m);
  int iD1 = MMpull(m);
  int iD0 = MMpull(m);
  int iStrb = MMpull(m);
  int iRs = MMpull(m);
  int iBits = MMpull(m);
  int iCols = MMpull(m);
  int iRows = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOlcd error : channel is nil...\n");
    return 0;
  }
 
  if (iRows == NIL || iCols == NIL || iBits == NIL || iRs == NIL || iStrb == NIL || iD0 == NIL || iD1 == NIL || iD2 == NIL || iD4 == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOlcd error : missing parameter...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (iD7 == NIL)
    iD7 = 0;
 
  if (iD6 == NIL)
    iD6 = 0;
 
  if (iD5 == NIL)
    iD5 = 0;
 
  if (iD4 == NIL)
    iD4 = 0;
 
  RpiLCD* lcdobj = new RpiLCD(MTOI(iRows), MTOI(iCols), MTOI(iBits), MTOI(iRs), MTOI(iStrb), MTOI(iD0), MTOI(iD1), MTOI(iD2), MTOI(iD3), MTOI(iD4), MTOI(iD5), MTOI(iD6), MTOI(iD7));
 
  // create
  if ((MMpushPointer(m, lcdobj) != 0))
  {
    SAFE_DELETE(lcdobj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOLCD_SCOL, SCOL_PTR lcdobj, NIL, 0);
}
 
int _dsGPIOlcd(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOlcd\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOpin : ObjGpioLcd is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOLCD_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _GPIOlcdHome(mmachine m)
{
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdHome error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioLcdObj->Home();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdClear(mmachine m)
{
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdClear error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioLcdObj->Clear();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdDisplay(mmachine m)
{
  int iState = MMpull(m);
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdDisplay error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (iState == NIL || MTOI(iState) <= 0)
    iState = 0;
  else
    iState = 1;
 
  gpioLcdObj->DisplayState(iState);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdCursor(mmachine m)
{
  int iState = MMpull(m);
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdDisplay error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (iState == NIL || MTOI(iState) <= 0)
    iState = 0;
  else
    iState = 1;
 
  gpioLcdObj->CursorState(iState);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdCursorBlink(mmachine m)
{
  int iState = MMpull(m);
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdDisplay error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (iState == NIL || MTOI(iState) <= 0)
    iState = 0;
  else
    iState = 1;
 
  gpioLcdObj->CursorBlink(iState);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdPosition(mmachine m)
{
  int iY = MMpull(m);
  int iX = MMpull(m);
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdDisplay error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (iX == NIL || MTOI(iX) <= 0)
    iX = 0;
  else
    iX = MTOI(iX);
 
  if (iY == NIL || MTOI(iY) <= 0)
    iY = 0;
  else
    iY = MTOI(iY);
 
  gpioLcdObj->SetPosition(iX, iY);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOlcdPuts(mmachine m)
{
  int iText = MMpull(m);
  int iLcdObj = MMget(m, 0);
 
  if (iLcdObj == NIL)
  {
    MMechostr(MSKDEBUG, "_GPIOlcdDisplay error : Lcd handle is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(iLcdObj));
  if (gpioLcdObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string txtout = "";
  if (iText != NIL)
    txtout = MMstartstr(m, MTOP(iText));
 
  if (txtout.empty())
  {
    MMechostr(MSKDEBUG, "_GPIOlcdPuts error : no text to print...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioLcdObj->Puts(txtout);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int _crGPIOservo(mmachine m)
{
  int iValue = MMpull(m);
  int iPin = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOservo error : channel is nil...\n");
    return 0;
  }
 
  if (iPin == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOservo error : pin is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iPin = MTOI(iPin);
 
  float value = 90.0f;
  if (iValue != NIL)
    value = MTOF(iValue);
 
  RpiServo* servoObj = new RpiServo(iPin, value);
 
  // create
  if ((MMpushPointer(m, servoObj) != 0))
  {
    SAFE_DELETE(servoObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOSERVO_SCOL, SCOL_PTR servoObj, NIL, 0);
}
 
int _dsGPIOservo(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOservo\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOservo : ObjGpioServo is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOSERVO_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _setGPIOservoAngle(mmachine m)
{
  int iValue = MMpull(m);
  int iServoObj = MMget(m, 0);
 
  if (iServoObj == NIL)
  {
    MMechostr(MSKDEBUG, "_setGPIOservoAngle error : servo object is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value = 90.0f;
  if (iValue != NIL)
    value = MTOF(iValue);
 
  RpiServo* servoObj = MMgetPointer<RpiServo*>(m, MTOP(iServoObj));
  if (servoObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  servoObj->WriteValue(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int _crGPIOshiftDriver(mmachine m)
{
  int iNbOut = MMpull(m);
  int iLatch = MMpull(m);
  int iClock = MMpull(m);
  int iData = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOshiftDriver error : channel is nil...\n");
    return 0;
  }
 
  if ((iData == NIL) || (iClock == NIL) || (iLatch == NIL))
  {
    MMechostr(MSKDEBUG, "_crGPIOshiftDriver error : pin is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iData = MTOI(iData);
  iClock = MTOI(iClock);
  iLatch = MTOI(iLatch);
  iNbOut = (iNbOut == NIL) ? 8 : MTOI(iNbOut);
 
  RpiShiftDriver* shiftDriverObj = new RpiShiftDriver(iData, iClock, iLatch, iNbOut);
 
  // create
  if ((MMpushPointer(m, shiftDriverObj) != 0))
  {
    SAFE_DELETE(shiftDriverObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOSHIFTDRIVER_SCOL, SCOL_PTR shiftDriverObj, NIL, 0);
}
 
int _dsGPIOshiftDriver(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOservo\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOshiftDriver : ObjGpioShiftDriver is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOSHIFTDRIVER_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _setGPIOshiftDriverValues(mmachine m)
{
  int iValues = MMpull(m);
  int iShiftRegisterObj = MMget(m, 0);
 
  if (iShiftRegisterObj == NIL)
  {
    MMechostr(MSKDEBUG, "_setGPIOshiftDriverValues error : ObjGpioShiftDriver is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiShiftDriver* gpioShiftDriverObj = MMgetPointer<RpiShiftDriver*>(m, MTOP(iShiftRegisterObj));
  if (gpioShiftDriverObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::vector<RpiShiftDriver::shiftValue> values;
 
  if (iValues != NIL)
  {
    // Iterate through the recursive tuple
    int dataTuple;
    int val, tm;
    iValues = MTOP(iValues);
    while (iValues != NIL)
    {
      // Get values
      dataTuple = MTOP(MMfetch(m, iValues, 0));
      val = MTOI(MMfetch(m, dataTuple, 0));
      tm = MTOI(MMfetch(m, dataTuple, 1));
      iValues = MTOP(MMfetch(m, iValues, 1));
 
      // Add data
      values.push_back(RpiShiftDriver::shiftValue(val, tm));
    }
  }
  gpioShiftDriverObj->SetValues(values);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _crGPIOi2c(mmachine m)
{
  int iDeviceId = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOi2c error : channel is nil...\n");
    return 0;
  }
 
  if (iDeviceId == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOi2c error : Device ID is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iDeviceId = MTOI(iDeviceId);
 
  RpiI2C* pinobj = new RpiI2C(iDeviceId);
 
  // create
  if ((MMpushPointer(m, pinobj) != 0))
  {
    SAFE_DELETE(pinobj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOI2C_SCOL, SCOL_PTR pinobj, NIL, 0);
}
 
int _dsGPIOi2c(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOi2c\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOi2c : ObjGpioI2C is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOI2C_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _GPIOi2cWrite (mmachine m)
{
  int iVal = MMpull(m);
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cWrite error : I2C object or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iVal = MTOI(iVal);
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->Write(iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOi2cRead (mmachine m)
{
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cRead error : I2C object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(gpioI2CObj->Read()));
  return 0;
}
 
int _GPIOi2cWrite8 (mmachine m)
{
  int iVal = MMpull(m);
  int iReg = MMpull(m);
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cWrite8 error : I2C object or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  if (iReg == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cWrite8 error : I2C register is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iReg = MTOI(iReg);
  iVal = MTOI(iVal);
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->WriteReg8(iReg, iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOi2cRead8 (mmachine m)
{
  int iReg = MMpull(m);
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cRead8 error : I2C object object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  if (iReg == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cRead8 error : I2C register is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iReg = MTOI(iReg);
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(gpioI2CObj->ReadReg8(iReg)));
  return 0;
}
 
int _GPIOi2cWrite16 (mmachine m)
{
  int iVal = MMpull(m);
  int iReg = MMpull(m);
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cWrite16 error : I2C object or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  if (iReg == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cWrite16 error : I2C register is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iReg = MTOI(iReg);
  iVal = MTOI(iVal);
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->WriteReg16(iReg, iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOi2cRead16 (mmachine m)
{
  int iReg = MMpull(m);
  int iI2CObj = MMget(m, 0);
 
  if (iI2CObj == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cRead16 error : I2C object object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  if (iReg == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOi2cRead16 error : I2C register is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iReg = MTOI(iReg);
 
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(iI2CObj));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(gpioI2CObj->ReadReg16(iReg)));
  return 0;
}
 
int _crGPIOpca9685(mmachine m)
{
  int iFrequency = MMpull(m);
  int iPinBase = MMpull(m);
  int iDeviceId = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOpca9685 error : channel is nil...\n");
    return 0;
  }
 
  if (iDeviceId == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOpca9685 error : Device ID is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iDeviceId = MTOI(iDeviceId);
 
  if (iPinBase == NIL)
    iPinBase = 300;
  else
    iPinBase = MTOI(iPinBase);
 
  if (iFrequency == NIL)
    iFrequency = 50;
  else
    iFrequency = MTOI(iFrequency);
 
  RpiPCA9685* pca9685Obj = new RpiPCA9685(iDeviceId, iPinBase, iFrequency);
 
  // create
  if ((MMpushPointer(m, pca9685Obj) != 0))
  {
    SAFE_DELETE(pca9685Obj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOPCA9685_SCOL, SCOL_PTR pca9685Obj, NIL, 0);
}
 
int _dsGPIOpca9685(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOpca9685\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOpca9685 : ObjGpioPCA9685 is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOPCA9685_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _GPIOpca9685Write (mmachine m)
{
  int iVal = MMpull(m);
  int iPin = MMpull(m);
  int iPCA9685 = MMget(m, 0);
 
  if (iPCA9685 == NIL || iPin == NIL || iVal == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOpca9685Write error : I2C object, pin or value is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  iPin = MTOI(iPin);
  iVal = MTOI(iVal);
 
  RpiPCA9685* gpioI2CObj = MMgetPointer<RpiPCA9685*>(m, MTOP(iPCA9685));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->PwmWrite(iPin, iVal);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOpca9685Read (mmachine m)
{
  int iPin = MMpull(m);
  int iPCA9685 = MMget(m, 0);
 
  if (iPCA9685 == NIL || iPin == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOpca9685Read error : I2C object or pin is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  RpiPCA9685* gpioI2CObj = MMgetPointer<RpiPCA9685*>(m, MTOP(iPCA9685));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  iPin = MTOI(iPin);
 
  MMset(m, 0, ITOM(gpioI2CObj->PwmRead(iPin)));
  return 0;
}
 
int _GPIOpca9685Reset (mmachine m)
{
  int iPCA9685 = MMget(m, 0);
 
  if (iPCA9685 == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOpca9685Reset error : I2C object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  RpiPCA9685* gpioI2CObj = MMgetPointer<RpiPCA9685*>(m, MTOP(iPCA9685));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->Reset();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int _GPIOpca9685SetFrequency (mmachine m)
{
  int iFrequency = MMpull(m);
  int iPCA9685 = MMget(m, 0);
 
  if (iPCA9685 == NIL)
  {
          MMechostr (MSKDEBUG, "_GPIOpca9685SetFrequency error : I2C object is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  if (iFrequency == NIL)
    iFrequency = 50;
  else
    iFrequency = MTOI(iFrequency);
 
  RpiPCA9685* gpioI2CObj = MMgetPointer<RpiPCA9685*>(m, MTOP(iPCA9685));
  if (gpioI2CObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  gpioI2CObj->SetFrequency(iFrequency);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
 
int _crGPIOecho(mmachine m)
{
  int iEchoPin = MMpull(m);
  int iTriggerPin = MMpull(m);
  int chn = MMget(m, 0);
 
  if (chn == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOecho error : channel is nil...\n");
    return 0;
  }
 
  if (iTriggerPin == NIL || iEchoPin == NIL)
  {
    MMechostr(MSKDEBUG, "_crGPIOecho error : pin is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  iTriggerPin = MTOI(iTriggerPin);
  iEchoPin = MTOI(iEchoPin);
 
  RpiEcho* echoObj = new RpiEcho(iTriggerPin, iEchoPin);
 
  // create
  if ((MMpushPointer(m, echoObj) != 0))
  {
    SAFE_DELETE(echoObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJ_GPIOECHO_SCOL, SCOL_PTR echoObj, NIL, 0);
}
 
int _dsGPIOecho(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_dsGPIOecho\n");
#endif
 
  int objtab = MMget(m, 0);
  if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_dsGPIOecho : ObjGpioEcho is NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJ_GPIOECHO_SCOL, objtab);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _getGPIOechoValue(mmachine m)
{
  int iEchoObj = MMget(m, 0);
 
  if (iEchoObj == NIL)
  {
    MMechostr(MSKDEBUG, "_getGPIOechoValue error : echo object is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  RpiEcho* echoObj = MMgetPointer<RpiEcho*>(m, MTOP(iEchoObj));
  if (echoObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM((int)echoObj->ReadValue()));
  return 0;
}
 
NativeDefinition rpiGPIOEngine[] =
{
  { "ObjGpioI2C", TYPTYPE, NULL, NULL },
  { "ObjGpioPCA9685", TYPTYPE, NULL, NULL },
  { "ObjGpioShiftDriver", TYPTYPE, NULL, NULL },
  { "ObjGpioServo", TYPTYPE, NULL, NULL },
  { "ObjGpioLcd", TYPTYPE, NULL, NULL },
  { "ObjGpioPin", TYPTYPE, NULL, NULL },
  { "GPIO_DIGITAL_INPUT", TYPVAR, "I", SCOL_TYPTYPE(SOFT_DIGITAL_INPUT) },
  { "GPIO_INPUT", TYPVAR, "I", SCOL_TYPTYPE(INPUT) },
  { "GPIO_OUTPUT", TYPVAR, "I", SCOL_TYPTYPE(OUTPUT) },
  { "GPIO_CLOCK", TYPVAR, "I", SCOL_TYPTYPE(GPIO_CLOCK) },
  { "GPIO_PWM_OUTPUT", TYPVAR, "I", SCOL_TYPTYPE(PWM_OUTPUT) },
  { "GPIO_HIGH", TYPVAR, "I", SCOL_TYPTYPE(HIGH) },
  { "GPIO_LOW", TYPVAR, "I", SCOL_TYPTYPE(LOW) },
  { "GPIO_PUD_DOWN", TYPVAR, "I", SCOL_TYPTYPE(PUD_DOWN) },
  { "GPIO_PUD_UP", TYPVAR, "I", SCOL_TYPTYPE(PUD_UP) },
  { "GPIO_PUD_OFF", TYPVAR, "I", SCOL_TYPTYPE(PUD_OFF) },
  { "_GPIOdelay", 1, "fun [I] I", _GPIOdelay },
  { "_GPIOdelayMicroseconds", 1, "fun [I] I", _GPIOdelayMicroseconds },
 
  { "_crGPIOpin", 3, "fun [Chn I I] ObjGpioPin", _crGPIOpin },
  { "_dsGPIOpin", 1, "fun [ObjGpioPin] I", _dsGPIOpin },
  { "_setGPIOpinPullMode", 2, "fun [ObjGpioPin I] I", _setGPIOpinPullMode },
  { "_GPIOdigitalWrite", 2, "fun [ObjGpioPin I] I", _GPIOdigitalWrite },
  { "_GPIOdigitalRead", 1, "fun [ObjGpioPin] I", _GPIOdigitalRead },
  { "_GPIOanalogWrite", 2, "fun [ObjGpioPin I] I", _GPIOanalogWrite },
  { "_GPIOanalogRead", 1, "fun [ObjGpioPin] I", _GPIOanalogRead },
  { "_GPIOpwmWrite", 2, "fun [ObjGpioPin I] I", _GPIOpwmWrite },
 
  { "_crGPIOlcd", 14, "fun [Chn I I I I I I I I I I I I I] ObjGpioLcd", _crGPIOlcd },
  { "_dsGPIOlcd", 1, "fun [ObjGpioLcd] I", _dsGPIOlcd },
  { "_GPIOlcdHome", 1, "fun [ObjGpioLcd] I", _GPIOlcdHome },
  { "_GPIOlcdClear", 1, "fun [ObjGpioLcd] I", _GPIOlcdClear },
  { "_GPIOlcdDisplay", 2, "fun [ObjGpioLcd I] I", _GPIOlcdDisplay },
  { "_GPIOlcdCursor", 2, "fun [ObjGpioLcd I] I", _GPIOlcdCursor },
  { "_GPIOlcdCursorBlink", 2, "fun [ObjGpioLcd I] I", _GPIOlcdCursorBlink },
  { "_GPIOlcdPosition", 3, "fun [ObjGpioLcd I I] I", _GPIOlcdPosition },
  { "_GPIOlcdPuts", 2, "fun [ObjGpioLcd S] I", _GPIOlcdPuts },
 
  { "_crGPIOservo", 3, "fun [Chn I F] ObjGpioServo", _crGPIOservo },
  { "_dsGPIOservo", 1, "fun [ObjGpioServo] I", _dsGPIOservo },
  { "_setGPIOservoAngle", 2, "fun [ObjGpioServo F] I", _setGPIOservoAngle },
 
  { "_crGPIOshiftDriver", 5, "fun [Chn I I I I] ObjGpioShiftDriver", _crGPIOshiftDriver },
  { "_dsGPIOshiftDriver", 1, "fun [ObjGpioShiftDriver] I", _dsGPIOshiftDriver },
  { "_setGPIOshiftDriverValues", 2, "fun [ObjGpioShiftDriver [[I I] r1]] I", _setGPIOshiftDriverValues },
 
  { "_crGPIOi2c", 2, "fun [Chn I] ObjGpioI2C", _crGPIOi2c },
  { "_dsGPIOi2c", 1, "fun [ObjGpioI2C] I", _dsGPIOi2c },
  { "_GPIOi2cWrite", 2, "fun [ObjGpioI2C I] I", _GPIOi2cWrite },
  { "_GPIOi2cRead", 1, "fun [ObjGpioI2C] I", _GPIOi2cRead },
  { "_GPIOi2cWrite8", 3, "fun [ObjGpioI2C I I] I", _GPIOi2cWrite8 },
  { "_GPIOi2cRead8", 2, "fun [ObjGpioI2C I] I", _GPIOi2cRead8 },
  { "_GPIOi2cWrite16", 3, "fun [ObjGpioI2C I] I", _GPIOi2cWrite16 },
  { "_GPIOi2cRead16", 2, "fun [ObjGpioI2C I] I", _GPIOi2cRead16 },
 
  { "_crGPIOpca9685", 4, "fun [Chn I I I] ObjGpioPCA9685", _crGPIOpca9685 },
  { "_dsGPIOpca9685", 1, "fun [ObjGpioPCA9685] I", _dsGPIOpca9685 },
  { "_GPIOpca9685Write", 3, "fun [ObjGpioPCA9685 I I] I", _GPIOpca9685Write },
  { "_GPIOpca9685Read", 2, "fun [ObjGpioPCA9685 I] I", _GPIOpca9685Read },
  { "_GPIOpca9685Reset", 1, "fun [ObjGpioPCA9685] I", _GPIOpca9685Reset },
  { "_GPIOpca9685SetFrequency", 2, "fun [ObjGpioPCA9685 I] I", _GPIOpca9685SetFrequency },
 
  { "_crGPIOecho", 3, "fun [Chn I I] ObjGpioEcho", _crGPIOecho },
  { "_dsGPIOecho", 1, "fun [ObjGpioEcho] I", _dsGPIOecho },
  { "_getGPIOechoValue", 1, "fun [ObjGpioEcho] I", _getGPIOechoValue }
};
 
 
int destroyGPIOpin(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiPin* gpioPinObj = MMgetPointer<RpiPin*>(m, MTOP(objtab));
  SAFE_DELETE(gpioPinObj);
  MMsetPointer<RpiPin*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOlcd(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiLCD* gpioLcdObj = MMgetPointer<RpiLCD*>(m, MTOP(objtab));
  SAFE_DELETE(gpioLcdObj);
  MMsetPointer<RpiLCD*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOservo(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiServo* gpioServoObj = MMgetPointer<RpiServo*>(m, MTOP(objtab));
  SAFE_DELETE(gpioServoObj);
  MMsetPointer<RpiServo*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOshiftDriver(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiShiftDriver* gpioShiftDriverObj = MMgetPointer<RpiShiftDriver*>(m, MTOP(objtab));
  SAFE_DELETE(gpioShiftDriverObj);
  MMsetPointer<RpiServo*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOi2c(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiI2C* gpioI2CObj = MMgetPointer<RpiI2C*>(m, MTOP(objtab));
  SAFE_DELETE(gpioI2CObj);
  MMsetPointer<RpiI2C*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOpca9685(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiPCA9685* gpioPCA9685Obj = MMgetPointer<RpiPCA9685*>(m, MTOP(objtab));
  SAFE_DELETE(gpioPCA9685Obj);
  MMsetPointer<RpiPCA9685*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
int destroyGPIOecho(mmachine m, SCOL_PTR_TYPE handsys, int objtab)
{
  RpiEcho* gpioEchoObj = MMgetPointer<RpiEcho*>(m, MTOP(objtab));
  SAFE_DELETE(gpioEchoObj);
  MMsetPointer<RpiEcho*>(m, MTOP(objtab), 0);
 
  return 0;
}
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadGPIO(mmachine m)
{
        int     k;
 
#ifdef RPI
  if (getuid())
  {
    MMechostr(MSKDEBUG, "Init GPIO with sys mode, note that you need root privilieges for full support.\n");
    wiringPiSetupSys();
  }
  else
  {
    MMechostr(MSKDEBUG, "Init GPIO, with root privilieges and full support.\n");
    wiringPiSetupGpio();
  }
#endif
 
  OBJ_GPIOPIN_SCOL = OBJregister(GPIOPIN_NB_CB, 0, destroyGPIOpin, "GPIOPin");
  OBJ_GPIOLCD_SCOL = OBJregister(GPIOLCD_NB_CB, 0, destroyGPIOlcd, "GPIOLcd");
  OBJ_GPIOSERVO_SCOL = OBJregister(GPIOSERVO_NB_CB, 0, destroyGPIOservo, "GPIOServo");
  OBJ_GPIOSHIFTDRIVER_SCOL = OBJregister(GPIOSHIFTDRIVER_NB_CB, 0, destroyGPIOshiftDriver, "GPIOShiftDriver");
        OBJ_GPIOI2C_SCOL = OBJregister(GPIOI2C_NB_CB, 0, destroyGPIOi2c, "GPIOI2C");
  OBJ_GPIOPCA9685_SCOL = OBJregister(GPIOPCA9685_NB_CB, 0, destroyGPIOpca9685, "GPIOPca9685");
  OBJ_GPIOECHO_SCOL = OBJregister(GPIOECHO_NB_CB, 0, destroyGPIOecho, "GPIOecho");
 
  k = PKhardpak2(m, "RPIGPIO.pkg", sizeof(rpiGPIOEngine) / sizeof(rpiGPIOEngine[0]), rpiGPIOEngine);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
        return k;
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolLoadPlugin(mmachine m, cbmachine w)
#else
extern "C" SCOL_EXPORT int ScolGPIOLoadPlugin(mmachine m, cbmachine w)
#endif
{
        int k = 0;
  SCOLinitplugin(w);
        LoadGPIO(m);
        return k;
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
#else
extern "C" SCOL_EXPORT int ScolGPIOUnloadPlugin()
#endif
{
        return 0;
}