b15f.h

#ifndef B15F_H
#define B15F_H
 
#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <fstream>
#include <cstdlib>
#include <chrono>
#include <cstdint>
#include <vector>
 
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <termios.h>
 
#include "requests.h"
#include "usart.h"
#include "driverexception.h"
#include "timeoutexception.h"
 
// wichtig für die Register-Zugriffe
#define _AVR_IO_H_ 1 // Erzwinge die Inklusion
#include "/usr/lib/avr/include/avr/sfr_defs.h"
#include "/usr/lib/avr/include/avr/iom1284p.h"
 
typedef std::function<void(std::exception&)> errorhandler_t;
 
 
class B15F
{
public:
 
    /*************************************
     * Grundfunktionen des B15F Treibers *
     *************************************/
 
    static B15F& getInstance(void);
 
    void reconnect(void);
 
    void discard(void);
 
    bool testConnection(void);
 
    bool testIntConv(void);
 
    std::vector<std::string> getBoardInfo(void);
 
    void delay_ms(uint16_t ms);
 
    void delay_us(uint16_t us);
 
    void reverse(uint8_t& b);
 
    static std::string exec(std::string cmd);
 
    static void abort(std::string msg);
 
    static void abort(std::exception& ex);
 
    static void setAbortHandler(errorhandler_t func);
 
    /*************************************/
 
 
 
    /*************************
     * Steuerbefehle für B15 *
     *************************/
 
    void activateSelfTestMode(void);
 
    void digitalWrite0(uint8_t);
 
    void digitalWrite1(uint8_t);
 
    uint8_t digitalRead0(void);
 
    uint8_t digitalRead1(void);
 
    uint8_t readDipSwitch(void);
 
    void analogWrite0(uint16_t port);
 
    void analogWrite1(uint16_t port);
 
    uint16_t analogRead(uint8_t channel);
 
    void analogSequence(uint8_t channel_a, uint16_t* buffer_a, uint32_t offset_a, uint8_t channel_b, uint16_t* buffer_b, uint32_t offset_b, uint16_t start, int16_t delta, uint16_t count);
 
    uint8_t pwmSetFrequency(uint32_t freq);
 
    void pwmSetValue(uint8_t value);
 
    void setMem8(volatile uint8_t* adr, uint8_t val);
 
    uint8_t getMem8(volatile uint8_t* adr);
 
    void setMem16(volatile uint16_t* adr, uint16_t val);
 
    uint16_t getMem16(volatile uint16_t* adr);
 
    void setRegister(volatile uint8_t* adr, uint8_t val);
 
    uint8_t getRegister(volatile uint8_t* adr);
 
    uint16_t* getInterruptCounterOffset(void);
 
    void setServoEnabled(void);
 
    void setServoDisabled(void);
 
    void setServoPosition(uint16_t pos);
 
    /*************************/
 
 
    // CONSTANTS
    const std::string PRE = "[B15F] "; 
    constexpr static uint8_t  MSG_OK = 0xFF; 
    constexpr static uint8_t  MSG_FAIL = 0xFE; 
    constexpr static uint16_t RECONNECT_TIMEOUT = 64; 
    constexpr static uint16_t WDT_TIMEOUT = 15; 
    constexpr static uint8_t  RECONNECT_TRIES = 3; 
    constexpr static uint32_t BAUDRATE = 57600; 
 
private:
 
    B15F(void);
 
    void init(void);
 
    template<typename CodeType, typename ExpectationType>
    void assertCode(CodeType& code, ExpectationType expectation) const
    {
        if(code != static_cast<CodeType>(expectation))
            throw DriverException("Ungültige Antwort erhalten: " + std::to_string((int) code) + " (erwartet: " + std::to_string((int) expectation) + ")");
    }
 
    template<size_t RequestLength>
    void assertRequestLength(uint8_t (&)[RequestLength], uint8_t rq_num)
    {
        if(RequestLength != rq_len[rq_num])
            throw DriverException("Ungültige Request Länge: " + std::to_string(RequestLength) + " (erwartet: " + std::to_string(rq_len[rq_num]) + ")");
    }
 
    USART usart; 
    static B15F* instance; 
    static errorhandler_t errorhandler; 
};
 
#endif // B15F_H