plugin.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 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
 
-----------------------------------------------------------------------------
*/
 
/*
 SERIAL IO library
 First version : jully 2011
 Author : Bastien Bourineau
*/
 
#include "plugin.h"
#include "BufferedAsyncSerial.h"
#include <scolMemoryHelper.hpp>
 
#ifdef SCOL_STATIC
extern cbmachine        ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif
 
//OBJECT
int OBJSERIALSCOL;
int SERIALSCOL_NB_CB = 1;
 
//===== CB UNIT ON ===
int SCOL_SERIAL_READ_CB = 0;
int SERIAL_READ_CB;
 
int _openSIO (mmachine m)
{
  int k = 0;
  int baudRate, parity, byteSize, stopBits;
 
  int pUser = MMpull(m);
  int pCbk  = MMpull(m);
  int pSettings = MMpull(m);
  int pName = MMpull(m);
 
  //MMechostr (0, "_openSIO : start\n");
  // check IO device name
  if (pName == NIL)
  {
          MMechostr (MSKDEBUG, "\n_openSIO error : IO device name is nil...\n");
    MMset(m, 0, NIL);
          return 0;
  }
 
  std::string portnum((char*)MMstartstr(m, MTOP(pName)));
  if (pSettings == NIL)
  {
          baudRate = 9600;
          parity = 0;
          byteSize = 8;
          stopBits = 0;
  }
  else
  {
          pSettings = MTOP(pSettings);
          baudRate = MTOI(MMfetch (m, pSettings, 0));
          parity = MTOI(MMfetch (m, pSettings, 1));
          byteSize = MTOI(MMfetch (m, pSettings, 2));
          stopBits = MTOI(MMfetch (m, pSettings, 3));
  }
 
  // check reading callback
  if (pCbk == NIL)
  {
    MMechostr (0, "\n_openSIO error : reading callback is nil...\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMechostr(0, "_openSIO : new SerialIO\n");
  // launch serial connection
#ifndef ANDROID
  boost::asio::serial_port_base::character_size bsize(byteSize);
  boost::asio::serial_port_base::parity bparity = boost::asio::serial_port_base::parity((parity == 1) ? boost::asio::serial_port_base::parity::odd : (parity == 2) ? boost::asio::serial_port_base::parity::even : boost::asio::serial_port_base::parity::none);
  boost::asio::serial_port_base::stop_bits bstop = boost::asio::serial_port_base::stop_bits((stopBits == 3) ? boost::asio::serial_port_base::stop_bits::onepointfive : (parity == 2) ? boost::asio::serial_port_base::stop_bits::two : boost::asio::serial_port_base::stop_bits::one);
 
  BufferedAsyncSerial* serialObj = new BufferedAsyncSerial(portnum, baudRate, bparity, bsize, boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none), bstop);
#else
  BufferedAsyncSerial* serialObj = new BufferedAsyncSerial(portnum);
#endif
  if (serialObj == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // 
  // create scol SerialIO object
  //
  
  if ((MMpushPointer(m, serialObj) != 0))
  {
    SAFE_DELETE(serialObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  if ((k = OBJcreate(m, OBJSERIALSCOL, SCOL_PTR serialObj, NIL, 0))) return k;
        
  /* add reflex */
  if ((k = MMpush(m, pCbk)))     return k; /* reading callback */
  if ((k = MMpush(m, pUser)))    return k; /* user param       */
  if ((k = OBJaddreflex(m, OBJSERIALSCOL, SCOL_SERIAL_READ_CB))) return k;
  
  //MMechostr (0, "_openSIO : done SerialIO\n");
  return 0;
}
 
 
int _closeSIO(mmachine m) 
{
#ifdef _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"SCcloseSIO\n");
#endif
 
        int objtab = MMget(m, 0);
        if (objtab == NIL)
  {
    MMechostr(MSKDEBUG, "_closeSIO : SerialIO NIL\n");
                MMset(m, 0, NIL);
                return 0;
        }
 
  OBJdelTM(m, OBJSERIALSCOL, objtab);
        MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif
        return 0;
}
 
 
int _writeSIO(mmachine m)
{
        int s = MMpull(m);
  int objtab = MMget(m, 0);
        if ((s == NIL) || (objtab == NIL))
        {
        MMset(m, 0, NIL);
                return 0;
        }
 
  BufferedAsyncSerial* serialObj = MMgetPointer<BufferedAsyncSerial*>(m, MTOP(objtab));
  if (serialObj == 0)
  {
    MMset(m, 0, NIL);
                return 0;
  }
 
  std::string data = (char*)MMstart(m, (MTOP(s))+1);
  serialObj->writeString(data);
 
  MMset(m, 0, ITOM(0));
        return 0;
}
 
 
int getSerialReadCb(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
        int k = 0;
  BufferedAsyncSerial* serialObj = (BufferedAsyncSerial*)id;
  std::string* data = (std::string*)param;
 
  if (serialObj == 0)
  {
    delete(data);
    return 0;
  }
 
        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
  if (OBJbeginreflex(m, OBJSERIALSCOL, SCOL_PTR serialObj, SCOL_SERIAL_READ_CB))
  {
    delete(data);
    return 0;
  }
 
  int res = MMmalloc (m,((data->size()+4)>>2)+1, TYPEBUF);
  *(int*) MMstart(m, res) = data->size();
  char* BS = (char*)MMstart(m, res + 1);
  memcpy(BS, data->data(), data->size());
 
        if ((k = MMpush(m, (res<<1) + 1))) return k;
  if ((k = MMpush(m, ITOM(data->size())))) return k;
 
        k=OBJcallreflex(m, 2);
  delete(data);
        return k;
}
 
static NativeDefinition sSerialDef[] =
{
  { "_openSIO",      5,  "fun [Chn S [I I I I] fun [SerialIO u0 S I] I u0] SerialIO",    _openSIO },
  { "_closeSIO",     1,  "fun [SerialIO] I",                                             _closeSIO },
  { "_writeSIO",     2,  "fun [SerialIO S] I",                                           _writeSIO }
};
 
int destroySerialIO(mmachine m, SCOL_PTR_TYPE handsys, int objtab) 
{
  BufferedAsyncSerial* serialObj = MMgetPointer<BufferedAsyncSerial*>(m, MTOP(objtab));
        SAFE_DELETE(serialObj);
  MMsetPointer<BufferedAsyncSerial*>(m, MTOP(objtab), 0);
 
        return 0;
}
 
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadSerialIO(mmachine m)
{
  // Scol type declaration
        OBJSERIALSCOL = OBJregister(SERIALSCOL_NB_CB, 0, destroySerialIO, "SerialIO");
 
        //******************************    Callbacks for serial    *******************************************************
    
  //===== CB READ ===
  SERIAL_READ_CB = OBJgetUserEvent();
  OBJdefEvent(SERIAL_READ_CB, getSerialReadCb);
 
        // load scol functions
  int k = PKhardpak2(m, "serialIO.pkg-1.0", sizeof(sSerialDef) / sizeof(sSerialDef[0]), sSerialDef);
 
  MMechostr(MSKDEBUG,"\n" );
        return k;
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolLoadPlugin(mmachine m, cbmachine w)
{
        int k = 0;
  SCOLinitplugin(w);
        LoadSerialIO(m);
        return k;
}
 
 
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
{
        return 0;
}
#else
extern "C" SCOL_EXPORT int ScolSerialIOLoadPlugin(mmachine m, cbmachine w)
{
        int k = 0;
  SCOLinitplugin(w);
        LoadSerialIO(m);
        return k;
}
 
 
extern "C" SCOL_EXPORT int ScolSerialIOUnloadPlugin()
{
        return 0;
}
#endif //SCOL_STATIC