NIBOburger.h

gehe zur Dokumentation dieser Datei

/*
  NIBOburger library for ARDUINO
  License: BSD-License
  (c) 2015 by Nils Springob, nicai-systems
*/

#ifndef __NIBOBURGER_H__
#define __NIBOBURGER_H__


#if (!defined (_NIBOBURGER_)) && (!defined (ARDUINO_AVR_NIBOBURGER)) && (!defined (ARDUINO_AVR_NIBOBURGER_1284_15)) && (!defined (ARDUINO_AVR_NIBOBURGER_1284_20))
#error "NIBOburger library should be used with a NIBOburger robot as board!"
#endif

#include "niboburger/color.h"


#define ON 1
#define OFF 0

#define LED1 1
#define LED2 2
#define LED3 3
#define LED4 4

class NIBOburgerClass {
  public:
    NIBOburgerClass();
    
    void begin();
    
    unsigned int getVoltage();
    
    void setMonitorVoltage(unsigned int millivolt);
    
    void checkVoltage();
    
    void setLeds(bool led1, bool led2, bool led3, bool led4);
    
    void setLed(int led, int value);
    
    int getLed(int led);
    
    void waitAnalogUpdate();

    unsigned int getAnalog(unsigned char adc_channel, unsigned char active=0);
    
    unsigned int getKeyState();
      
    unsigned int getKeyChar();

    unsigned int getRandomSeed();
    
    void randomize(unsigned int seed);
    
    void randomize();

    int getRandomInt(int lo, int hi);
};

extern NIBOburgerClass NIBOburger;


/*---------------------------------------------------------------------------*/


    
class EnginePartClass {
  private:
    unsigned char id;
  public:
    EnginePartClass(unsigned char id);
    
    void resetTicks();

    int getTicks();
    //int getSpeed();
};


/*---------------------------------------------------------------------------*/


    
class EngineClass {
  public:
    
    EnginePartClass left;
    
    EnginePartClass right;
    EngineClass();
    
    void begin();
    
    void setPWM(int left, int right);  
    
    void setSpeed(int left, int right);
    
    void setTargetAbs(int left, int right, unsigned int speed);
    
    void setTargetRel(int left, int right, unsigned int speed);
    
    int getTargetDist();
    
    void stop();
    
    void stopImmediate();
};

extern EngineClass Engine;


/*---------------------------------------------------------------------------*/

    
class ColorRGB {
  private:
    unsigned long value;
  public:
    static const unsigned long CALIBRATE_BLACK  = COLOR_RGB_CAL_BLACK;  
    static const unsigned long CALIBRATE_WHITE  = COLOR_RGB_CAL_WHITE;  
    static const unsigned long CALIBRATE_RED    = COLOR_RGB_CAL_RED;    
    static const unsigned long CALIBRATE_BLUE   = COLOR_RGB_CAL_BLUE;   
    static const unsigned long CALIBRATE_GREEN  = COLOR_RGB_CAL_GREEN;  
    static const unsigned long CALIBRATE_YELLOW = COLOR_RGB_CAL_YELLOW; 

    ColorRGB(unsigned char r, unsigned char g, unsigned char b);

    explicit ColorRGB(unsigned long val);

    ~ColorRGB();
    
    unsigned int diff(const ColorRGB & col2) const;
    
    unsigned int diff(unsigned long val2) const;
};

/*---------------------------------------------------------------------------*/

    
class ColorHSV {
  private:
    unsigned long value;
  public:
    static const unsigned long CALIBRATE_BLACK  = COLOR_HSV_CAL_BLACK;  
    static const unsigned long CALIBRATE_WHITE  = COLOR_HSV_CAL_WHITE;  
    static const unsigned long CALIBRATE_RED    = COLOR_HSV_CAL_RED;    
    static const unsigned long CALIBRATE_BLUE   = COLOR_HSV_CAL_BLUE;   
    static const unsigned long CALIBRATE_GREEN  = COLOR_HSV_CAL_GREEN;  
    static const unsigned long CALIBRATE_YELLOW = COLOR_HSV_CAL_YELLOW; 

    ColorHSV(unsigned char h, unsigned char s, unsigned char v);

    explicit ColorHSV(unsigned long val);

    ~ColorHSV();
    
    unsigned int diff(const ColorHSV & col2, unsigned int hTol=0) const;
    
    unsigned int diff(unsigned long val2, unsigned int hTol=0) const;
};

/*---------------------------------------------------------------------------*/

    
class SurfaceSensorClass {
  public:
    SurfaceSensorClass();
    
    void begin();
    
    unsigned int get(unsigned char index, unsigned char absolute=0);
    
    unsigned int getL(unsigned char absolute=0);
    
    unsigned int getC(unsigned char absolute=0);
    
    unsigned int getR(unsigned char absolute=0);
    
    unsigned int getCL(unsigned char absolute=0);
    
    unsigned int getCR(unsigned char absolute=0);
    
    ColorRGB getColorRGB();
    
    ColorHSV getColorHSV();
    
    void calibrateWhite();
    
    void calibrateBlack();
    
    void storeCalibration();
};

extern SurfaceSensorClass SurfaceSensor;



/*---------------------------------------------------------------------------*/


enum {
  SENSOR_DISABLED = 0,
  SENSOR_PULSE    = 1,
  SENSOR_LOW      = 2,
  SENSOR_HIGH     = 3
};

class SensorClass {
  private:
    unsigned char id;
  public:
    SensorClass(unsigned char id);
    
    void begin();
    
    void activate(unsigned char mode);
    
    void deactivate();
    
    unsigned int get(unsigned char absolute=0);
    //unsigned int getRaw(unsigned char variant);
};

    
extern SensorClass SensorFL;
    
extern SensorClass SensorFR;
    
extern SensorClass SensorFLL;
    
extern SensorClass SensorFRR;
    
extern SensorClass SensorBL;
    
extern SensorClass SensorBC;
    
extern SensorClass SensorBR;


#endif