vex_brain.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*    Copyright (c) Innovation First 2017, All rights reserved.               */
/*                                                                            */
/*    Module:     vex_brain.h                                                 */
/*    Author:     James Pearman                                               */
/*    Created:    8 July 2017                                                 */
/*                                                                            */
/*    Revisions:                                                              */
/*                V1.00     TBD - Initial release                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
 
#ifndef   VEX_BRAIN_CLASS_H
#define   VEX_BRAIN_CLASS_H
 
#include "vex_timer.h"
 
/*-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace vex {
  class brain {
    private:
      static  int32_t _index;
      
    public:
      brain();
      ~brain();
 
    private:
      enum class tEventType {
        EVENT_UP_PRESSED     = 1,
        EVENT_UP_RELEASED    = 2,
        EVENT_DOWN_PRESSED   = 4,
        EVENT_DOWN_RELEASED  = 8,
        EVENT_CHECK_PRESSED  = 16,
        EVENT_CHECK_RELEASED = 32
      };
 
    public:
      class button {
        private:
          uint8_t  _id;
          
        public:
          button() : _id( -1 ) {};
          button( const int id ) : _id( id ) {};
          ~button() {};
          
          void    pressed( void (* callback)(void) );
          void    released( void (* callback)(void) );
         bool     pressing( void );        
      };
      
      button       buttonUp    = button(0);
      button      &buttonLeft  = buttonUp;
      button       buttonDown  = button(1);
      button      &buttonRight = buttonDown;
      button       buttonCheck = button(2);
      
      class lcd {
        private:
          int16_t   _row;
          int16_t   _maxrows;
          int16_t   _rowheight;
          
          int16_t   _col;
          int16_t   _maxcols;
 
          int32_t   _penWidth;
 
          char      _textStr[32];
          
          bool      _fg_color;
          bool      _bg_color;
          bool      _transparent;
          bool      _aspect_compensation;
          
          int       _origin_x;
          int       _origin_y;
 
          int32_t   rowToPixel( int32_t row );
          int32_t   colToPixel( int32_t col );
          int32_t   scaley( int32_t y );
          
        public:
          lcd();
          ~lcd() {};
                  
          void     setCursor( int32_t row, int32_t col ); 
 
          void     setPenWidth( uint32_t width ); 
 
          void     setOrigin( int32_t x, int32_t y );
 
          void     setAspectCompensation( bool value );
 
          int32_t  column();
 
          int32_t  row();
 
          void     setPenColor( colorType color );
 
          void     setFillColor( colorType color );
 
          void     print( const char *format, ... );
          void     print( char *format, ... );
 
          void     printAt( int32_t x, int32_t y, const char *format, ... );
 
          void     clearScreen( void );
 
          void     clearLine( int number );
 
          void     clearLine( void );
 
          void     newLine( void );
 
          void     drawPixel( int x, int y );
 
          void     drawLine( int x1, int y1, int x2, int y2 );
 
          void     drawRectangle( int x, int y, int width, int height );
          
          void     drawRectangle( int x, int y, int width, int height, colorType color );
 
 
          void     invertRectangle( int x, int y, int width, int height );
 
          void     drawCircle( int x, int y, int radius );
 
          void     drawCircle( int x, int y, int radius, colorType color );
 
          void     invertCircle( int x, int y, int radius );
      };
      
      lcd         Screen;
 
      double      timer( timeUnits units );
 
      void        resetTimer();
 
      void        setTimer( double value, timeUnits units );
 
      vex::timer  Timer;
 
      class battery {
        public:
          battery() {};
          ~battery() {};
 
          uint16_t  capacity( percentUnits units = percentUnits::pct );
 
          double    voltage( voltageUnits units = voltageUnits::volt );
      };
      
      battery     Battery;
      
      // we need to avoid using printf or std::cout
      // as it uses too much memory
      class terminal {
        public:
          terminal() {};
          ~terminal() {};
          
          void print( const char *fmt, ... );
      };
      
      terminal    Terminal;
                
      void        playSound( soundType sound );
      void        playNote( int32_t octave, int32_t note );
      void        playNote( int32_t octave, int32_t note, int32_t ms );
      void        soundOff( void );
      void        programStop();
  };
};
 
#endif // VEX_BRAIN_CLASS_H