From 45ab288c8256f2787e7bf694c7a48888592be4cd Mon Sep 17 00:00:00 2001
From: Barattero Laurent <laurent@larueluberlu.net>
Date: Sat, 18 Jan 2014 10:24:55 +0100
Subject: first commit release 0.2
---
src/Makefile.am | 28 +++
src/buffer.cpp | 173 ++++++++++++++++++
src/buffer.hpp | 74 ++++++++
src/buffermanager.cpp | 384 ++++++++++++++++++++++++++++++++++++++++
src/buffermanager.hpp | 105 +++++++++++
src/config.h.in | 91 ++++++++++
src/define_ultimate_fct.h | 50 ++++++
src/gloInterface.hpp | 63 +++++++
src/global.hpp | 42 +++++
src/gloseq.cpp | 238 +++++++++++++++++++++++++
src/gloseq.hpp | 99 +++++++++++
src/main.cpp | 269 ++++++++++++++++++++++++++++
src/main.hpp | 50 ++++++
src/optmanager.cpp | 438 ++++++++++++++++++++++++++++++++++++++++++++++
src/optmanager.hpp | 141 +++++++++++++++
src/regboost.cpp | 62 +++++++
src/regboost.hpp | 72 ++++++++
src/reglinux.cpp | 97 ++++++++++
src/reglinux.hpp | 80 +++++++++
src/rules.cpp | 198 +++++++++++++++++++++
src/rules.hpp | 94 ++++++++++
src/ruleserror.hpp | 81 +++++++++
src/serialboost.cpp | 200 +++++++++++++++++++++
src/serialboost.hpp | 69 ++++++++
src/seriallinux.cpp | 136 ++++++++++++++
src/seriallinux.hpp | 66 +++++++
src/serialprop.cpp | 70 ++++++++
src/serialprop.hpp | 77 ++++++++
src/ultimate.cpp | 137 +++++++++++++++
src/ultimate.hpp | 66 +++++++
30 files changed, 3750 insertions(+)
create mode 100644 src/Makefile.am
create mode 100644 src/buffer.cpp
create mode 100644 src/buffer.hpp
create mode 100644 src/buffermanager.cpp
create mode 100644 src/buffermanager.hpp
create mode 100644 src/config.h.in
create mode 100644 src/define_ultimate_fct.h
create mode 100644 src/gloInterface.hpp
create mode 100644 src/global.hpp
create mode 100644 src/gloseq.cpp
create mode 100644 src/gloseq.hpp
create mode 100644 src/main.cpp
create mode 100644 src/main.hpp
create mode 100644 src/optmanager.cpp
create mode 100644 src/optmanager.hpp
create mode 100644 src/regboost.cpp
create mode 100644 src/regboost.hpp
create mode 100644 src/reglinux.cpp
create mode 100644 src/reglinux.hpp
create mode 100644 src/rules.cpp
create mode 100644 src/rules.hpp
create mode 100644 src/ruleserror.hpp
create mode 100644 src/serialboost.cpp
create mode 100644 src/serialboost.hpp
create mode 100644 src/seriallinux.cpp
create mode 100644 src/seriallinux.hpp
create mode 100644 src/serialprop.cpp
create mode 100644 src/serialprop.hpp
create mode 100644 src/ultimate.cpp
create mode 100644 src/ultimate.hpp
(limited to 'src')
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..bf11705
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,28 @@
+bin_PROGRAMS = aeroup
+
+ext_src =
+if BOOST
+ext_src += serialboost.cpp
+ext_src += regboost.cpp
+#echo have boost
+else
+ext_src += reglinux.cpp
+ext_src += seriallinux.cpp
+#echo have not boost
+endif
+
+aeroup_SOURCES = \
+ main.cpp \
+ ultimate.cpp \
+ serialprop.cpp \
+ optmanager.cpp \
+ gloseq.cpp \
+ buffer.cpp \
+ buffermanager.cpp \
+ rules.cpp \
+ ${ext_src}
+
+aeroup_CPPFLAGS = -W -Wall -std=c++11
+aeroup_LDFLAGS =
+#LIBS +=
+#-DSERIAL_BOOST_LIB
diff --git a/src/buffer.cpp b/src/buffer.cpp
new file mode 100644
index 0000000..9c0ffec
--- /dev/null
+++ b/src/buffer.cpp
@@ -0,0 +1,173 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: buffer.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 28/12/2013 07:06:20
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ *
+ */
+
+#include <buffer.hpp>
+
+using namespace std;
+
+Buffer::Buffer():
+ size(0)
+{
+ //memset(buff, 0, sizeof(buff));
+}
+
+int Buffer::addChr(unsigned char val)
+{
+ verify_size();
+ //buff[size++] = val;
+ //strcpy((char*)buff[size],(const char *)val);
+ buff[size] = val;
+ size++;
+ return 1;
+
+}
+
+ string
+Buffer::addDefsubToBuff()
+{
+ for(auto itr = sub_position.begin(); itr != sub_position.end(); ++itr)
+ {
+ while(((*itr).second.empty()) == false )
+ {
+ auto it = defsub_position.find((*itr).first);
+ if(it != defsub_position.end())
+ {
+ buff[(*itr).second.back()] = defsub_position[(*itr).first][0];
+ buff[(*itr).second.back() + 1] = defsub_position[(*itr).first][1];
+ (*itr).second.pop_back();
+ }
+ else
+ {
+ return (*itr).first ;
+ }
+ }
+ }
+ return "";
+}
+
+ int
+Buffer::addDefsubPos(string defsubName)
+{
+ auto it = defsub_position.find(defsubName);
+ if(it == defsub_position.end())
+ {
+ defsub_position[defsubName][0] = (uint8_t)(size & 0xff);
+ defsub_position[defsubName][1] = (uint8_t)(size >> 8);
+ return 0;
+ }
+ else
+ {
+ return 1;
+ }
+}
+
+ void
+Buffer::addSubPos(string subName)
+{
+ sub_position[subName].push_back(size);
+}
+
+ void
+Buffer::printDefsubPos()
+{
+ cout << endl
+ << "(Debug function) print map defsub_position :" << endl
+ << "============================================" << endl;
+ for(auto itr = defsub_position.begin(); itr != defsub_position.end(); ++itr)
+ {
+ cout << "Key : " << (*itr).first << endl
+ << "Lsb : " << dec << (int)(*itr).second[0] << endl
+ << "Msb : " << dec << (int)(*itr).second[1] << endl ;
+ }
+}
+
+ void
+Buffer::printSubPos()
+{
+ cout << endl
+ << "(Debug function) print map sub_position :" << endl
+ << "=========================================" << endl;
+ for(auto itr = sub_position.begin(); itr != sub_position.end(); ++itr)
+ {
+ cout << "Key : " << (*itr).first << endl
+ << "Value : " ;
+ for (auto itr_vect = (*itr).second.begin();
+ itr_vect != (*itr).second.end();
+ ++itr_vect)
+ {
+ cout << (*itr_vect) << " ";
+ }
+
+ cout << endl;
+ }
+}
+
+ void
+Buffer::printBuff(void) const
+{
+ for (unsigned int i = 0; i < size ; i++)
+ {
+ printf("buff[%d] : %d\n", i, buff[i]);
+
+ }
+
+}
+
+ void
+Buffer::verify_size(void)
+{
+ if (size > BUFF_SIZE_MAX)
+ {
+ printf ("Error glow file too big !");
+ exit (EXIT_FAILURE);
+ }
+}
+
+
+/*
+ * where is sub map string vector int subnamekey, (byte,...)
+ * defsub defsubname, localisation subfunction
+ *
+ * if sub define 2 times error
+ *
+ * */
+ unsigned char*
+Buffer::getSizeUpCmd()
+{
+ lsb_msb[0]= 100;
+ lsb_msb[1]= (uint8_t)(size & 0xff);
+ lsb_msb[2]= (uint8_t)(size >> 8);
+ return lsb_msb;
+
+
+}
diff --git a/src/buffer.hpp b/src/buffer.hpp
new file mode 100644
index 0000000..eae7080
--- /dev/null
+++ b/src/buffer.hpp
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: buffer.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 28/12/2013 07:01:58
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef buffer_INC
+#define buffer_INC
+
+#define BUFF_SIZE_MAX 8959
+//#define SIZE_MAX_OVER 20000
+
+
+#include "global.hpp"
+#include <map>
+#include <vector>
+
+class Buffer
+{
+public:
+ Buffer();
+ int addChr(unsigned char val);
+ void addSubPos(std::string subName);
+ int addDefsubPos(std::string defsubName);
+ std::string addDefsubToBuff();
+ void printSubPos();
+ void printDefsubPos();
+ void printBuff(void) const;
+ // SIZE
+ unsigned short int getSize(void) const { return size;}
+ unsigned char * pointToBuff(){return buff;}
+ unsigned char* getSizeUpCmd();
+
+
+private:
+ void setSize(unsigned short int val) {size = val ;}
+ void verify_size(void);
+ unsigned short int size;
+ uint8_t lsb_msb[3];
+
+ // metre une variable pour 80
+ uint8_t buff[BUFF_SIZE_MAX];
+ std::map <std::string, std::vector<int> > sub_position;
+ std::map <std::string, uint8_t[2]> defsub_position;
+};
+
+
+#endif /* ----- #ifndef buffer_INC ----- */
diff --git a/src/buffermanager.cpp b/src/buffermanager.cpp
new file mode 100644
index 0000000..72ae576
--- /dev/null
+++ b/src/buffermanager.cpp
@@ -0,0 +1,384 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: buffermanager.cpp
+ *
+ * Description: take the parsed, tokenized lines and manage them.
+ * send also some rules test
+ *
+ * Version: 0.2
+ * Created: 30/12/2013 12:12:46
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#include "buffermanager.hpp"
+
+using namespace std;
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager
+ * Description: constructor
+ */
+
+BufferManager::BufferManager (Buffer* theBuff, Rules* theRules):
+ buff(theBuff),
+ rules(theRules)
+{
+}
+
+/*
+ * Class: BufferManager
+ * Method: completesCreateCommand
+ * Description: Second pass to buff, Completes createCommand work
+ */
+ void
+BufferManager::completesCreateCommand()
+{
+ verifyEndFileError();
+ addDefsubToBuff();
+}
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: verifyEndFileError
+ * Description: Verification which require that EOF is reached
+ * executed after the multiple call
+ * to the createCommand function by GloSeq instance.
+ */
+ void
+BufferManager::verifyEndFileError()
+{
+ /* verify there is no DEFSUB without ENDSUB before EOF */
+ rules->endTestDefsub();
+
+}
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: addDefsubToBuff
+ * Description: adds the defsub adress to every sub of the buffer
+ */
+ void
+BufferManager::addDefsubToBuff()
+{
+ string sub_name = buff->addDefsubToBuff();
+ /* If a sub is not defined, we throw an error */
+ if(!sub_name.empty())
+ {
+ rules->noDefsubError(sub_name);
+ }
+}
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: createCommand
+ * Description: fills the buffer with a token line
+ */
+
+ void
+BufferManager::createCommand (vector <string> tokens, int cmd_type, int nb_line)
+{
+
+ switch (cmd_type) {
+
+ case C_FCT:
+ rules->isStandardCmdPossible(nb_line, C_FCT);
+ colorsFillBuff(tokens);
+ break;
+
+ case D_FCT:
+ rules->isStandardCmdPossible(nb_line, D_FCT);
+ delayFillBuff(tokens);
+ break;
+
+ case RAMP_FCT:
+ rules->isStandardCmdPossible(nb_line, RAMP_FCT);
+ rampFillBuff(tokens);
+ break;
+
+ case L_FCT:
+ rules->setloop(nb_line);
+ loopFillBuff(tokens);
+ break;
+
+ case E_FCT:
+ rules->unsetloop(nb_line);
+ oneByteFillBuff(E_CMD);
+ break;
+
+ case R_FCT:
+ rules->isStandardCmdPossible(nb_line, R_FCT);
+ oneColorFillBuff(tokens, R_CMD);
+ break;
+
+ case G_FCT:
+ rules->isStandardCmdPossible(nb_line, G_FCT);
+ oneColorFillBuff(tokens, G_CMD);
+ break;
+
+ case B_FCT:
+ rules->isStandardCmdPossible(nb_line, B_FCT);
+ oneColorFillBuff(tokens, B_CMD);
+ break;
+
+ case SUB_FCT:
+ rules->isStandardCmdPossible(nb_line, SUB_FCT);
+ subFillBuff(tokens);
+ break;
+
+ case DEFSUB_FCT:
+ rules->setDefsub(nb_line);
+ defsubFillBuff(tokens, nb_line);
+ break;
+
+ case ENDSUB_FCT:
+ rules->unsetDefsub(nb_line);
+ oneByteFillBuff(ENDSUB_CMD);
+ break;
+
+ case END_FCT:
+ rules->setEnd(nb_line);
+ oneByteFillBuff(END_CMD);
+ break;
+ } /* ----- end switch ----- */
+ return ;
+} /* ----- end of method BufferManager::createCommand ----- */
+
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: oneColorFillBuff
+ * Description: ( *FillBuff function ) generic method for R, G, B commands
+ */
+
+ void
+BufferManager::oneColorFillBuff(vector <string> tokens, int col)
+{
+ buff->addChr(col);
+ buffAddOneColor(tokens[1]);
+}
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: ColorFillBuff
+ * Description: ( *FillBuff function ) Color C
+ */
+ void
+BufferManager::colorsFillBuff (vector <string> tokens)
+{
+ buff->addChr(C_CMD);
+ buffAddTriColors(tokens);
+}
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: delayFillBuff
+ * Description: ( *FillBuff function ) Delay D
+ */
+
+ void
+BufferManager::delayFillBuff (vector <string> tokens)
+{
+ int tmp_byte;
+ tmp_byte = stoi(tokens[1]);
+ if (verifyByteOverflow(tmp_byte) != -1)
+ {
+ buff->addChr(D_LOW_CMD);
+ buff->addChr((uint8_t)tmp_byte);
+ return;
+ }
+ else if(verify2BytesOverflow(tmp_byte) != -1)
+ {
+ buff->addChr(D_HIGH_CMD);
+ buff->addChr((uint8_t)(tmp_byte & 0xff));
+ buff->addChr((uint8_t)(tmp_byte >> 8));
+ return;
+ }
+ else
+ exit(EXIT_FAILURE);
+} /* ----- end of method BufferManager::delayFillBuff ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: loopFillBuff
+ * Description: ( *FillBuff function ) Loop L
+ */
+ void
+BufferManager::loopFillBuff (vector <string> tokens)
+{
+ buff->addChr(L_CMD);
+ int tmp_byte;
+ tmp_byte = stoi(tokens[1]);
+ if(verifyByteOverflow(tmp_byte)!= -1)
+ {
+ buff->addChr((uint8_t)tmp_byte);
+ }
+ else
+ {
+ exit(EXIT_FAILURE);
+ }
+} /* ----- end of method BufferManager::loopFillBuff ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: oneByteFillBuff
+ * Description: ( *FillBuff function ) Generic for E, END, ENDSUB
+ */
+ void
+BufferManager::oneByteFillBuff(int cmd)
+{
+ buff->addChr(cmd);
+} /* ----- end of method BufferManager::endLoopFillBuff ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: rampFillBuff
+ * Description: ( *FillBuff function ) RAMP
+ */
+ void
+BufferManager::rampFillBuff(std::vector<std::string> tokens)
+{
+ int tmp_byte;
+ tmp_byte = stoi(tokens[4]);
+ if (verifyByteOverflow(tmp_byte) != -1)
+ {
+ buff->addChr(RAMP_LOW_CMD);
+ buffAddTriColors(tokens);
+ buff->addChr(tmp_byte);
+ }
+ else if(verify2BytesOverflow(tmp_byte) != -1)
+ {
+ buff->addChr(RAMP_HIGH_CMD);
+ buffAddTriColors(tokens);
+ buff->addChr((uint8_t)(tmp_byte & 0xff));
+ buff->addChr((uint8_t)(tmp_byte >> 8));
+ return;
+ }
+ else
+ exit(EXIT_FAILURE);
+} /* ----- end of method BufferManager::rampFillBuff ----- */
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: subFillBuff
+ * Description: ( *FillBuff function ) SUB
+ * - Add SUB_CMD to buff
+ * - Stores the buffer position of the SUB LSB value in a map
+ * - And add two tempory '\0' value to buff for LSB & MSB
+ */
+ void
+BufferManager::subFillBuff(std::vector<std::string> tokens)
+{
+ buff->addChr(SUB_CMD);
+ buff->addSubPos(tokens[1]);
+ buff->addChr(0);
+ buff->addChr(0);
+} /* ----- end of method BufferManager::subFillBuff ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: defsubFillBuff
+ * Description: ( *FillBuff function ) DEFSUB
+ * - Add the beginning position of the DEFSUB
+ * function in the buffer to a map.
+ * - throws an error if the same function is defined twice
+ */
+ void
+BufferManager::defsubFillBuff(std::vector<std::string> tokens, int nb_line)
+{
+ if(buff->addDefsubPos(tokens[1]))
+ {
+ rules->twiceDefsubError(nb_line);
+ }
+
+} /* ----- end of method BufferManager::defsubFillBuff function ----- */
+
+
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: verifyByteOverflow
+ */
+ int
+BufferManager::verifyByteOverflow(int value)
+{
+ if (value < 256 && value > -1)
+ {
+ return value;
+ }
+ else
+ return -1;
+} /* ----- end of method BufferManager::verifyByteOverflow function ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: verify2BytesOverflow
+ */
+ int
+BufferManager::verify2BytesOverflow(int value)
+{
+ if (value < 65536 && value > 255)
+ {
+ return value;
+ }
+ else
+ return -1;
+} /* ----- end of method BufferManager::verify2BytesOverflow function ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: buffAddTriColors
+ */
+ void
+BufferManager::buffAddTriColors(vector<string>& tokens)
+{
+ for(int i = 1; i < 4; i++)
+ {
+ buffAddOneColor(tokens[i]);
+ }
+} /* ----- end of method BufferManager::buffAddTriColors function ----- */
+
+/*
+ * Class: BufferManager
+ * Method: BufferManager :: buffAddOneColor
+ */
+ void
+BufferManager::buffAddOneColor(string& tok)
+{
+ int tmp_byte;
+ tmp_byte = stoi(tok);
+ if(verifyByteOverflow(tmp_byte)!= -1)
+ {
+ buff->addChr((uint8_t)tmp_byte);
+ }
+ else {
+ exit(EXIT_FAILURE);
+ }
+} /* ----- end of method BufferManager::buffAddOneColor function ----- */
+
diff --git a/src/buffermanager.hpp b/src/buffermanager.hpp
new file mode 100644
index 0000000..0b14781
--- /dev/null
+++ b/src/buffermanager.hpp
@@ -0,0 +1,105 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: buffermanager.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 30/12/2013 12:07:43
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef commandfactory_INC
+#define commandfactory_INC
+
+#include <string>
+#include <vector>
+
+#include "buffer.hpp"
+#include "global.hpp"
+#include "rules.hpp"
+#include "define_ultimate_fct.h"
+
+/* -- commands byte values -- */
+const uint8_t C_CMD = 1;
+const uint8_t D_LOW_CMD = 2;
+const uint8_t L_CMD = 3;
+const uint8_t D_HIGH_CMD = 4;
+const uint8_t E_CMD = 5;
+const uint8_t R_CMD = 7;
+const uint8_t G_CMD = 8;
+const uint8_t B_CMD = 9;
+const uint8_t RAMP_LOW_CMD = 12;
+const uint8_t RAMP_HIGH_CMD = 13;
+const uint8_t SUB_CMD = 10;
+const uint8_t ENDSUB_CMD = 11;
+const uint8_t END_CMD = 255;
+
+/*
+ * Class: BufferManager
+ * Description:
+ */
+class BufferManager
+{
+ public:
+ BufferManager (Buffer* theBuff, Rules* theRules); /* constructor */
+
+ void createCommand ( std::vector <std::string> tokens,
+ int cmd_type,
+ int nb_line );
+ void completesCreateCommand ();
+
+ private:
+ /* ...FillBuff function */
+ void delayFillBuff(std::vector<std::string> tokens);
+ void oneByteFillBuff(int fct);
+ void oneColorFillBuff(std::vector <std::string> tokens, int col);
+ void colorsFillBuff(std::vector<std::string> tokens);
+ void rampFillBuff(std::vector<std::string> tokens);
+ void loopFillBuff(std::vector<std::string> tokens);
+ void subFillBuff(std::vector<std::string> tokens);
+ void defsubFillBuff(std::vector<std::string> tokens, int nb_line);
+
+ /* Second pass to buff, Completes createCommand work */
+ void addDefsubToBuff();
+ void verifyEndFileError();
+
+ /* Byte verification */
+ int verifyByteOverflow(int Value);
+ int verify2BytesOverflow(int Value);
+
+ /* Colors utility */
+ void buffAddTriColors(std::vector<std::string>& tokens);
+ void buffAddOneColor(std::string& tok);
+
+ /* aggregation */
+ Buffer* buff;
+ Rules* rules;
+
+ /* data */
+ std::string fileName;
+
+};
+
+#endif /* ----- #ifndef command_factory_INC ----- */
diff --git a/src/config.h.in b/src/config.h.in
new file mode 100644
index 0000000..aaedc55
--- /dev/null
+++ b/src/config.h.in
@@ -0,0 +1,91 @@
+/* src/config.h.in. Generated from configure.ac by autoheader. */
+
+/* Define debug mod */
+#undef DEBUG
+
+/* Define to 1 if you have the `bzero' function. */
+#undef HAVE_BZERO
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#undef HAVE_FCNTL_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the 'boost_regex' library (-lboost_regex) */
+#undef HAVE_LIBBOOST_REGEX
+
+/* Define to 1 if you have the `boost_system' library (-lboost_system). */
+#undef HAVE_LIBBOOST_SYSTEM
+
+/* Define to 1 if you have the `boost_thread' library (-lboost_thread). */
+#undef HAVE_LIBBOOST_THREAD
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `memset' function. */
+#undef HAVE_MEMSET
+
+/* Define to 1 if you have the `regcomp' function. */
+#undef HAVE_REGCOMP
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the `strtol' function. */
+#undef HAVE_STRTOL
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <termios.h> header file. */
+#undef HAVE_TERMIOS_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if the system has the type `_Bool'. */
+#undef HAVE__BOOL
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
diff --git a/src/define_ultimate_fct.h b/src/define_ultimate_fct.h
new file mode 100644
index 0000000..36fe030
--- /dev/null
+++ b/src/define_ultimate_fct.h
@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: define_ultimate_fct.h
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 30/12/2013 12:50:40
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef define_ultimate_fct_INC
+#define define_ultimate_fct_INC
+
+#define C_FCT 0
+#define D_FCT 1
+#define RAMP_FCT 2
+#define L_FCT 3
+#define E_FCT 4
+#define R_FCT 5
+#define G_FCT 6
+#define B_FCT 7
+#define SUB_FCT 8
+#define DEFSUB_FCT 9
+#define ENDSUB_FCT 10
+#define END_FCT 11
+#define REG_TAB_LEN (END_FCT + 1)
+
+#endif /* ----- #ifndef define_ultimate_fct_INC ----- */
diff --git a/src/gloInterface.hpp b/src/gloInterface.hpp
new file mode 100644
index 0000000..f31658a
--- /dev/null
+++ b/src/gloInterface.hpp
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: gloInterface.hpp
+ *
+ * Description:
+ *
+ * Version:
+ * Created: 11/01/2014 14:03:43
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef gloInterface_INC
+#define gloInterface_INC
+
+
+
+#include "global.hpp"
+#include "gloseq.hpp"
+
+
+/*
+ * Class: GloInterface
+ * Description:
+ */
+class GloInterface
+{
+ public:
+ GloInterface(){;} /* constructor */
+
+ int verifyFile( std::string fileName)
+ {
+ GloSeq file(fileName);
+ file.verify();
+ return (1); // tempory implementaion return
+ }
+
+
+ private:
+
+}; /* ----- end of class Editor ----- */
+
+#endif
diff --git a/src/global.hpp b/src/global.hpp
new file mode 100644
index 0000000..be20d98
--- /dev/null
+++ b/src/global.hpp
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: global.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 20/12/2013 00:09:35
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef global_INC
+#define global_INC
+
+#include <stdlib.h>
+#include <string>
+#include <iostream>
+
+typedef unsigned char uint8_t;
+
+#endif /* ----- #ifndef global_INC ----- */
diff --git a/src/gloseq.cpp b/src/gloseq.cpp
new file mode 100644
index 0000000..370b522
--- /dev/null
+++ b/src/gloseq.cpp
@@ -0,0 +1,238 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: gloseq.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 27/12/2013 10:38:49
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#include <sstream>
+#include "gloseq.hpp"
+
+using namespace std;
+
+
+/*
+ * Class: GloSeq
+ * Method: GloSeq :: GloSeq
+ * Description: Constructor, open glo file in read mode
+ */
+GloSeq::GloSeq (string fileName):
+ file_name(fileName),
+ buff(),
+ rules(file_name),
+ buffManager(&buff, &rules)
+{
+ try
+ {
+ glofile.open(fileName);
+ if (!glofile)
+ {
+ throw "Error : can't opening glo file : ";
+ }
+ }
+ catch(const char* cstr)
+ {
+ cerr << cstr << fileName << endl;
+ throw;
+ }
+} /* ----- end of constructor ----- */
+
+/*
+ * Class: GloSeq
+ * Method: GloSeq :: verify
+ * Description: Verify that the glo file is valid.
+ * At the end of process, if no error happened the buffer is filled
+ * and ready to be upload.
+ */
+ void
+GloSeq::verify ()
+{
+ /* step 1 */
+ #ifdef DEBUG
+ cout << endl
+ << "1) Clean lines and keep what is needed :" << endl
+ << "========================================" << endl;
+ int j = 0;
+ #endif
+
+ string line;
+ for(int nb_line = 1; getline(glofile, line) != 0; nb_line++)
+ {
+ // cleaning each line
+ cleanLine(line);
+ if (line.length() != 0)
+ {
+ // put it in a vector
+ cmdTab.push_back({line, -1, nb_line});
+#ifdef DEBUG
+ cout << cmdTab[j].nb_line <<"| "<< cmdTab[j].line << endl;
+ ++j;
+#endif
+ }
+ }
+
+ /* step 2 */
+ #ifdef DEBUG
+ cout << endl
+ << "2) Regex validation :" << endl
+ << "=====================" << endl;
+ #endif
+
+#if HAVE_LIBBOOST_REGEX
+ RegBoost* reg = new RegBoost;
+#else
+ RegLinux* reg = new RegLinux;
+#endif
+ auto iterlist = cmdTab.begin();
+ int cmd;
+ int nb_error = 0;
+
+ while (iterlist != cmdTab.end())
+ {
+ cmd = reg->isValidSyntax( (*iterlist).line );
+ if (cmd == NOT_VALID)
+ {
+ if (!nb_error)
+ cout << "Syntax error in file " << file_name << " :" << endl;
+
+ cout << "Error line " << (*iterlist).nb_line
+ << ", " << (*iterlist).line << endl;
+ ++nb_error;
+ }
+ else
+ (*iterlist).cmd_type = cmd;
+ ++iterlist;
+ }
+ delete reg;
+
+ try
+ {
+ if (nb_error != 0)
+ throw(nb_error);
+ }
+ catch (int nb_error )
+ {
+ if (nb_error == 1)
+ cerr << "Error : "<< nb_error <<" syntax error in " << file_name << endl;
+ else
+ cerr << "Error : "<< nb_error <<" syntax errors in " << file_name << endl;
+ throw;
+ }
+
+ /* step 3 */
+ #ifdef DEBUG
+ cout << endl
+ << "3) Tokenize and send to buffManager:" << endl
+ << "========================================" << endl;
+ #endif
+ iterlist = cmdTab.begin();
+ vector <string> tokens;
+ //vector<string>::iterator it_string;
+
+ while (iterlist != cmdTab.end())
+ {
+ istringstream iss((*iterlist).line);
+ tokens.clear();
+ for (string each; (getline(iss, each, ',')); tokens.push_back(each));
+ try
+ {
+ buffManager.createCommand(tokens, (*iterlist).cmd_type, (*iterlist).nb_line);
+ }
+ catch( const std::exception & e )
+ {
+ cerr << e.what() << "\n";
+ throw;
+ }
+
+ ++iterlist;
+ }
+
+ #ifdef DEBUG
+ buff.printBuff();
+ buff.printSubPos();
+ buff.printDefsubPos();
+ #endif
+
+ try
+ {
+ /*
+ * createCommand second pass:
+ * makes some works haven't been at the first pass
+ * 1) error detection, we can't see during the createCommand function
+ * 2) fill buffer with the adress of beginning of defsub
+ **/
+ buffManager.completesCreateCommand();
+ }
+ catch( const std::exception & e )
+ {
+ cerr << e.what() << "\n";
+ throw;
+ }
+
+ #ifdef DEBUG
+ cout << "(debug) print buff second pass :" << endl
+ << "================================" << endl;
+ buff.printBuff();
+ #endif
+} /* ----- end of method GloSeq::verify ----- */
+
+/*
+ * Class: GloSeq
+ * Method: GloSeq :: cleanLine
+ * Description:
+ */
+ void
+GloSeq::cleanLine ( string &rline )
+{
+ size_t i;
+ // parsing a line
+ for (i = 0 ; i < rline.length(); ++ i )
+ {
+ if (rline[i] == ';')
+ rline.erase(i, rline.length());
+
+ else if (rline[i] == SP || rline[i] == TAB || rline[i] == CR || rline[i] == LF)
+ rline.erase(rline.begin() + i--);
+ }
+} /* ----- end of method GloSeq::cleanLine ----- */
+
+
+/*
+ * Class: GloSeq
+ * Method: GloSeq :: upload
+ * Description:
+ */
+ void
+GloSeq::upload(SerialProp & ser)
+{
+ ser.sendString(buff.getSizeUpCmd(), 3);
+ ser.sendString(buff.pointToBuff(), buff.getSize());
+
+} /* ----- end of method GloSeq::upload ----- */
+
+
diff --git a/src/gloseq.hpp b/src/gloseq.hpp
new file mode 100644
index 0000000..3487f6b
--- /dev/null
+++ b/src/gloseq.hpp
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: gloseq.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 27/12/2013 10:40:44
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef gloseq_INC
+#define gloseq_INC
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include <iterator>
+#include <algorithm>
+
+#include "global.hpp"
+#include "buffer.hpp"
+#include "buffermanager.hpp"
+#include "rules.hpp"
+#include "serialprop.hpp"
+#include "config.h"
+
+#if HAVE_LIBBOOST_REGEX
+ #include "regboost.hpp"
+#else
+ #include "reglinux.hpp"
+#endif
+
+
+/*
+ * Class: GloSeq
+ * Description: Contains all the processing related to the glo file.
+ */
+class GloSeq
+{
+ public:
+ void verify();
+ void upload(SerialProp & ser);
+
+ GloSeq (std::string fileName); /* constructor */
+
+
+
+ private:
+ void cleanLine(std::string& rline);
+
+ const char SP = 0x20;
+ const char TAB = 0x09;
+ const char CR = 0x0d;
+ const char LF = 0x0a;
+ const int NOT_VALID = -1;
+
+ std::string file_name;
+ std::ifstream glofile;
+
+ struct command
+ {
+ std::string line;
+ int cmd_type;
+ int nb_line;
+ };
+ std::vector <command> cmdTab;
+
+
+ Buffer buff;
+ Rules rules;
+ BufferManager buffManager;
+
+
+}; /* ----- end of class GloSeq ----- */
+
+
+#endif /* ----- #ifndef gloseq_INC ----- */
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..920a89b
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,269 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: main.cpp
+ *
+ * Description: command line entry point.
+ * lib getopt needed this is for unix users
+ *
+ *
+ * Version: 0.2
+ * Created: 20/12/2013 00:57:44
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <string>
+
+#include <getopt.h>
+#include "global.hpp"
+#include "main.hpp"
+#include "optmanager.hpp"
+#include "config.h"
+
+
+
+using namespace std;
+
+
+bool VERBOSE_AERO;
+
+/*
+ * Name: main
+ * Description: get cmd args... gives the job to OptManager.
+ * and finally said to OptManager to start launch
+ * of what is expected.
+ */
+ int
+main ( int argc, char *argv[] )
+{
+
+ int version = 0;
+ int help = 0;
+ VERBOSE_AERO = false;
+ int c;
+ OptManager manager;
+
+ while (1)
+ {
+ static struct option long_options[] =
+ {
+ {"start", required_argument, NULL, 'o'},
+ {"test", required_argument, NULL, 't'},
+ {"color", required_argument, NULL, 'c'},
+ {"getSerial", required_argument, NULL, 'G'},
+ {"setSerial", required_argument, NULL, 'S'},
+ {"verify", required_argument, NULL, 'i'},
+ {"uploadGlo", required_argument, NULL, 'u'},
+ {"uploadGloc", no_argument, NULL, 'U'},
+ {"verbose", no_argument, NULL, 'v'},
+ {"thread", no_argument, NULL, 1 },
+ {"version", no_argument, &version, 1 },
+ {"help", no_argument, NULL, 'h'},
+ {0, 0, 0, 0}
+ };
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+ c = getopt_long (argc, argv, "o:t:c:G:S:u:U:i:vh",
+ long_options, &option_index);
+
+ /* Detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c)
+ {
+ case 'o':
+ manager.addItemStart(optarg);
+ break;
+
+ case 't':
+ manager.addItemTest(optarg);
+ break;
+
+ case 'c':
+ try
+ {
+ manager.subRoutine(FLAG_COLOR);
+ }
+ catch ( const string & Msg )
+ {
+ cerr << "Error : " << Msg << endl;
+ return(EXIT_FAILURE);
+ }
+ break;
+
+ case 'G':
+ manager.addItemGetSerial(optarg);
+ break;
+
+ case 'S':
+ try
+ {
+ manager.subRoutine(FLAG_SET_SER);
+ }
+ catch ( const string & Msg )
+ {
+ cerr << "Error : " << Msg << endl;
+ return(EXIT_FAILURE);
+ }
+ break;
+
+ case 'i':
+ manager.addItemVerify(optarg);
+ break;
+
+ case 'u':
+ manager.subRoutine(FLAG_UP_GLO);
+ break;
+
+ case 'U':
+ manager.subRoutine(FLAG_UP_GLOC);
+ break;
+
+ case 'v':
+ VERBOSE_AERO = true;
+ break;
+
+ case 'h':
+ help = 1;
+ break;
+
+ case '?':
+ /* getopt_long already printed an error message. */
+ puts("To get help : 'aeroup --help' or 'man aeroup'");
+ return EXIT_FAILURE;
+ break;
+
+ default:
+ abort ();
+ }
+ }
+
+ /* Print any remaining command line arguments (not options). */
+ if (optind < argc)
+ {
+ printf ("non-option ARGV-elements: ");
+ while (optind < argc)
+ printf ("%s ", argv[optind++]);
+ putchar ('\n');
+ puts("To get help : 'aeroup --help' or 'man aeroup'");
+ return(EXIT_FAILURE);
+ }
+
+
+ if(version)
+ {
+ aeroVersion();
+ return(EXIT_SUCCESS);
+ }
+
+ if(help || argc == 1)
+ {
+ aeroHelp();
+ return(EXIT_SUCCESS);
+ }
+
+ try
+ {
+ manager.start();
+ }
+ catch( const exception & e )
+ {
+ return(EXIT_FAILURE);
+ }
+ catch(...)
+ {
+ //return(EXIT_FAILURE);
+ puts("UNKNOWN ERROR, CATCHED IN MAIN");
+ return(EXIT_FAILURE);
+ }
+
+ return(EXIT_SUCCESS);
+}
+
+
+/*
+ * Name: aeroHelp
+ * Description: --help
+ */
+ void
+aeroHelp()
+{
+ cout << "Usage : " << PACKAGE <<" [OPTION [SUB_OPTION]]...\n"
+ << "AeroUp is an open source command line tool to control Ultimate juggling props sold by Aerotech Projects.\n\n"
+ << " -t, --test=serialPort Send a test command on dev serialPort.\n"
+ << " -o, --start=serialPort Send a start sequence command on dev serialPort.\n"
+ << " -c, --color=R,G,B,serialPort Send a color command on dev serialPort.\n"
+ << " R,G,B can be hex (0x#), dec (#) value,\n"
+ << " in range of [0-255] (8bit).\n"
+ << " -G, --getSerial=serialPort get serial number on dev serialPort, and print it to standard output.\n"
+ << " -S, --setSerial=serialNumber,serialPort Set serialNumber on dev serialPort. the 32 bits serialNumber value\n"
+ << " can be writen in hex (0x#) or dec (#).\n"
+ << " -i, --verify=gloFile Verify that syntax glo file is valid.\n"
+ << " -u, --uploadGloc=gloFile,serialPort Verify that syntax glo file is valid, and if this is the case\n"
+ << " upload it on dev serialPort.\n"
+ << " -P, --thread Multithread mode, not implemented yet...\n"
+ << " -U, --uploadGloc=glocFile,serialPort not implemented yet...\n"
+ << " -v Verbose mode.\n"
+ << " -h, --help Print help.\n"
+ << " --version Print version.\n\n"
+ << "Each sub options have to be separate with a comma without blank.\n"
+ << "you 'll find more info in the man of aeroup.\n\n"
+ << "Examples\n"
+ << " aeroup -t /dev/ttyACM0\n"
+ << " aeroup -o /dev/ttyACM0 -o /dev/ttyACM1 -t /dev/ttyACM3\n"
+ << " aeroup -c 255,69,255,/dev/ttyACM0 27,3,7,/dev/ttyACM1\n"
+ << " aeroup -S 0x0b01/dev/ttyACM0\n"
+ << " aeroup -G /dev/ttyACM0\n\n"
+ << "AeroUp project page : " PACKAGE_URL << "\n"
+ << "You can also take a look at the AeroWrite project page https://github.com/LaurentBa/AeroWrite\n"
+ << "Report bugs to " << PACKAGE_BUGREPORT << "\n"
+ << endl;
+
+}
+
+
+/*
+ * Name: aeroVersion
+ * Description: --version
+ */
+ void
+aeroVersion()
+{
+ cout << PACKAGE_STRING << "\n"
+ "Copyright © 2014 BARATTERO Laurent\n"
+ "License GPLv3+: GNU GPL version 3 or later\n"
+ "<http://gnu.org/licenses/gpl.html>\n"
+ "This is free software: you are free to change and redistribute it.\n"
+ "There is NO WARRANTY, to the extent permitted by law\n";
+}
+
+
+
+
+
diff --git a/src/main.hpp b/src/main.hpp
new file mode 100644
index 0000000..d66dfff
--- /dev/null
+++ b/src/main.hpp
@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: main.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 21/12/2013 03:56:20
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef main_INC
+#define main_INC
+
+#define TEST_FLAG 0x1
+#define START_FLAG 0x2
+#define GET_SERIAL_FLAG 0x4
+#define SET_SERIAL_FLAG 0x8
+#define UPLOAD_GLO_FLAG 0x10
+#define UPLOAD_GLOC_FLAG 0x20
+#define VERBOSSE_FLAG 0x40
+#define VERIFY_FLAG 0x80
+#define MAKE_GLOC_FLAG 0x100
+#define FLAG1 0x100
+
+void aeroHelp();
+void aeroVersion();
+
+#endif /* ----- #ifndef main_INC ----- */
diff --git a/src/optmanager.cpp b/src/optmanager.cpp
new file mode 100644
index 0000000..a8cc039
--- /dev/null
+++ b/src/optmanager.cpp
@@ -0,0 +1,438 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: optmanager.cpp
+ *
+ * Description: Manages command line options & sub options
+ * To do : make space possible on command line
+ * for sub option would be cool more cool
+ *
+ * ToDo : Verify that the value for setSerial is not out of range
+ * for the time being, the value is set to max.
+ * we could test string before conversion.
+ *
+ * Version: 0.2
+ * Created: 23/12/2013 23:31:46
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#include "optmanager.hpp"
+
+extern bool VERBOSE_AERO;
+
+using namespace std;
+
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: start
+ * Description: Order Processing
+ */
+ void
+OptManager::start()
+{
+ // Start command
+ for (vector<string>::iterator iter = startList.begin();
+ iter != startList.end(); ++iter)
+ {
+ sendStart(*iter);
+ if (VERBOSE_AERO)
+ cout << "Start command sent on : " << *iter << endl;
+ }
+
+ // Color Command
+ for (vector<optCol>::iterator iter = colorList.begin();
+ iter != colorList.end(); ++iter)
+ {
+ if ( (*iter).port != "\0")
+ {
+ sendColor( (*iter).rgb[RED],
+ (*iter).rgb[GREEN],
+ (*iter).rgb[BLUE],
+ (*iter).port);
+ }
+ else
+ {
+ cout << "missing port name argument in color command" << endl;
+ exit (EXIT_FAILURE);
+ }
+
+ if(VERBOSE_AERO)
+ {
+ cout << "Color command (c" << dec
+ << "," << static_cast<int>((*iter).rgb[RED])
+ << "," << static_cast<int>((*iter).rgb[GREEN])
+ << "," << static_cast<int>((*iter).rgb[BLUE])
+ << ") sent on port \"" << (*iter).port << "\""
+ << endl;
+
+ }
+ }
+
+ // Test command
+ for ( vector<string>::iterator iter = testList.begin();
+ iter != testList.end(); ++iter)
+ {
+ sendTest(*iter);
+ if (VERBOSE_AERO)
+ cout << "Test command sent on : " << *iter << endl;
+ }
+
+ // Upload Glo file
+ for (vector<optUp>::iterator iter = upGloList.begin();
+ iter != upGloList.end(); ++iter)
+ {
+ sendUpGlo((*iter).fileName, (*iter).port);
+ }
+
+ // Get serial number
+ for (vector<string>::iterator iter = getSerialList.begin();
+ iter != getSerialList.end(); ++iter)
+ {
+ sendGetSerial(*iter);
+ }
+
+ // Set serial number
+ for (vector<optSerial>::iterator iter = setSerialList.begin();
+ iter != setSerialList.end(); ++iter)
+ {
+ sendSetSerial((*iter).i_serialNumber,(*iter).port);
+ }
+
+ // Verify Glo file
+ for ( vector<string>::iterator iter = verifyList.begin();
+ iter != verifyList.end(); ++iter)
+ {
+ sendVerify(*iter);
+ if (VERBOSE_AERO)
+ cout << "Process verification on file " << *iter << endl;
+ }
+
+} /* ----- end of method OptManager::start ----- */
+
+
+/*
+ * .::SEND COMMAND::.
+ * all the functionalities functionality proposed by the command line interface
+ */
+
+/*
+ * Method: OptManager :: sendTest
+ */
+ void
+OptManager::sendTest( std::string port_name )
+{
+ Ultimate prop( port_name );
+ prop.test();
+
+}
+
+/*
+ * Method: OptManager :: sendStart
+ */
+ void
+OptManager::sendStart(string port_name)
+{
+ Ultimate prop(port_name);
+ prop.start();
+}
+
+/*
+ * Method: OptManager :: sendColor
+ */
+ void
+OptManager::sendColor( uint8_t red, uint8_t green, uint8_t blue, string port_name)
+{
+ Ultimate prop(port_name);
+ prop.color(red, green, blue);
+}
+
+/*
+ * Method: OptManager :: sendGetSerial
+ */
+ void
+OptManager::sendGetSerial( std::string port_name)
+{
+ Ultimate prop(port_name);
+ cout << "Serial number is : 0x" << prop.getSerial() << endl;
+
+}
+
+/*
+ * Method: OptManager :: sendSetSerial
+ */
+ void
+OptManager::sendSetSerial(uint32_t i_serialNumber, string port)
+{
+ Ultimate prop(port);
+ prop.setSerialUlt( i_serialNumber);
+}
+
+/*
+ * Method: OptManager :: sendVerify
+ */
+ void
+OptManager::sendVerify(string fileName)
+{
+ GloInterface gloInt;
+ gloInt.verifyFile(fileName);
+}
+/*
+ * Method: OptManager :: sendUpGlo
+ */
+ void
+OptManager::sendUpGlo(string fileName, string port_name)
+{
+ Ultimate prop(port_name);
+ if( prop.uploadGlo(fileName))
+ {
+ cout << "Upload " << fileName << " OK" << endl;
+ }
+}
+
+/* ---- End of SEND COMMAND ---- */
+
+
+/*
+ * .::SUB COMMAND::.
+ */
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: subRoutine
+ * Description: Getopt sub routine switch
+ */
+ void
+OptManager::subRoutine(const short int FLAG )
+{
+ switch(FLAG)
+ {
+ case FLAG_COLOR:
+ subRoutineColor();
+ break;
+
+ case FLAG_UP_GLOC:
+ case FLAG_UP_GLO:
+ subRoutineUp(FLAG);
+ break;
+
+ case FLAG_SET_SER:
+ subRoutineSetSerial();
+ break;
+ }
+}
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: subRoutineSetSerial
+ * Description: Getopt sub routine for Set Serial
+ */
+ void
+OptManager::subRoutineSetSerial()
+{
+ optSerial tmpSerialNb;
+ subopts = optarg;
+ tmpSerialNb.i_serialNumber = 0;
+ uint32_t tmp_int;
+ for (int i = 0; *subopts !='\0'; i++)
+ {
+ getsubopt(&subopts, token, &value);
+ switch (i)
+ {
+ case 0:
+ tmp_int =isValidSerialNumber(value);
+ if (tmp_int != 1)
+ tmpSerialNb.i_serialNumber = tmp_int;
+ else
+ cerr << "error without throw" << endl;
+ break;
+
+ case 1:
+ tmpSerialNb.port = value;
+ break;
+
+ default:
+ cout << "too many args in set serial command" << endl;
+ break;
+ }
+ }
+ setSerialList.push_back(tmpSerialNb);
+}
+
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: subRoutineUp
+ * Description: Getopt sub routine for Upload Glo & GloC
+ */
+ void
+OptManager::subRoutineUp(const short int FLAG )
+{
+ optUp tmpOpt;
+
+ subopts = optarg;
+ for (int i = 0; *subopts !='\0'; i++)
+ {
+ getsubopt(&subopts, token, &value);
+ switch (i)
+ {
+ case 0:
+ tmpOpt.fileName = value;
+ break;
+
+ case 1:
+ tmpOpt.port = value;
+ break;
+
+ default:
+ cout << "too many args in upload command" << endl;
+ break;
+ }
+ }
+
+ switch (FLAG)
+ {
+ case FLAG_UP_GLO:
+ upGloList.push_back(tmpOpt);
+ case FLAG_UP_GLOC:
+ upGloCList.push_back(tmpOpt);
+ break;
+ }
+}
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: subRoutineColor
+ * Description: Getopt sub routine for color command
+ */
+ void
+OptManager::subRoutineColor()
+{
+ optCol tmpcol;
+ uint8_t intensity[3] = {0} ;
+ int tmp_int;
+ subopts = optarg;
+ for (int i = 0; *subopts !='\0'; i++)
+ {
+ getsubopt(&subopts, token, &value);
+ switch (i)
+ {
+
+ // for all color verify the validity of values
+ case RED: case GREEN: case BLUE:
+ tmp_int = isValid0xFF(value);
+ if (tmp_int == -1)
+ {
+ cerr << "ERROR : non valid color for color command c "
+ << value << endl;
+ exit (EXIT_FAILURE);
+ }
+ intensity[i] = ( char)tmp_int;
+ break;
+
+ case PORT_NAME:
+ for (int index = 0 ; index<3; index++)
+ tmpcol.rgb[index] = intensity[index];
+ tmpcol.port = value;
+ colorList.push_back(tmpcol);
+ break;
+
+ default:
+ cerr << "Error, too many args for -c" << endl;
+ exit (EXIT_FAILURE);
+ break;
+ }
+ }
+} /* ----- end of method OptManager::subRoutineColor ----- */
+
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: isValid0xFF
+ * Description: verify if value can become 1 byte(0-255)
+ */
+ int
+OptManager::isValid0xFF(char * value)
+{
+ int hexval = strtol(value,(char**)NULL,0);
+ if (hexval < 256 && hexval > -1)
+ return hexval;
+ return -1;
+}
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: isValidSerialNumber
+ * Description: test with dec, hex & bin notation
+ */
+ uint32_t
+OptManager::isValidSerialNumber(string strNb)
+{
+ uint32_t i_ser_nb;
+
+ if (isDecNotation( strNb))
+ {
+ std::stringstream ss( strNb);
+ ss >> dec >> i_ser_nb;
+ cout << i_ser_nb << endl;
+ }
+ else if(isHexNotation( strNb))
+ {
+ std::stringstream ss( strNb.substr(2));
+ ss >> hex >> i_ser_nb;
+ cout << i_ser_nb << endl;
+ }
+ else
+ {
+ throw std::string( "Bad serial number" );
+ }
+
+ return i_ser_nb;
+}
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: isHexNotation
+ * Description: is hex notation
+ */
+ bool
+OptManager::isHexNotation(std::string const& s)
+{
+ return s.compare(0, 2, "0x") == 0
+ && s.size() > 2
+ && s.find_first_not_of("0123456789abcdefABCDEF", 2) == std::string::npos;
+}
+
+
+/*
+ * Class: OptManager
+ * Method: OptManager :: isDecNotation
+ * Description: is dec notation
+ */
+ bool
+OptManager::isDecNotation(const std::string& s)
+{
+ std::string::const_iterator it = s.begin();
+ while (it != s.end() && std::isdigit(*it)) ++it;
+ return !s.empty() && it == s.end();
+}
diff --git a/src/optmanager.hpp b/src/optmanager.hpp
new file mode 100644
index 0000000..3252a91
--- /dev/null
+++ b/src/optmanager.hpp
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: optmanager.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 23/12/2013 22:59:22
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef optmanager_INC
+#define optmanager_INC
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string>
+#include <vector>
+#include "global.hpp"
+#include "ultimate.hpp"
+#include "gloInterface.hpp"
+
+#define MAX_LEN_OPT 2
+
+#define FLAG_SET_SER 0x1
+#define FLAG_UP_GLO 0x2
+#define FLAG_UP_GLOC 0x4
+#define FLAG_COLOR 0x8
+#define FLAG_VERIFY 0x10
+
+/*
+ * Class: OptManager
+ * Description: Manages command line options & sub options
+ */
+class OptManager
+{
+ public:
+ OptManager (){;} /* constructor */
+
+ void start();
+
+ void addItemStart(std::string port_name)
+ {startList.push_back(port_name);}
+
+ void addItemTest(std::string port_name)
+ {testList.push_back(port_name);}
+
+ void addItemGetSerial(std::string port_name)
+ {getSerialList.push_back(port_name);}
+
+ void addItemVerify(std::string glo_file)
+ {verifyList.push_back(glo_file);}
+
+ void subRoutine(const short int FLAG);
+
+ private:
+ // Send functions
+ void sendTest(std::string port_name);
+ void sendStart(std::string port_name);
+ void sendColor(uint8_t red, uint8_t green, uint8_t blue, std::string port_name);
+ void sendGetSerial(std::string port_name);
+ void sendSetSerial(uint32_t i_serialNumber, std::string port);
+ void sendVerify(std::string fileName);
+ void sendUpGlo(std::string fileName, std::string port);
+ // void sendUpGloC(std::string fileName, std::string port);
+
+ // Sub functions
+ void subRoutineColor();
+ void subRoutineUp(const short FLAG);
+ void subRoutineSetSerial();
+
+ // Tool functions
+ uint32_t isValidSerialNumber(std::string strNb);
+ int isValid0xFF(char* value);
+ bool isHexNotation(std::string const& s);
+ bool isDecNotation(std::string const& s);
+
+ // GetSubOpt data
+ char * token[MAX_LEN_OPT]={0};
+ char *subopts;
+ char *value;
+ enum { RED = 0, GREEN, BLUE, PORT_NAME };
+
+
+ // Structures and variables for opts containers
+ // struct
+ struct optCol
+ {
+ unsigned char rgb[3];
+ std::string port;
+ };
+
+ struct optUp
+ {
+ std::string fileName;
+ std::string port;
+ };
+
+ struct optSerial
+ {
+ uint32_t i_serialNumber;
+ std::string serialNumber;
+ std::string port;
+ };
+ // Var
+ std::vector<std::string> startList;
+ std::vector<std::string> testList;
+ std::vector<optCol> colorList;
+ std::vector<optUp> upGloList;
+ std::vector<optUp> upGloCList;
+ std::vector<std::string> verifyList;
+ std::vector<optSerial> setSerialList;
+ std::vector<std::string> getSerialList;
+ // end of Structures and variables for opts containers
+
+}; /* ----- end of class OptManager ----- */
+
+#endif /* ----- #ifndef optmanager_INC ----- */
diff --git a/src/regboost.cpp b/src/regboost.cpp
new file mode 100644
index 0000000..bf3cf87
--- /dev/null
+++ b/src/regboost.cpp
@@ -0,0 +1,62 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: regboost.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 19/12/2013 05:22:37
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ *
+ */
+#include "regboost.hpp"
+
+
+using namespace std;
+using namespace boost;
+
+RegBoost::RegBoost ( )
+{
+} /* ----- end of method RegBoost::RegBoost ----- */
+
+
+
+ int
+RegBoost::isValidSyntax ( string &rline )
+{
+ for (int i = 0; i < REG_TAB_LEN; i++)
+ {
+ if ( regex_match(rline.begin(), rline.end(), reg_tab[i]) )
+ {
+ #ifdef DEBUG
+ cout << rline << " -> ok" << endl;
+ #endif
+ return i;
+ }
+ }
+ return -1;
+
+} /* ----- end of method RegBoost::isValidSyntax ----- */
+
+
diff --git a/src/regboost.hpp b/src/regboost.hpp
new file mode 100644
index 0000000..956be25
--- /dev/null
+++ b/src/regboost.hpp
@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: regboost.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 19/12/2013 05:23:16
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+
+#ifndef regboost_INC
+#define regboost_INC
+
+
+#include <boost/regex.hpp>
+#include <iostream>
+#include "define_ultimate_fct.h"
+#include "global.hpp"
+
+// BOOST REGEX TAB
+static const boost::regex reg_tab[] = {
+ boost::regex("^C,[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,3}$"), // C_FCT
+ boost::regex("^D,[[:digit:]]{1,5}$"), // D_FCT
+ boost::regex("^RAMP,[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,5}$"), // RAMP_FCT
+ boost::regex("^L,[[:digit:]]{1,3}$"), // L_FCT
+ boost::regex("^E$"), // E_FCT
+ boost::regex("^R,[[:digit:]]{1,3}$"), // R_FCT
+ boost::regex("^G,[[:digit:]]{1,3}$"), // G_FCT
+ boost::regex("^B,[[:digit:]]{1,3}$"), // B_FCT
+ boost::regex("^SUB,[-_[:alnum:]]+$"), // SUB_FCT
+ boost::regex("^DEFSUB,[-_[:alnum:]]+$"), // DEFSUB_FCT
+ boost::regex("^ENDSUB$"), // ENDSUB_FCT
+ boost::regex("^END$")}; // END_FCT
+
+
+/*
+ * Class: RegBoost
+ * Description:
+ */
+class RegBoost
+{
+ public:
+ RegBoost (); /* constructor */
+
+ int isValidSyntax( std::string &rline);
+
+}; /* ----- end of class RegBoost ----- */
+
+#endif /* ----- #ifndef regboost_INC ----- */
diff --git a/src/reglinux.cpp b/src/reglinux.cpp
new file mode 100644
index 0000000..854d1b4
--- /dev/null
+++ b/src/reglinux.cpp
@@ -0,0 +1,97 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: reglinux.cpp
+ *
+ * Description: Regex lib (linux version)
+ *
+ * Version: 0.2
+ * Created: 18/01/2014 01:16:04
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+#include <stdlib.h>
+#include "reglinux.hpp"
+
+/*
+ * Class: RegLinux
+ * Method: RegLinux :: RegLinux
+ * Description: Constructor
+ */
+RegLinux::RegLinux()
+{
+ comp();
+}
+
+
+/*
+ *--------------------------------------------------------------------------------------
+ * Class: RegLinux
+ * Method: RegLinux :: comp
+ * Description: Compile Regex
+ *--------------------------------------------------------------------------------------
+ */
+ void
+RegLinux::comp(void)
+{
+ int err = regcomp (reg, str_regex[0], REG_NOSUB | REG_EXTENDED);
+ if (err != 0)
+ {
+ printf("ERROR");
+ exit (EXIT_FAILURE);
+ }
+
+ for (int i = 0; i < REG_TAB_LEN ; i++, preg++)
+ {
+
+ err = regcomp (preg, str_regex[i], REG_NOSUB | REG_EXTENDED);
+ if (err != 0)
+ {
+ printf("ERROR");
+ exit (EXIT_FAILURE);
+ }
+ }
+}
+
+
+/*
+ *--------------------------------------------------------------------------------------
+ * Class: RegLinux
+ * Method: RegLinux :: isValidSyntax
+ * Description: Compile Regex
+ *--------------------------------------------------------------------------------------
+ */
+ int
+RegLinux::isValidSyntax ( std::string &rline )
+{
+ preg = ®[0];
+ int match;
+ for (int i = 0; i < REG_TAB_LEN; i++, preg++)
+ {
+ match = regexec (preg, rline.c_str(), 0, NULL, 0);
+ if (match == 0)
+ return i;
+ }
+ return -1;
+} /* ----- end of method RegLinux::isValidSyntax ----- */
+
+
diff --git a/src/reglinux.hpp b/src/reglinux.hpp
new file mode 100644
index 0000000..16ffd43
--- /dev/null
+++ b/src/reglinux.hpp
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: reglinux.hpp
+ *
+ * Description: Regex lib (linux version)
+ *
+ * Version: 0.2
+ * Created: 18/01/2014 01:16:31
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef reglinux_INC
+#define reglinux_INC
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <regex.h>
+#include <string.h>
+#include "define_ultimate_fct.h"
+#include "global.hpp"
+
+
+/*
+ * Class: RegLinux
+ * Description: Linux regex lib version
+ */
+
+class RegLinux
+{
+public:
+ RegLinux();
+ int isValidSyntax(std::string &rline);
+
+
+private:
+ void comp(void);
+
+ regex_t reg[REG_TAB_LEN];
+ regex_t *preg = ®[0];
+
+ const char *str_regex[REG_TAB_LEN] ={
+ "^C,[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,3}$", // C_FCT
+ "^D,[[:digit:]]{1,5}$", // D_FCT
+ "^RAMP,[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,3},[[:digit:]]{1,5}$", // RAMP_FCT
+ "^L,[[:digit:]]{1,3}$", // L_FCT
+ "^E$", // E_FCT
+ "^R,[[:digit:]]{1,3}$", // R_FCT
+ "^G,[[:digit:]]{1,3}$", // G_FCT
+ "^B,[[:digit:]]{1,3}$", // B_FCT
+ "^SUB,[-_[:alnum:]]+$", // SUB_FCT
+ "^DEFSUB,[-_[:alnum:]]+$", // DEFSUB_FCT
+ "^ENDSUB$", // ENDSUB_FCT
+ "^END$"}; // END_FCT
+};
+
+
+
+#endif /* ----- #ifndef reglinux_INC ----- */
diff --git a/src/rules.cpp b/src/rules.cpp
new file mode 100644
index 0000000..741a2cd
--- /dev/null
+++ b/src/rules.cpp
@@ -0,0 +1,198 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: rules.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 31/12/2013 18:33:14
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ *
+ */
+#include "rules.hpp"
+
+using namespace std;
+
+/*
+ * Class: Rules
+ * Method: Rules
+ * Description: constructor
+ */
+Rules::Rules (string gloFileName):
+ fileName(gloFileName)
+{
+} /* ----- end of method Rules::Rules (constructor) ----- */
+
+ bool
+Rules::isStandardCmdPossible(int nb_line, int fct)
+{
+ if(!end || defsub_cout )
+ return true;
+ else
+ {
+ string error = "invalid " + FctVectStr[fct] + " not in main sequence or sub-sequence";
+ throw RulesError( error.c_str() , fileName, nb_line );
+ return false;
+ }
+}
+ bool
+Rules::isDefsubCmdPossible()
+{
+
+ return true;
+}
+ bool
+Rules::isEndPossible()
+{
+
+ return true;
+}
+
+ bool
+Rules::isSeqOk()
+{
+ return true;
+
+}
+
+
+ void
+Rules::setEnd(int nb_line)
+{
+ if(!end && !loop_count)
+ end = true;
+ else
+ {
+ if(end)
+ {
+ string error = "Attempt to define more than one 'END command'";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ else
+ {
+ string error = "Reached end of main sequence with unterminated loop";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ }
+}
+
+ void
+Rules::setDefsub(int nb_line)
+{
+ if(!defsub_cout && end)
+ {
+ defsub_cout = nb_line;
+ }
+ else
+ {
+ if(!end)
+ {
+ string error = "Attempt to define subsequence before the main sequence is complete ";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ else
+ {
+ string error = "Attempting to define a subroutine inside another subroutine' ";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ }
+}
+
+ void
+Rules::unsetDefsub(int nb_line)
+{
+ if(defsub_cout && !loop_count)
+ {
+ defsub_cout = 0;
+ }
+ else
+ {
+ if (!defsub_cout)
+ {
+ string error = "ENDSUB without corresponding DEFSUB command";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ else
+ {
+ string error = "'ENDSUB command' found with unterminated 'Loop command'";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+ }
+}
+
+ void
+Rules::endTestDefsub()
+{
+ if (defsub_cout)
+ {
+ string error = "Reached EOF with unterminated 'DEFSUB command'";
+ throw RulesError(error.c_str(), fileName, defsub_cout);
+ }
+}
+
+
+
+ void
+Rules::setloop(int nb_line)
+{
+ isStandardCmdPossible(nb_line, L_FCT);
+ loop_count +=1;
+}
+
+ void
+Rules::unsetloop(int nb_line)
+{
+ isStandardCmdPossible(nb_line, E_FCT);
+ if (loop_count > 0)
+ loop_count -=1;
+ else
+ {
+ string error = "End Loop command with no Loop Command";
+ throw RulesError(error.c_str(), fileName, nb_line );
+ }
+}
+
+
+
+/*
+ * Class: Rules
+ * Method: Rules :: twiceDefsubError
+ * Description:
+ */
+ void
+Rules::twiceDefsubError(int nb_line)
+{
+ // to do : add class warning
+ throw RulesError("Error, more than one definition for a sub function !", fileName, nb_line );
+
+} /* ----- end of method Rules::twiceDefsubError ----- */
+
+ void
+Rules::noDefsubError(string sub_name)
+{
+ string error = "No definition for SUB," + sub_name ;
+ throw RulesError(error.c_str(), fileName);
+
+}
+
diff --git a/src/rules.hpp b/src/rules.hpp
new file mode 100644
index 0000000..a658fce
--- /dev/null
+++ b/src/rules.hpp
@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: rules.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 31/12/2013 18:32:35
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef rules_INC
+#define rules_INC
+#include "ruleserror.hpp"
+#include "define_ultimate_fct.h"
+#include <vector>
+#include "global.hpp"
+/*
+ * Class: Rules
+ * Description:
+ */
+class Rules
+{
+ public:
+ Rules (std::string gloFileName); /* constructor */
+ void twiceDefsubError(int nb_line);
+ void noDefsubError(std::string sub_name);
+
+ bool isStandardCmdPossible(int nb_line, int fct=0);
+ bool isDefsubCmdPossible();
+ bool isEndPossible();
+ bool isSeqOk();
+
+ /* END */
+ void setEnd(int nb_line);
+
+ /* DEFSUB */
+ void setDefsub(int nb_line);
+ void unsetDefsub(int nb_line);
+ void endTestDefsub();
+
+ /* LOOP */
+ void setloop(int nb_line);
+ void unsetloop(int nb_line);
+
+ private:
+ struct defsub
+ {
+ bool on = false;
+ int line = 0;
+ } ;
+
+ int defsub_cout = 0;
+ int loop_count = 0;
+ bool end = false;
+ std::string fileName;
+ std::vector<std::string> FctVectStr = {
+ "'C command'",
+ "'D command'",
+ "'RAMP command'",
+ "'L command'",
+ "'E command'",
+ "'R command'",
+ "'G command'",
+ "'B command'",
+ "'SUB command'",
+ "'DEFSUB command'",
+ "'ENDSUB command'",
+ "'END command'"
+ };
+}; /* ----- end of class Rules ----- */
+
+#endif /* ----- #ifndef rules_INC ----- */
diff --git a/src/ruleserror.hpp b/src/ruleserror.hpp
new file mode 100644
index 0000000..d84192d
--- /dev/null
+++ b/src/ruleserror.hpp
@@ -0,0 +1,81 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: rulesError.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 06/01/2014 10:04:32
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+
+#ifndef ruleserror_INC
+#define ruleserror_INC
+
+#include <iostream>
+#include <sstream>
+#include <exception>
+
+
+/*
+ * Class: RulesError
+ * Description:
+ */
+class RulesError : public std::exception
+{
+ public:
+ RulesError (const char * Msg, std::string fileName, int line)
+ {
+ std::ostringstream oss;
+ oss << "In File \"" << fileName << "\""
+ << ", Error line " << line << " : "
+ << Msg;
+ this->msg = oss.str();
+ } /* constructor 1 */
+
+ RulesError (const char * Msg, std::string fileName)
+ {
+ std::ostringstream oss;
+ oss << "In File \"" << fileName << "\""
+ << ", Error" << " : "
+ << Msg;
+ this->msg = oss.str();
+ } /* constructor 2 */
+
+ virtual ~RulesError() throw()
+ {
+ }
+
+ virtual const char* what() const throw()
+ {
+ return this->msg.c_str();
+ }
+
+ private:
+ std::string msg;
+
+}; /* ----- end of class RulesError ----- */
+
+#endif /* ----- #ifndef ruleserror_INC ----- */
diff --git a/src/serialboost.cpp b/src/serialboost.cpp
new file mode 100644
index 0000000..821fed8
--- /dev/null
+++ b/src/serialboost.cpp
@@ -0,0 +1,200 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: serialboost.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 20/12/2013 00:06:15
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+#include <serialboost.hpp>
+
+using namespace std;
+using namespace boost;
+
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: SerialBoost
+ * Description: Constructor
+ */
+SerialBoost::SerialBoost ( std::string port_name ):
+ port(port_io)
+{
+ try
+ {
+ port.open( port_name );
+ }
+ catch(boost::system::system_error& e)
+ {
+ cout<<"Serial Error ("<<e.what()<< ")" << endl;
+ throw;
+ }
+
+ typedef asio::serial_port_base asio_serial;
+ port.set_option(asio_serial::baud_rate(19200));
+ port.set_option(asio_serial::flow_control(asio_serial::flow_control::none));
+ port.set_option(asio_serial::parity( asio_serial::parity::none));
+ port.set_option(asio_serial::stop_bits( asio_serial::stop_bits::one));
+ port.set_option(asio_serial::character_size(8));
+
+} /* ----- end of Constructor ----- */
+
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: ~SerialBoost
+ * Description: Destructor
+ */
+SerialBoost::~SerialBoost ( )
+{
+ port.close();
+
+} /* ----- end of Destructor ----- */
+
+
+/**
+ * SEND A CHAR METHODS...
+ **/
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendChar
+ * Description: Write on serial port
+ * char version
+ */
+ void
+SerialBoost::sendChar(char c)
+{
+ port.write_some(asio::buffer(&c, 1));
+}
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendChar
+ * Description: Write on serial port
+ * unsigned Char version
+ */
+ void
+SerialBoost::sendChar(unsigned char c)
+{
+ port.write_some(asio::buffer(&c, 1));
+
+}
+
+/**
+ * SEND A STRING METHODS...
+ **/
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendString
+ * Description: Write on serial port
+ * (char* + nb) version
+ */
+ void
+SerialBoost::sendString(char* s, int nb_char)
+{
+ port.write_some(asio::buffer(s, nb_char));
+}
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendString
+ * Description: Write on serial port
+ * (unsigned char* + nb) version
+ */
+ void
+SerialBoost::sendString(unsigned char* s, int nb_char)
+{
+ port.write_some(asio::buffer(s, nb_char));
+}
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendString
+ * Description: Write on serial port
+ * (const char* + nb) version
+ */
+ void
+SerialBoost::sendString(const char* s, int nb_char)
+{
+ port.write_some(asio::buffer(s, nb_char));
+}
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: sendString
+ * Description: Write on serial port
+ * String version
+ */
+ void
+SerialBoost::sendString(string s)
+{
+ port.write_some(asio::buffer(s.c_str(),s.size()));
+}
+
+/**
+ * READ METHODS...
+ **/
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost ::readLine
+ * Description: Read on serial port
+ * Readline version
+ */
+ string
+SerialBoost::readLine()
+{
+ char c;
+ string result;
+ for(;;)
+ {
+ asio::read(port, asio::buffer(&c,1));
+ switch(c)
+ {
+ case '\r':
+ break;
+ case '\n':
+ return result;
+ default:
+ result+=c;
+ }
+ }
+}
+
+/*
+ * Class: SerialBoost
+ * Method: SerialBoost :: getString
+ * Description: Read on serial port
+ * (char* + nb-read) version
+ */
+void SerialBoost::getString(char* s, int nb_char)
+{
+ asio::read(port, asio::buffer(s, nb_char));
+}
+
+
diff --git a/src/serialboost.hpp b/src/serialboost.hpp
new file mode 100644
index 0000000..0b5dd9d
--- /dev/null
+++ b/src/serialboost.hpp
@@ -0,0 +1,69 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: serialboost.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 20/12/2013 00:06:28
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef serialboost_INC
+#define serialboost_INC
+
+#include <boost/asio.hpp>
+#include <boost/asio/serial_port.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/deadline_timer.hpp>
+#include <boost/ref.hpp>
+#include "global.hpp"
+
+/*
+ * Class: SerialBoost
+ * Description:
+ */
+class SerialBoost
+{
+ public:
+ SerialBoost (std::string port_name); /* constructor */
+ ~SerialBoost (); /* destructor */
+
+ void sendChar(char c);
+ void sendChar(unsigned char c);
+ void sendString(unsigned char* s, int nb_char);
+ void sendString(char* s, int nb_char);
+ void sendString(const char* s, int nb_char);
+ void sendString(std::string s);
+ void getString();
+ void getString(char* s, int nb_char);
+ std::string readLine();
+
+ protected:
+ boost::asio::io_service port_io;
+ boost::asio::serial_port port;
+
+}; /* ----- end of class SerialBoost ----- */
+
+#endif /* ----- #ifndef serialboost_INC ----- */
diff --git a/src/seriallinux.cpp b/src/seriallinux.cpp
new file mode 100644
index 0000000..27ba784
--- /dev/null
+++ b/src/seriallinux.cpp
@@ -0,0 +1,136 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: seriallinux.cpp
+ *
+ * Description: Serial lib linux (termios version)
+ * used if haven't boost
+ *
+ * Version: 0.2
+ * Created: 17/01/2014 03:31:32
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <iostream>
+#include <pthread.h>
+
+#include "seriallinux.hpp"
+
+
+using namespace std;
+
+/*
+ * Class: SerialLinux
+ * Description: open/write to serial port
+ */
+SerialLinux::SerialLinux(std::string dev)
+ {
+ memset(&tio,0,sizeof(tio));
+ tio.c_iflag= IGNPAR ;
+ tio.c_oflag=0;
+ tio.c_cflag= CS8|CREAD|CLOCAL ;
+ tio.c_lflag=0;
+ tio.c_cc[VMIN]=1;
+ tio.c_cc[VTIME]=0;
+
+ fd = open( dev.c_str(), O_RDWR | O_NOCTTY);
+ if(fd < 0)
+ {
+ perror("open");
+ printf("file => %s\n", dev.c_str());
+ exit(EXIT_FAILURE);
+ }
+
+ tcgetattr(fd,&old_tio);
+ tcflush(fd, TCIFLUSH);
+ cfsetospeed(&tio, B19200);
+ cfsetispeed(&tio, B19200);
+ tcsetattr(fd,TCSANOW,&tio);
+
+ }
+
+SerialLinux::~SerialLinux()
+{
+ tcsetattr(fd,TCSANOW,&old_tio);
+ fclose();
+}
+
+ void
+SerialLinux::sendChar(char c)
+{
+ write(fd,&c,1);
+}
+
+ void
+SerialLinux::sendString(uint8_t *c, int n)
+{
+ write(fd, c, n);
+}
+
+ string
+SerialLinux::readLine()
+{
+ char c[] = {0,0};
+ string result;
+ for(;;)
+ {
+ nb_read = read(fd, c, 1);
+ switch(c[0])
+ {
+ case '\r':
+ break;
+ case '\n':
+ return result;
+ default:
+ result+=c[0];
+ }
+ }
+}
+
+ void
+SerialLinux::fclose()
+{
+ if (close(fd)<0)
+ {
+ perror("close");
+ exit(EXIT_FAILURE);
+ }
+}
+
+
+ void
+SerialLinux::setspeed(speed_t vitesse)
+{
+ cfsetospeed(&tio, vitesse);
+ cfsetispeed(&tio, vitesse);
+ tcsetattr(fd,TCSANOW,&tio);
+}
+
+
+
+
diff --git a/src/seriallinux.hpp b/src/seriallinux.hpp
new file mode 100644
index 0000000..82b7475
--- /dev/null
+++ b/src/seriallinux.hpp
@@ -0,0 +1,66 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: seriallinux.hpp
+ *
+ * Description: Serial lib linux (termios version)
+ * used if haven't boost
+ *
+ * Version: 0.2
+ * Created: 17/01/2014 03:31:35
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+
+#ifndef seriallinux_INC
+#define seriallinux_INC
+
+#ifndef DEF_SERIAL
+#define DEF_SERIAL
+
+#include <termios.h>
+#include <unistd.h>
+#include "global.hpp"
+
+
+class SerialLinux
+{
+ public:
+ SerialLinux(std::string dev);
+ ~SerialLinux();
+ void sendChar(char c);
+ void sendString(uint8_t *c, int n);
+ std::string readLine();
+ void fclose();
+
+ private:
+ void setspeed(speed_t vitesse);
+ int nb_read;
+ struct termios tio, old_tio;
+ int fd;
+
+};
+#endif
+
+
+#endif /* ----- #ifndef seriallinux_INC ----- */
diff --git a/src/serialprop.cpp b/src/serialprop.cpp
new file mode 100644
index 0000000..309a75c
--- /dev/null
+++ b/src/serialprop.cpp
@@ -0,0 +1,70 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: serialprop.cpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 21/12/2013 01:39:53
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#include "serialprop.hpp"
+
+using namespace std;
+
+
+ void
+SerialProp::start()
+{
+ sendChar('o');
+}
+
+ void
+SerialProp::test()
+{
+ sendChar('t');
+}
+
+ void
+SerialProp::color(unsigned char red, unsigned char green, unsigned char blue )
+{
+ unsigned char rgb[5] = { 'c', red, green, blue, '\0'};
+ sendString(rgb, 4);
+}
+
+ void
+SerialProp::serialNumber(uint8_t * five)
+{
+ sendString(five, 5);
+}
+
+ string
+SerialProp::getSerial()
+{
+ string line;
+ sendChar('G');
+ line = readLine();
+ return line.erase(0,13);
+}
diff --git a/src/serialprop.hpp b/src/serialprop.hpp
new file mode 100644
index 0000000..d335c46
--- /dev/null
+++ b/src/serialprop.hpp
@@ -0,0 +1,77 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: serialprop.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 19/12/2013 23:25:14
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+
+#ifndef serialprop_INC
+#define serialprop_INC
+#include "global.hpp"
+#include "config.h"
+
+#if HAVE_TERMIOS_H==1
+#include "seriallinux.hpp"
+/*
+ * Class: SerialProp
+ * Description:
+ */
+class SerialProp : public SerialLinux
+{
+ public:
+ SerialProp (std::string port_name) : SerialLinux(port_name){}; /* constructor */
+
+ void test();
+ void start();
+ void color(unsigned char red, unsigned char green, unsigned char blue);
+ void serialNumber(uint8_t * five);
+ std::string getSerial();
+}; /* ----- end of class SerialAbs ----- */
+
+
+#else /* ----- not HAVE_TERMIOS_H ----- */
+ #include "serialboost.hpp"
+/*
+ * Class: SerialProp
+ * Description:
+ */
+class SerialProp : public SerialBoost
+{
+ public:
+ SerialProp (std::string port_name) : SerialBoost(port_name){}; /* constructor */
+
+ void test();
+ void start();
+ void color(unsigned char red, unsigned char green, unsigned char blue);
+ void serialNumber(uint8_t * five);
+ std::string getSerial();
+}; /* ----- end of class SerialAbs ----- */
+#endif /* ----- not HAVE_TERMIOS_H ----- */
+
+#endif /* ----- #ifndef serialabs_INC ----- */
diff --git a/src/ultimate.cpp b/src/ultimate.cpp
new file mode 100644
index 0000000..5efa0f9
--- /dev/null
+++ b/src/ultimate.cpp
@@ -0,0 +1,137 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: ultimatecmd.cpp
+ *
+ * Description: Interface for Ultimate props
+ *
+ * Version: 0.2
+ * Created: 19/12/2013 20:28:22
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+#include <stdlib.h>
+#include "ultimate.hpp"
+
+using namespace std;
+
+Ultimate::Ultimate ( string serial_name ):
+ ser(serial_name)
+{
+} /* ----- end of constructor ----- */
+
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: test
+ * Description:
+ */
+void Ultimate::test ()
+{
+ ser.test();
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: start
+ * Description:
+ */
+ void
+Ultimate::start ()
+{
+ ser.start();
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: color
+ * Description:
+ */
+ void
+Ultimate::color (unsigned char red, unsigned char green, unsigned char blue)
+{
+ ser.color(red, green, blue);
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: getSerial
+ * Description:
+ */
+ string
+Ultimate::getSerial ()
+{
+ string nb = ser.getSerial();
+ return nb;
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: uploadGloc
+ * Description:
+ */
+ int
+Ultimate::uploadGloc ( string filename)
+{
+ return sizeof(filename);
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: uploadGlo
+ * Description:
+ */
+ int
+Ultimate::uploadGlo ( string fileName)
+{
+ GloSeq file(fileName);
+ file.verify();
+ // to do add security
+ file.upload(ser);
+ return sizeof(fileName);
+}
+
+/*
+ * Class: Ultimate
+ * Method: Ultimate :: setSerialUlt
+ * Description:
+ */
+ void
+Ultimate::setSerialUlt(uint32_t serialNumber)
+{
+ cout << serialNumber << endl;
+ uint8_t ser_nb[6] = {83,0,0,0,0,0};
+
+ ser_nb[4] = (uint8_t)((serialNumber & 0xff000000UL) >> 24);
+ ser_nb[3] = (uint8_t)((serialNumber & 0x00ff0000UL) >> 16);
+ ser_nb[2] = (uint8_t)((serialNumber & 0x0000ff00UL) >> 8);
+ ser_nb[1] = (uint8_t)((serialNumber & 0x000000ffUL) );
+
+ for (int i = 0; i < 6; i++)
+ {
+ cout << (int)ser_nb[i] << endl;
+ }
+ ser.serialNumber(ser_nb) ;
+
+ exit (EXIT_FAILURE);
+
+}
diff --git a/src/ultimate.hpp b/src/ultimate.hpp
new file mode 100644
index 0000000..0375781
--- /dev/null
+++ b/src/ultimate.hpp
@@ -0,0 +1,66 @@
+/*
+ Copyright (C) 2014 BARRATERO Laurent
+
+ AeroUp 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 3 of the License, or
+ (at your option) any later version.
+
+ Aeroup 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.
+*/
+
+/*
+ * Filename: ultimatecmd.hpp
+ *
+ * Description:
+ *
+ * Version: 0.2
+ * Created: 19/12/2013 20:28:34
+ * Revision: none
+ * Compiler: gcc
+ *
+ * Author: BARATTERO Laurent, laurentba<at>larueluberlu.net
+ * Organization: La rue Luberlu
+ */
+
+#ifndef ultimate_INC
+#define ultimate_INC
+
+#include <string>
+#include "global.hpp"
+#include "serialprop.hpp"
+#include "gloseq.hpp"
+
+
+/*
+ * Class: Ultimate
+ * Description: Ultimate interface, access to all commands used by your props
+ */
+class Ultimate
+{
+ public:
+ Ultimate (std::string serial_name); /* constructor */
+
+ void start();
+ void test();
+ void color(unsigned char red,
+ unsigned char green,
+ unsigned char blue);
+ std::string getSerial();
+ int uploadGlo(std::string file_name);
+ int uploadGloc(std::string file_name);
+ void setSerialUlt(uint32_t serialNumber);
+
+ private:
+ SerialProp ser;
+
+}; /* ----- end of class UltimateCmd ----- */
+
+#endif /* ----- #ifndef ultimatecmd_INC ----- */
--
cgit v1.2.3