C:/Documents and Settings/gw/My Documents/Other projects/flightos/Core/module.h

Go to the documentation of this file.

/*
  Copyright (c) 2010 Les Newell. All rights reserved

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef MODULE_H_INCLUDED
#define MODULE_H_INCLUDED

#include "common.h"
#include "array.h"

class Socket;
class Socket8;
class Socket16;
class SocketF;
class PlugF;


#define MAX_MODULES 20

struct SOCKETRECORD
{
    Socket * socket;
    const char * name;
};

class SocketArray : public GrowArray<SOCKETRECORD>
{
public:
    ~SocketArray();
    void Add(const char * name, Socket * socket);
    Socket * Get(const char * name, const char * type = NULL);
    bool Replace(Socket* oldSocket, Socket * newSocket);
};



#define DECLARE_MODULE(Name,Parent)\
  public:\
    virtual const char * GetName(){return(#Name);}\
    virtual void PrintName(HardwareSerial& port){\
      port.print(#Name);\
      port.print(".");\
      Parent::PrintName(port);}


class Module
{
public:


    Module();


    virtual void Init(){}


    virtual void Reference(){};


    virtual void ParamChanged(Socket * param){};


    virtual void Loop(const unsigned long& interval){};




    virtual const char * GetName()
    {
        return("Module");
    }


    virtual void PrintName(HardwareSerial& port)
    {
        port.print("Module");
    };


    bool Poll(const long& time);


    Socket * GetSocket(const char * name, const char * type = NULL)
    {
        return(m_sockets.Get(name,type));
    }


    bool ReplaceSocket(Socket* oldSocket, Socket * newSocket)
    {
        return(m_sockets.Replace(oldSocket, newSocket));
    }


    SocketArray& GetSockets()
    {
        return(m_sockets);
    }

    inline bool IsRunning(){return(m_running);}

    inline int8_t GetPriority(){return(m_priority);}

    inline long GetMaxTime(){long t = m_cpuTime; m_cpuTime = 0; return(t);}


    int GetInterval(){return (m_interval / 1000);}

    inline void CheckTime(long time)
    {
        if(time > m_cpuTime)
        {
            m_cpuTime = time;
        }

    }

protected:



    void SetInterval(unsigned int time);


    void SetPriority(const int8_t priority)
    {
        m_priority = priority;
        if(m_priority > 100)
        {
            m_priority = 100;
        }
    }


    void AddSocket(const char * name, Socket * socket)
    {
        m_sockets.Add(name,socket);
    }


    void AddSocketArray(const char * names[], Socket8 sockets[], int n);

    void AddSocketArray(const char * names[], Socket16 sockets[], int n);

    void AddSocketArray(const char * names[], SocketF sockets[], int n);


    void ConnectPlugArray(const char * names[], PlugF plugs[], int n);

    inline float GetTime(const unsigned long& interval)
    {
        float result = interval;
        result /= 1000000;
        return (result);
    }

private:
    SocketArray m_sockets;
    long m_interval;
    long m_lastTime;
    volatile byte m_running;
    int8_t m_priority;
    long m_cpuTime;
};


#define MAX_THREADS 6

#define PRIORITY_NEVER -1


class ModuleManager
{
public:
    ModuleManager();


    void Init();



    Module * GetModule(const char * name);


    Socket * GetSocket(const char * name, const char * type = NULL, int * moduleNumber = NULL);


    bool ReplaceSocket(Socket* oldSocket, Socket * newSocket);



    bool ParseParameter(char * name, char * string);


    bool WriteParameters();


    void Reference();


    void Add(Module * module){m_modules.Add(module);}

    inline int GetCount(){return(m_modules.GetCount());}

    inline Module * GetModule(int mod){return (m_modules[mod]);}

    void PrintVersion(Print& print, const bool full);


    static void InterruptHandler();


    int GetOverloadCount(){int m = m_overloadCount; m_overloadCount = 0; return(m); }

    int GetMaxThreads(){int m = m_maxThreads; m_maxThreads = 0; return(m); }

    int GetHeartbeat(){return (m_heartbeat & 0x7fff);}

private:

    enum READMODE{modeREAD,modeWRITE,modeCHECKSUM};

    /*Read all of the parameters from non volatile memory
    this is automatically called during initialisation*/
    bool ReadParameters();
    bool ReadWriteParameters(const READMODE mode);
    void CreateChecksum();

    int m_checksum;
    static GrowArray<Module *> m_modules;
    static volatile int m_threadCount;
    static int m_maxThreads;
    static int m_overloadCount;
    static int m_heartbeat;
    static int8_t m_threadStack[MAX_THREADS + 1];
    bool m_started;

};

extern ModuleManager g_moduleManager;

#endif //#define MODULE_H_INCLUDED