spogobot.h

Go to the documentation of this file.

#ifndef POGOBOT_H
#define POGOBOT_H
 
#include <stddef.h> /* size_t */
#include <stdint.h> /* uint8_t and friends */
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <time.h> 
#include <stdbool.h>
 
#include "FifoBuffer.h"
 
// Create a macro to specify that we are using a simulator, and not real Pogobots
#define SIMULATOR
 
// Rename the main function from the robot code. The simulator uses a different main function.
#define main robot_main
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
 
/************************* POGOLIB API ************************ {{{1 */
 
#define IR_RX_COUNT 4
 


void pogobot_init(void);

 
#ifndef MAX_PAYLOAD_SIZE_BYTES
#define MAX_PAYLOAD_SIZE_BYTES 382
#endif /* MAX_PAYLOAD_SIZE_BYTES */

 
#ifndef MAX_NUMBER_OF_WORD
#define MAX_NUMBER_OF_WORD 20
#endif /* MAX_NUMBER_OF_WORD */

 
#define pogobot_infrared_emitter_power_max 3
#define pogobot_infrared_emitter_power_twoThird 2
#define pogobot_infrared_emitter_power_oneThird 1
#define pogobot_infrared_emitter_power_null 0
 
#define pogobot_infrared_emitter_width_bits 2
 
#define pogobot_infrared_emitting_power_list( front, right, back, left )       \
    ( front ) | ( ( right ) << ( pogobot_infrared_emitter_width_bits ) ) |     \
        ( ( back ) << ( 2 * pogobot_infrared_emitter_width_bits ) ) |          \
        ( ( left ) << ( 3 * pogobot_infrared_emitter_width_bits ) )
 
#define get_infrared_emitter_dir(dir, emitting_power_list) (((emitting_power_list) >> ((pogobot_infrared_emitter_width_bits) * (dir))) & 0x03)
 
enum
{
    pogobot_infrared_emitting_power_list_front_full =
        ( pogobot_infrared_emitter_power_max ),
    pogobot_infrared_emitting_power_list_right_full =
        ( ( pogobot_infrared_emitter_power_max )
          << ( pogobot_infrared_emitter_width_bits ) ),
    pogobot_infrared_emitting_power_list_back_full =
        ( ( pogobot_infrared_emitter_power_max )
          << ( 2 * pogobot_infrared_emitter_width_bits ) ),
    pogobot_infrared_emitting_power_list_left_full =
        ( ( pogobot_infrared_emitter_power_max )
          << ( 3 * pogobot_infrared_emitter_width_bits ) ),
    pogobot_infrared_emitting_power_list_all_full =
        ( pogobot_infrared_emitter_power_max *
          ( 1 | ( 1 << pogobot_infrared_emitter_width_bits ) |
            ( 1 << ( 2 * pogobot_infrared_emitter_width_bits ) ) |
            ( 1 << ( 3 * pogobot_infrared_emitter_width_bits ) ) ) ),
};
 
/*static inline uint8_t
pogobot_infrared_emitter_byindex(uint8_t index)
{
    return (1<<index)
};*/
 
/* Private, implementation part */
 
#define pogobot_infrared_emitter_front_mask ( 1 << 0 )
#define pogobot_infrared_emitter_right_mask ( 1 << 8 )
#define pogobot_infrared_emitter_back_mask  ( 1 << 16 )
#define pogobot_infrared_emitter_left_mask  ( 1 << 24 )
 
#define pogobot_infrared_emitter_mask_byindex( index ) ( 1 << ( 8 * index ) )
 
typedef union emitting_power_list_t
{
    uint32_t number;
    struct
    {
        uint8_t front;
        uint8_t left;
        uint8_t back;
        uint8_t right;
    } fields;
    uint8_t array[4];
} emitting_power_list_t;
 

typedef enum
{
    ir_front = 0,
    ir_right = 1,
    ir_back = 2,
    ir_left = 3,
    ir_all = 4
} ir_direction;
 
 
// From pogolib/slip.h in pogobot repository
typedef struct 
{
    uint32_t overflow_counter;
    uint32_t unknown_escaped_byte_counter;
    uint32_t crc_mismatch_counter;
} slip_error_counter_s;
 
 
 
