feldbus_base.h

 
#ifndef TINA_FELDBUS_SLAVE_FELDBUS_H_
#define TINA_FELDBUS_SLAVE_FELDBUS_H_
 
 
#include <feldbus/util/xor_checksum.h>
#include <feldbus/util/crc_checksum.h>
 
#include "feldbus_config_check.h"
 
 
 
#ifdef __cplusplus
# include <cstdlib>
# include <cstddef>
# include <cstring>
 
extern "C" {
#else
# include <stdlib.h>
# include <string.h>
# include <stdbool.h>
#endif
 
 
 
 
 
extern void turag_feldbus_hardware_init(void);
 
extern void turag_feldbus_device_rts_off(void);
 
extern void turag_feldbus_device_rts_on(void);
 
extern void turag_feldbus_device_activate_dre_interrupt(void);
 
extern void turag_feldbus_device_deactivate_dre_interrupt(void);
 
extern void turag_feldbus_device_activate_rx_interrupt(void);
 
extern void turag_feldbus_device_deactivate_rx_interrupt(void);
 
extern void turag_feldbus_device_activate_tx_interrupt(void);
 
extern void turag_feldbus_device_deactivate_tx_interrupt(void);
 
extern void turag_feldbus_device_start_receive_timeout(void);
 
extern void turag_feldbus_device_begin_interrupt_protect(void);
 
extern void turag_feldbus_device_end_interrupt_protect(void);
 
extern void turag_feldbus_device_toggle_led(void);
 
extern void turag_feldbus_device_transmit_byte(uint8_t byte);
 
extern void turag_feldbus_device_enable_bus_neighbours();
 
extern void turag_feldbus_device_disable_bus_neighbours();
 
extern void turag_feldbus_device_assert_low();
 
extern void turag_feldbus_device_goto_sleep();
 
extern void turag_feldbus_device_goto_deep_sleep();
 
extern uint32_t turag_feldbus_device_get_static_storage_capacity();
 
extern uint16_t turag_feldbus_device_get_static_storage_page_size();
 
extern uint8_t turag_feldbus_device_read_from_static_storage(uint32_t offset, uint16_t size, uint8_t* buffer);
 
extern uint8_t turag_feldbus_device_write_to_static_storage(uint32_t offset, const uint8_t* data, uint16_t size);
 
 
 
 
 
 
static inline void turag_feldbus_device_byte_received(uint8_t data);
 
static inline void turag_feldbus_device_ready_to_transmit(void);
 
static inline void turag_feldbus_device_transmission_complete(void);
 
static inline void turag_feldbus_device_receive_timeout_occured(void);
 
#if defined(__DOXYGEN__)
static inline void turag_feldbus_device_increase_uptime_counter(void);
#endif
 
 
 
#if defined(__DOXYGEN__)
# define TURAG_FELDBUS_NO_ANSWER        <configuration-dependend>
#endif
 
#if defined(__DOXYGEN__)
typedef int FeldbusSize_t;
#endif
 
typedef uint8_t FeldbusAddress_t;
 
 
 
 
 
typedef FeldbusSize_t (*TuragFeldbusPacketProcessor)(const uint8_t* message, FeldbusSize_t message_length, uint8_t* response);
 
 
typedef void (*TuragFeldbusBroadcastProcessor)(const uint8_t* message, FeldbusSize_t message_length, uint8_t protocol_id);
 
 
 
 
 
 
void turag_feldbus_device_init(
        FeldbusAddress_t bus_address, uint32_t uuid,
        const char* name, const char* version_info,
        uint8_t device_protocol, uint8_t device_type,
        TuragFeldbusPacketProcessor packetProcessor,
        TuragFeldbusBroadcastProcessor broadcastProcessor);
 
 
uint32_t turag_feldbus_device_hash_uuid(const uint8_t* key, size_t length);
 
void turag_feldbus_do_processing(void);
 
 
 
 
 
// debugging functions
#if TURAG_FELDBUS_DEVICE_CONFIG_DEBUG_ENABLED || defined(__DOXYGEN__)
    void print_text(const char*);   
    
    void print_char(uint8_t);   
    
    void print_short(uint16_t);
    
    void print_sshort(int16_t x);
    
    void print_long(uint32_t x);
    
    void print_short_d(int16_t x);
    
    void print_slong(int32_t);
    
    void print_sshort_nn(int16_t x);
    
    void print_short_nn(uint16_t x);
    
    #define TURAG_FELDBUS_DEBUG_SAFE(function) function; while (turag_feldbus_device.transmission_active)
#else
#   define print_text(x)
#   define print_char(x)
#   define print_short(x)
#   define print_sshort(x)
#   define print_long(x)
#   define print_short_d(x)
#   define print_slong(x)
#   define print_sshort_nn(x)
#   define print_short_nn(x)
#endif
    
#ifdef __cplusplus
}
#endif
    
