Diff: Peripherien/Phaserunner.h

Revision:

7:15e6fc689368

Parent:

6:a80300ee574d

Child:

9:56aed8c6779f

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Peripherien/Phaserunner.h	Thu May 16 20:42:39 2019 +0000
@@ -0,0 +1,181 @@
+/**
+ * Handelt die Kommunikation (Lesen und Schreiben) mit den Phaserunnern
+ */
+
+#ifndef PHASERUNNER_H
+#define PHASERUNNER_H
+
+#include "mbed.h"
+#include "rtos.h"
+
+class Phaserunner {
+private:
+    //Private constants
+    static const uint8_t BUFLEN = 255;
+
+    //Adressen
+    static const unsigned short REMOTE_THROTTLE_VOLTAGE =       495;
+    static const unsigned short REMOTE_ANALOG_BREAK_VOLTAGE =   497;
+    static const unsigned short MOTOR_CURRENT =                 262;
+    static const unsigned short LAST_FAULT =                    269;
+    static const unsigned short EBRAKESOURCE =                  249;
+
+    //Modbus-Protokoll
+    static const uint8_t SCHREIBANTWORT =   0x10;
+    static const uint8_t LESEANTWORT =      0x03;
+    
+
+    //Sonstiges
+    static const uint16_t WRITE_PERIOD =    3;      //Minimaler Zeitintervall zwischen zwei Messages an den Phaserunner [ms]
+    static const float TICKER_PERIOD =      0.02f;  //Zeitintervall für das Schreiben auf den Phaserunner [s]
+    
+    //Thread thread; //Wird für die Funktion writeToPhaserunner() gebraucht
+    Ticker ticker;
+
+    //Verbindung zum Phaserunner
+    RawSerial& connection;
+
+    //Buffer in das gelesen wird.
+    uint8_t writeBuffer[BUFLEN];
+
+    //Buffer aus dem geschrieben wird.
+    uint8_t read_buffer[BUFLEN];
+
+    //State valiables
+    float frequency;
+    float voltage;
+    float current;
+    uint16_t error;
+    uint16_t newTorque;
+    uint16_t newRecuperation;
+
+    /**
+     * Wartet auf ein Byte. Wenn ein Datenstring gelesen wird, werden die Daten mithilfe einer Zustandsmaschine abgespeichert.
+     */
+    void Rx_interrupt();
+
+    /**
+     * @brief Bereitet buf darauf vor, versendet zu werden.
+     * @param buf:      Byte-Array
+     * @param addr:     Adresse des Registers, das beschrieben wird
+     * @param value:    Wert der in das Register geschrieben wird
+     */
+    static int WriteRegister(uint8_t* buf, unsigned short addr, unsigned short value);
+
+    /**
+     * @brief Sendet einen Schreibbefehl auf einen Phaserunner
+     * @param writeBuf:         Byte-Array in das geschrieben wird.
+     * @param registerAddress:  Adresse des Registers aus dem gelesen wird.
+     */
+    static int readRegister(uint8_t *buf, uint16_t registerAddress);
+
+    /**
+     * @brief Sendet ein Byte-Array zum Phaserunner
+     * @param adress:   Adresse des Zielregisters
+     * @param value:    Wert der in das Register geschriebern werden soll.
+     * @return          Anzahl gesendeter Bytes
+     */
+    //int sendBuffer(unsigned short adress, unsigned short value);
+
+    /**
+     * @brief   Sendet den writeBuffer
+     * @param:  Länge des zu sendenden Arrays
+     * @return: Anzahl gesendeter Bytes
+     */
+    int sendBuffer(int length);
+
+    /**
+     * @brief:          Liest ein Register aus.
+     * @param adress:   Adresse des Registers aus dem gelesen werden soll.
+     * @return:         Anzahl gelesener Bytes
+     */
+    int readBuffer(uint16_t adress);
+
+    /**
+     * @brief:  Schreibt ein Drehmoment auf den Phaserunner.
+     * @param:  torque Drehmoment in percent
+     */
+    void writeTorque(uint8_t torque);
+
+    /**
+     * @brief:  Schreibt den Rekuperationswert auf den Phaserunner.
+     * @param:  recuperation Rekupertation in Prozent
+     */
+    void writeRecuperation(uint8_t recuperation);
+
+    /**
+     * @brief:  Prüfziffer berechnen
+     * @param:  msgByte Byte-Array
+     * @param:  length length of Byte-Array
+     */
+    static uint16_t getCRC(uint8_t* msgByte, uint8_t length);
+
+    /**
+     * @brief: Sendet kontinuierlich einen Lesebefehl auf den Phaserunner.
+     */
+    void writeToPhaserunner();
+
+    /**
+     * @brief:  Sendet einen Schreibbefehl für die Drehgewschwindigkeit, die Stromstärke und die Spannung
+     */
+    void readRPM();
+
+    /**
+     * @brief:  Liest das Fehlerregister aus
+     * @return  Byte
+     */
+    uint16_t readFaults();
+
+public:
+    static const uint8_t MAX_TORQUE_GAIN    = 2;    //Maximaler Sprung für Drehmoment
+    static const uint8_t MIN_RECUPERATION   = 10;   //Schwellwert für die Aktivierung des Daumengriffbetätigers
+    static const uint8_t MIN_HANDGRIFF      = 5;    //Schwellwert für die Aktivierung des Handgriffbetätigers
+    int sendBuffer(unsigned short adress, unsigned short value);
+    /**
+     * @brief Initialisiert ein Phaserunner-Objekt
+     * @param connection: Serielle Schnittstelle zum Phaserunner
+     */
+    Phaserunner(RawSerial& connection);
+
+    /**
+     * @brief:  Schreibt ein Drehmoment ins Phaserunnerobjekt, das dann geschrieben wird.
+     * @param:  torque Drehmoment in Prozent
+     */
+    void setTorque(uint8_t torque);
+
+    /**
+     * @brief:  Schreibt einen Rekuperationswert ins Phaserunnerobjekt, dass dann geschrieben wird.
+     * @param:  recuperation Rekuperationswert in Prozent
+     */
+    void setRecuperation(uint8_t recuperation);
+
+    /**
+     * @return frequenz
+     */
+    float getFrequency();
+
+    /**
+     * @return strom
+     */
+    float getCurrent();
+
+    /**
+     * @return spannung
+     */
+    float getVoltage();
+    
+    /**
+     * @return Ebrike Source
+     */
+    int getRegister(int address);
+
+    //Delete
+    uint8_t badBuf[256];
+    uint8_t bufPointer;
+    uint8_t read;
+    DigitalOut led;
+    
+    uint16_t getRecup();
+};
+
+#endif