/* ******************************** ******************************** */

 
typedef struct message_header_t
{
    uint8_t _packet_type;
    uint8_t _emitting_power_list;
    uint16_t _sender_id;
    uint8_t _sender_ir_index;
    uint8_t _receiver_ir_index;
    uint16_t payload_length;
} message_header_t;

 
typedef struct message_t
{
    message_header_t header;
    uint8_t payload[MAX_PAYLOAD_SIZE_BYTES];
} message_t;

 
typedef struct message_short_header_t
{
    uint8_t _packet_type;
    uint16_t payload_length;
} message_short_header_t;

 
typedef struct short_message_t
{
    message_short_header_t header;
    uint8_t payload[MAX_PAYLOAD_SIZE_BYTES];
} short_message_t;

 
typedef enum
{
    ir_t_cmd = 1,   // only to send command to the robot
    ir_t_flash = 2, // only to send part of the prog
    ir_t_short = 3, // only to send short header message
    ir_t_user = 16  // userspace
} ir_type_message;
 
 
/* ******************************** ******************************** */
 
/* fifo */
 
#define NUMEL 20
FifoBuffer_typedef( message_t, Messagefifo );
 
extern Messagefifo my_mes_fifo;
extern Messagefifo *my_mes_fifo_p;
 
/* ******************************** ******************************** */


void pogobot_infrared_ll_init( void );

void pogobot_infrared_update( void );

int pogobot_infrared_message_available( void );

void pogobot_infrared_recover_next_message( message_t *mes );

void pogobot_infrared_clear_message_queue( void );

void pogobot_infrared_set_power( uint8_t power );

uint32_t pogobot_infrared_sendRawLongMessage( message_t *const message );

uint32_t pogobot_infrared_sendRawShortMessage( ir_direction dir, short_message_t *const message );

uint32_t pogobot_infrared_sendLongMessage_uniSpe( ir_direction dir, uint8_t *message, uint16_t message_size );

uint32_t pogobot_infrared_sendLongMessage_omniGen( uint8_t *message, uint16_t message_size );

uint32_t pogobot_infrared_sendLongMessage_omniSpe( uint8_t *message, uint16_t message_size );
 

uint32_t pogobot_infrared_sendShortMessage_uni( ir_direction dir, uint8_t *message, uint16_t message_size );

uint32_t pogobot_infrared_sendShortMessage_omni( uint8_t *message, uint16_t message_size );
 

void pogobot_infrared_get_receiver_error_counter( slip_error_counter_s *error_counter, uint8_t ir_index );

void pogobot_infrared_reset_receiver_error_counter( void );


void pogobot_led_setColor(const uint8_t r, const uint8_t g, const uint8_t b);
 

void pogobot_led_setColors(const uint8_t r, const uint8_t g, const uint8_t b, uint8_t id);
 


 
typedef enum
{
    p_FL = 1,
    p_FR = 2,
    p_B = 0
} photosensor_id;
 


int16_t pogobot_photosensors_read( uint8_t sensor_number );
 


void pogobot_imu_read( float *acc, float *gyro );

float pogobot_imu_readTemp( void );
 


int16_t pogobot_battery_voltage_read( void );


 
typedef enum
{
    motorR = 0, // Right
    motorL = 1, // Left
    motorB = 2  // Back
} motor_id;

 
typedef enum
{
    motorStop = 0,
    motorQuarter = 256,
    motorHalf = 512,
    motorThreeQuarter = 716,
    motorFull = 1023
} motor_range;
 


void pogobot_motor_power_set( motor_id motor, uint16_t value );
void pogobot_motor_set ( motor_id motor, uint16_t value );

uint32_t pogobot_motor_dir_current_status( void );

int8_t pogobot_motor_dir_mem_get( uint8_t *p_directions );

int8_t pogobot_motor_dir_mem_set( uint8_t *p_directions);

void pogobot_motor_dir_set( motor_id motor, uint8_t value );

uint8_t pogobot_motor_power_mem_get( uint16_t *p_powers );

uint8_t pogobot_motor_power_mem_set( uint16_t *p_powers );
 
 


uint16_t pogobot_helper_getid(void);

int16_t pogobot_helper_getRandSeed( void );

void pogobot_helper_print_version( void );
 

 


void pli_timer_sleep_stopwatch_init( void );

// Original Pogobot.h struct:
//typedef struct time_reference_t
//{
//    uint32_t hardware_value_at_time_origin;
//} time_reference_t;
 
