mthread.h

Go to the documentation of this file.

// -*- mode: c++ -*-


// Arduino Multi-Threading Library (mthread)

// Copyright (C) 2010-2012 Jonathan Lamothe <jonathan@jlamothe.net>

// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation, either version 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
// Lesser General Public License for more details.

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

#ifndef MTHREAD_H
#define MTHREAD_H

//
// INCLUDES
//

#include "../newdel/newdel.h"

#define DEFAULT_DEBOUNCE 50

class ThreadList;
void loop(void);

//
// CLASSES
//

class Thread
{
public:

    enum Mode
    {

        run_mode,

        pause_mode,

        sleep_mode,

        sleep_milli_mode,

        sleep_micro_mode,

        kill_mode

    };

    Thread();

    virtual ~Thread();

    Mode get_mode() const;

    bool kill(bool force = false);

    bool pause();

    bool resume();

    bool sleep(unsigned long t);

    bool sleep_micro(unsigned long t);

    bool sleep_milli(unsigned long t);

protected:

    virtual bool loop();

    bool kill_flag;

private:

    bool call();

    unsigned long stop_time;

    unsigned long wait_time;

    Mode mode;

    friend class ThreadList;
    friend void loop(void);
};

class ThreadList : public Thread
{
public:


    ThreadList(bool keep = false);

    ~ThreadList();

    bool add_thread(Thread *t);

protected:

    bool loop();

private:

    Thread **thread;

    unsigned thread_count;

    unsigned thread_index;

    bool keep_flag;

};

class EventHandler : public Thread
{
public:

    EventHandler();

    virtual ~EventHandler();

protected:

    virtual bool condition();

    bool loop();

    virtual bool on_event();

private:

    bool trigger;

};

class SwitchInput : public Thread
{
public:

    enum Type {

        pull_up_internal,

        pull_up,

        pull_down

    };

    SwitchInput(int pin,
                unsigned long debounce = DEFAULT_DEBOUNCE,
                Type type = pull_up_internal);

    virtual ~SwitchInput();

    bool is_closed() const;

    bool is_open() const;

    virtual void on_close();

    virtual void on_open();

    unsigned long time_closed() const;

    unsigned long time_open() const;

protected:

    bool loop();

private:

    unsigned long debounce;

    unsigned long last_change;

    unsigned long last_debounce;

    int current_value;

    int last_value;

    int pin;

    Type type;

};

extern ThreadList *main_thread_list;

#endif  // MTHREAD_H

// jl