// hide some uninteresting stuff from documentation
#if (!defined(__DOXYGEN__))
        
#define TURAG_FELDBUS_DEVICE_ACTUAL_BUFFER_SIZE  (TURAG_FELDBUS_DEVICE_CONFIG_BUFFER_SIZE + TURAG_FELDBUS_DEVICE_CONFIG_ADDRESS_LENGTH + TURAG_FELDBUS_DEVICE_CRC_SIZE)
 
typedef struct {
    // holds the number of bytes in txbuf
    FeldbusSize_t transmitLength;
    // offset in txbuf
    FeldbusSize_t txOffset;
    // offset in rxBuf
    FeldbusSize_t rxOffset;
    // if not 0, then there is a package waiting for processsing
    volatile FeldbusSize_t rx_length;
    // overflow detected
    bool overflow;
    // package loss detected and counter must be increased
    bool package_lost_flag;
    // overflow detected and counter must be increased
    bool buffer_overflow_flag;
#if TURAG_FELDBUS_DEVICE_CONFIG_DEBUG_ENABLED
    volatile bool transmission_active;
#endif
    volatile bool toggleLedBlocked;
    TuragFeldbusPacketProcessor packet_processor;
    TuragFeldbusBroadcastProcessor broadcast_processor;
    // bus address of the device
    FeldbusAddress_t my_address;
    const char* name;
    size_t name_length;
    const char* versioninfo;
    size_t version_info_length;
    uint8_t device_protocol;
    uint8_t device_type;
    uint32_t packagecount_correct;
    uint32_t packagecount_buffer_overflow;
    uint32_t packagecount_lost;
    uint32_t packagecount_chksum_mismatch;
    uint32_t uptime_counter;
    // uuid of the device
    uint8_t uuid[4] __attribute__((aligned(4)));
    uint8_t txbuf[TURAG_FELDBUS_DEVICE_ACTUAL_BUFFER_SIZE] __attribute__((aligned(4)));
    uint8_t rxbuf[TURAG_FELDBUS_DEVICE_ACTUAL_BUFFER_SIZE] __attribute__((aligned(4)));
} turag_feldbus_device_t;
 
 
extern turag_feldbus_device_t turag_feldbus_device;
 
 
 
 
#endif // (!defined(__DOXYGEN__))
 
    
#ifdef __cplusplus
extern "C" {
#endif
 
static inline void turag_feldbus_device_byte_received(uint8_t data) {
    // if at this point rx_length is not 0, obviously the last 
    // received package was not processed yet. This package
    // will be overwritten now and is lost.
    // Once rx_length is cleared, turag_feldbus_do_processing() will no longer
    // try to copy packages from the in-buffer.
    if (turag_feldbus_device.rx_length) {
        turag_feldbus_device.rx_length = 0;
        turag_feldbus_device.package_lost_flag = true;
    }
 
    // We need to check for overflow before actually storing the received
    // byte. Otherwise we always get an overflow when the last byte in the
    // buffer gets filled.
    if (turag_feldbus_device.rxOffset >= TURAG_FELDBUS_DEVICE_ACTUAL_BUFFER_SIZE) {
        turag_feldbus_device.rxOffset = 0;
        
        // We have a buffer overflow. If this happens for the 
        // first time for this package, we check the address.
        // If the package was for us, we increase the counter for 
        // package overflow.
        if (!turag_feldbus_device.overflow) {
            if (*((FeldbusAddress_t*)turag_feldbus_device.rxbuf) == turag_feldbus_device.my_address || *((FeldbusAddress_t*)turag_feldbus_device.rxbuf) == TURAG_FELDBUS_BROADCAST_ADDR)
            {
                turag_feldbus_device.buffer_overflow_flag = true;
            }
            turag_feldbus_device.overflow = true;
        }
    }
 
    // accessing the buffer as an array is more effective than using a pointer
    // and increasing it.
    turag_feldbus_device.rxbuf[turag_feldbus_device.rxOffset] = data;
    ++turag_feldbus_device.rxOffset;
 
    // activate timer to recognize end of command
    turag_feldbus_device_start_receive_timeout();
}
 
static inline void turag_feldbus_device_ready_to_transmit() {
    // accessing the buffer as an array is more effective than using a pointer
    // and increasing it.
    turag_feldbus_device_transmit_byte(turag_feldbus_device.txbuf[turag_feldbus_device.txOffset]);
    ++turag_feldbus_device.txOffset;
 
    if (turag_feldbus_device.txOffset == turag_feldbus_device.transmitLength) {
        turag_feldbus_device_deactivate_dre_interrupt();
        turag_feldbus_device_activate_tx_interrupt();
    }
}
 
static inline void turag_feldbus_device_transmission_complete() {
    // turn off transmitter and release bus, turn on receiver
    turag_feldbus_device_rts_off();
    turag_feldbus_device_deactivate_tx_interrupt();
    turag_feldbus_device_activate_rx_interrupt();
 
#if TURAG_FELDBUS_DEVICE_CONFIG_DEBUG_ENABLED
    turag_feldbus_device.transmission_active = false;
#endif
}
 
 
static inline void turag_feldbus_device_receive_timeout_occured() {
    if (turag_feldbus_device.package_lost_flag) {
        ++turag_feldbus_device.packagecount_lost;
        turag_feldbus_device.package_lost_flag = false;
    }
    
    if (turag_feldbus_device.buffer_overflow_flag) {
        ++turag_feldbus_device.packagecount_buffer_overflow;
        turag_feldbus_device.buffer_overflow_flag = false;
    }
 
    if ((*((FeldbusAddress_t*)turag_feldbus_device.rxbuf) == turag_feldbus_device.my_address || *((FeldbusAddress_t*)turag_feldbus_device.rxbuf) == TURAG_FELDBUS_BROADCAST_ADDR) &&
            !turag_feldbus_device.overflow &&
            turag_feldbus_device.rxOffset > 1)
    {
        // package ok -> signal main loop that we have package ready
        turag_feldbus_device.rx_length = turag_feldbus_device.rxOffset;
        
        // we stop the led blinking until the user program starts the package
        // processing
        turag_feldbus_device.toggleLedBlocked = true;
    }
 
    // reset rxOffset and overflow-flag to ensure correct
    // receiving of future packages
    turag_feldbus_device.rxOffset = 0;
    turag_feldbus_device.overflow = 0;
}
 
static inline void turag_feldbus_device_increase_uptime_counter(void) {
    ++turag_feldbus_device.uptime_counter;
 
    // we only toggle the led if there is no package
    // waiting to be processsed.
    // We use this as an indicator for the user whether
    // there is something wrong with the communication.
    if (!turag_feldbus_device.toggleLedBlocked) {
#  if TURAG_FELDBUS_DEVICE_CONFIG_UPTIME_FREQUENCY >= 12
#   define COUNT_MAX (TURAG_FELDBUS_DEVICE_CONFIG_UPTIME_FREQUENCY / 12 - 1)
#    if COUNT_MAX > 255
        static uint16_t count = 0;
#    else
        static uint8_t count = 0;
#    endif
        static uint8_t subcount = 0;
    
        ++count;
        if (count > COUNT_MAX) {
            if (subcount == 0) {
                turag_feldbus_device_toggle_led();
            } else if (subcount == 1) {
                turag_feldbus_device_toggle_led();
            }
            subcount = (subcount+1) & 7;
            count = 0;
        }
#  elif TURAG_FELDBUS_DEVICE_CONFIG_UPTIME_FREQUENCY >= 2
        static uint8_t count = 0;
        
        ++count;
        if (count > (TURAG_FELDBUS_DEVICE_CONFIG_UPTIME_FREQUENCY / 2 - 1)) {
            turag_feldbus_device_toggle_led();
            count = 0;
        }
#  else
        turag_feldbus_device_toggle_led();
#  endif
    }
}
 
 
 
#ifdef __cplusplus
}
#endif
 
 
#endif /* TINA_FELDBUS_SLAVE_FELDBUS_H_ */