typedef struct time_reference_t {
#ifdef __cplusplus
    void reset();
    uint32_t get_elapsed_microseconds();
    void enable();
    void disable();
    void add_elapsed_microseconds(uint64_t microseconds);
    void offset_origin_microseconds(uint64_t microseconds);
#endif
 
    uint32_t hardware_value_at_time_origin;
    bool enabled;
    //std::chrono::time_point<std::chrono::system_clock> start_time;
    uint64_t start_time;
    uint32_t elapsed_ms;
} time_reference_t;
 

void pogobot_stopwatch_reset( time_reference_t *stopwatch );

int32_t pogobot_stopwatch_lap( time_reference_t *stopwatch );

int32_t pogobot_stopwatch_get_elapsed_microseconds( time_reference_t *stopwatch );

void pogobot_stopwatch_offset_origin_microseconds( time_reference_t *stopwatch, int32_t microseconds_offset );

void pogobot_timer_init( time_reference_t *timer, int32_t microseconds_to_go );

int32_t pogobot_timer_get_remaining_microseconds( time_reference_t *timer );

bool pogobot_timer_has_expired( time_reference_t *timer );

void pogobot_timer_wait_for_expiry( time_reference_t *timer );

void pogobot_timer_offset_origin_microseconds( time_reference_t *timer, int32_t microseconds_offset );
 
 
#ifdef __cplusplus
}
#endif
 
 
/************************* General API ************************ {{{1 */
 
#ifdef __cplusplus
extern "C" {
#endif
 
void msleep(int milliseconds);
void pogosim_printf(const char* format, ...);
int pogosim_putchar(int ch);

uint32_t get_nb_robots(void);

void stop_simulation(void);
 
void data_add_column_int8(char const* name);
void data_add_column_int16(char const* name);
void data_add_column_int32(char const* name);
void data_add_column_int64(char const* name);
void data_add_column_double(char const* name);
void data_add_column_string(char const* name);
void data_add_column_bool(char const* name);
void data_add_column_float16(char const* name);
 
void enable_data_export(void);
void disable_data_export(void);
 
void data_set_value_int8(char const* name, int8_t value);
void data_set_value_int16(char const* name, int16_t value);
void data_set_value_int32(char const* name, int32_t value);
void data_set_value_int64(char const* name, int64_t value);
void data_set_value_double(char const* name, double value);
void data_set_value_string(char const* name, char const* value);
void data_set_value_bool(char const* name, bool value);
void data_set_value_float16(char const* name, float value);
 
void init_bool_from_configuration(bool* var, char const* name, bool const default_value);
void init_double_from_configuration(double* var, char const* name, double const default_value);
void init_float_from_configuration(float* var, char const* name, float const default_value);
void init_int32_from_configuration(int32_t* var, char const* name, int32_t const default_value);
void init_uint32_from_configuration(uint32_t* var, char const* name, uint32_t const default_value);
void init_int16_from_configuration(int16_t* var, char const* name, int16_t const default_value);
void init_uint16_from_configuration(uint16_t* var, char const* name, uint16_t const default_value);
void init_int8_from_configuration(int8_t* var, char const* name, int8_t const default_value);
void init_uint8_from_configuration(uint8_t* var, char const* name, uint8_t const default_value);
void init_float_array_from_configuration(float* var, char const* name, size_t const size);
void init_double_array_from_configuration(double* var, char const* name, size_t const size);
void init_string_from_configuration(char *var, char const *name, size_t const size);
 
#ifdef __cplusplus
}
#endif
 
// Generic variable initialization from configuration (only from C code)
#ifndef __cplusplus
#define init_from_configuration(x)                                          \
    _Generic ((x),                                                          \
        bool:     init_bool_from_configuration,                             \
        double:   init_double_from_configuration,                           \
        float:    init_float_from_configuration,                            \
        int32_t:  init_int32_from_configuration,                            \
        uint32_t: init_uint32_from_configuration,                           \
        int16_t:  init_int16_from_configuration,                            \
        uint16_t: init_uint16_from_configuration,                           \
        int8_t:   init_int8_from_configuration,                             \
        uint8_t:  init_uint8_from_configuration                             \
    )(&(x), #x, (x))
 
#define init_array_from_configuration(a)                                   \
    _Generic (&(a),                                                        \
        float  (*)[] : init_float_array_from_configuration,                \
        double (*)[] : init_double_array_from_configuration,               \
        char   (*)[] : init_string_from_configuration                      \
    )((a), #a, sizeof(a) / sizeof((a)[0]))
#endif
 
// Define custom printf as the default in files including pogosim.h
#define printf pogosim_printf
#define putchar pogosim_putchar
 
 
#endif
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker