Merge pull request #116 from smit-happens/Unitek-Get-Set-#43

Unitek get set #43

MainBrain/src/Controller/UnitekController/UnitekController.cpp

@@ -121,3 +121,141 @@ uint16_t UnitekController::calculate90Charge(float batteryVoltage)
     float percent90Charge=0.9*batteryVoltageNumeric;            //finds 90% of numeric battery voltage
     return (int)percent90Charge;
 }
+
+/** 
+ * @brief  used to store the recieved speed value from CAN
+ * @note   
+ * @param  RpmSpeed: recieved numeric value from MC that is converted to RPMs using calculateRPM
+ * @retval None
+ */
+void  UnitekController::storeRpmSpeedValue(float RpmSpeed)
+{
+    unitekModel->setSpeedValueFromUnitek(RpmSpeed);
+}
+
+
+/** 
+ * @brief  stores rpm limit if we ever need to change it
+ * @note   should only ever be used if we implement reverse mode
+ * @param  RpmLimit: new RPM limit that should have been set in MC
+ * @retval None
+ */
+void UnitekController::storeRpmLimit(uint16_t RpmLimit)
+{
+    unitekModel->setRpmLimit(RpmLimit);
+}
+
+
+/** 
+ * @brief  stores error register value
+ * @note   
+ * @param  errorReg: recieved value of error reg from CAN
+ * @retval None
+ */
+void UnitekController::storeErrorReg(uint16_t errorReg)
+{
+    unitekModel->setErrorReg_0x8F(errorReg);
+}
+
+
+/** 
+ * @brief  stores warning register value
+ * @note   
+ * @param  warningReg: recieved value of wanring reg from CAN
+ * @retval None
+ */
+void UnitekController::storeWarningReg(uint16_t warningReg)
+{
+    unitekModel->setWarningReg_0x8F(warningReg);
+}
+
+
+/** 
+ * @brief  store state register value
+ * @note   
+ * @param  stateReg: recieved value of state reg from CAN
+ * @retval None
+ */
+void UnitekController::storeStateReg(uint16_t stateReg)
+{
+    unitekModel->setStateReg_0x40(stateReg);
+}
+
+
+/** 
+ * @brief  store mode register value
+ * @note   
+ * @param  modeReg: received value of mode reg from CAN
+ * @retval None
+ */
+void UnitekController::storeModeReg(uint16_t modeReg)
+{
+    unitekModel->setModeReg_0xD8(modeReg);
+}
+
+
+/** 
+ * @brief  store voltage value of hv bus 
+ * @note   value is in unitek resolution
+ * @param  HvBus: received value of HV bus from CAN
+ * @retval None
+ */
+void UnitekController::storeVoltageHvBus(uint16_t HvBus)
+{
+    unitekModel->setVoltageHvBus(HvBus);
+}
+
+
+/** 
+ * @brief  store speed value that is sent to MC
+ * @note   value is in unitek resolution
+ * @param  speedCmdValue: value calculated from pedal press percentage 
+ * @retval None
+ */
+void UnitekController::storeSpeedValueForUnitek(uint16_t speedCmdValue)
+{
+    unitekModel->setSpeedValueForUnitek(speedCmdValue);
+}
+
+
+/** 
+ * @brief  store speed value that is recieved from MC
+ * @note   value is RPM resolution (confirm)
+ * @param  speedValue: value received from MC over CAN
+ * @retval None
+ */
+void UnitekController::storeSpeedValueFromUnitek(uint16_t speedValue)
+{
+    unitekModel->setSpeedValueFromUnitek(speedValue);
+}
+
+
+/** 
+ * @brief  store temperature of the motor
+ * @note   value will be in unitek resolution
+ * @param  motorTemp: temp value recieved from MC over can
+ * @retval None
+ */
+void UnitekController::storeTemperatureMotor(uint16_t motorTemp)
+{
+    unitekModel->setTemperatureMotor(motorTemp);
+}
+
+
+/** 
+ * @brief  stores temperature of the output stage
+ * @note   value will be in unitek resolution
+ * @param  outputTemp: temp value of output stage recieved from MC
+ * @retval None
+ */
+void UnitekController::storeTempOutputStage(uint16_t outputTemp)
+{
+    unitekModel->setTemperatureOutputStage(outputTemp);
+}
+
+
+void UnitekController::storeTempInterior(uint16_t interiorTemp)
+{
+    unitekModel->setTemperatureInterior(interiorTemp);
+}
+

MainBrain/src/Controller/UnitekController/UnitekController.hpp

@@ -29,6 +29,19 @@ class UnitekController : public BaseController
     float calculateRpm(int speedValue);
     uint16_t calculateSpeedSetPoint(float percent);
     uint16_t calculate90Charge(float batteryVoltage);
+    void storeRpmSpeedValue(float RpmSpeed);
+    void storeRpmLimit(uint16_t RpmLimit);
+    void storeErrorReg(uint16_t errorReg);
+    void storeWarningReg(uint16_t warningReg);
+    void storeStateReg(uint16_t stateReg);
+    void storeModeReg(uint16_t modeReg);
+    void storeVoltageHvBus(uint16_t HvBus);
+    void storeSpeedValueForUnitek(uint16_t speedCmdValue);
+    void storeSpeedValueFromUnitek(uint16_t speedValue);
+    void storeTemperatureMotor(uint16_t motorTemp);
+    void storeTempOutputStage(uint16_t ouputTemp);
+    void storeTempInterior(uint16_t interiorTemp);
+
 
 private:
     //Private contstructor so that it can't be called

MainBrain/src/Model/Unitek/Unitek.cpp

@@ -48,15 +48,20 @@ int Unitek::getRpmLimit(void)
     return rpmLimitReg_C8;
 }
 
+void Unitek::setRpmLimit(uint16_t RpmLimit)
+{
+    rpmLimitReg_C8=RpmLimit;
+}
+
 
 /** 
- * @brief  Retrieves the current speed value set in the Unitek MC
- * @note   Might get called after setting the speed value as a confirmation step
+ * @brief  Retrieves the current speed value we will set in the MC
+ * @note   Might be used in order to monitor speed setpoint versus actual speed
  * @retval Current speed value set in the Unitek MC
  */
-int Unitek::getSpeedValue(void)
+uint16_t Unitek::getSpeedValueForUnitek(void)
 {
-    return 0;
+    return speedCmdValBeforeRampReg_0x31;
 }
 
 
@@ -66,53 +71,143 @@ int Unitek::getSpeedValue(void)
  * @param  userSpeedVal: Requested speed value to set in Unitek (calculated by calculateSpeedSetPoint in CanController)
  * @retval None
  */
-void Unitek::setSpeedValue(int userSpeedVal)
+void Unitek::setSpeedValueForUnitek(uint16_t userSpeedVal)
 {
     speedCmdValBeforeRampReg_0x31=userSpeedVal;
 }
 
+/** 
+ * @brief  gets the current speed value from the MC
+ * @note   used to measure rpms of motor and display to dash
+ * @retval returns current value stored in MC for actual RPM
+ */
+uint16_t Unitek::getSpeedValueFromUnitek(void)
+{
+    return speedValRnReg_0x30;
+}
 
 /** 
- * @brief  Retrieves temperature limit of the motor and converts to celsius
+ * @brief   sets the current speed value that is gathered from the MC
+ * @note   will be used once a can message is recieved from the MC with an RPM value
+ * @param  recSpeedValue: received speed value from MC (must be converted to RPMs)
+ * @retval None
+ */
+void Unitek::setSpeedValueFromUnitek(uint16_t recRpmSpeedValue)
+{
+    speedValRnReg_0x30=recRpmSpeedValue;
+}
+
+
+/** 
+ * @brief  Retrieves temperature limit of the motor
  * @note   If the temperature of the motor goes above this, it triggers the 
- * @retval Temperature limit register value (in celsius) set in the REG_MTEMPLIM
+ * @retval Temperature limit register value (in untitek resolution) set in the REG_MTEMPLIM
  */
-float Unitek::getTemperatureMotorLimit(void)
+uint16_t Unitek::getTemperatureMotorLimit(void)
 {
-    return 0.0;
+    return tempLimitMotorReg_0xA3;
+}
+
+
+/** 
+ * @brief  stores temp limit of the motor
+ * @note   stored in unitek resolution
+ * @param  tempMotorLimit: received motor temp limit from can
+ * @retval 
+ */
+void Unitek::setTemperatureMotorLimit(uint16_t tempMotorLimit)
+{
+    tempLimitMotorReg_0xA3=tempMotorLimit;
 }
 
 
 /** 
  * @brief  Retrieves temperature of the motor and converts to celsius
  * @note   
- * @retval Temperature (in celsius) of the Emrax motor
+ * @retval Temperature (in unitek resolution) of the Emrax motor
+ */
+uint16_t Unitek::getTemperatureMotor(void)
+{
+    return tempMotorReg_0x49;
+}
+
+
+/** 
+ * @brief  stores motor temp value
+ * @note   stores in unitek resolution
+ * @param  tempMotor: temp of motor that would be recieved from CAN
+ * @retval None
  */
-float Unitek::getTemperatureMotor(void)
+void Unitek::setTemperatureMotor(uint16_t tempMotor)
 {
-    return 0.0;
+    tempMotorReg_0x49=tempMotor;
 }
 
 
 /** 
- * @brief  Retrieves temperature of the output water and converts to celsius
+ * @brief  Retrieves temperature of the output water
  * @note   TODO: Ask Alec if this does what I think it does
- * @retval Temperature (in celsius) of the output water from the internal radiator (I think)
+ * @retval Temperature (in unitek resolution) of the output water from the internal radiator (I think)
+ */
+uint16_t Unitek::getTemperatureOutputStage(void)
+{
+    return tempOutputStageMCReg_0x4A;
+}
+
+
+/** 
+ * @brief  stores temp of output stage 
+ * @note   stores in unitek resolution
+ * @param  tempOutputStage: 
+ * @retval None
  */
-float Unitek::getTemperatureOutputStage(void)
+void Unitek::setTemperatureOutputStage(uint16_t tempOutputStage)
 {
-    return 0.0;
+    tempOutputStageMCReg_0x4A=tempOutputStage;
 }
 
 
 /** 
- * @brief  Retrieves temperature of the Unitek internals and converts to celsius
+ * @brief  Retrieves temperature of the Unitek internals 
  * @note   
- * @retval Temperature (in celsius) of the internals of the Unitek
+ * @retval Temperature (in unitek resolution) of the internals of the Unitek
+ */
+uint16_t Unitek::getTemperatureInterior(void)
+{
+    return tempInteriorMCReg_0x4B;
+}
+
+
+/** 
+ * @brief  stores temperature of unitek internals
+ * @note   stores in unitek resolution
+ * @param  tempInterior: internal temp resturned from MC via CAN
+ * @retval None
+ */
+void Unitek::setTemperatureInterior(uint16_t tempInterior)
+{
+    tempInteriorMCReg_0x4B=tempInterior;
+}
+
+/** 
+ * @brief  gets current hv bus measurement
+ * @note   this is in Unitek resolution (0-32767)
+ * @retval current HV voltage
+ */
+uint16_t Unitek::getVoltageHvBus(void)
+{
+    return hvBusVoltageReg_0xEB;
+}
+
+/** 
+ * @brief  sets new voltage of HV bus
+ * @note   this is in unitek resolution (0-32767)
+ * @param  hvBusVoltage: new HV bus value returned from CAN
+ * @retval 
  */
-float Unitek::getTemperatureInterior(void)
+void Unitek::setVoltageHvBus(uint16_t hvBusVoltage)
 {
-    return 0.0;
+    hvBusVoltageReg_0xEB=hvBusVoltage;
 }
 
 

MainBrain/src/Model/Unitek/Unitek.hpp

@@ -162,14 +162,25 @@ class Unitek : public BaseModel
     void update(void);
 
     int getRpmLimit(void);
+    void setRpmLimit(uint16_t RpmLimit);
 
-    int getSpeedValue(void);
-    void setSpeedValue(int userSpeedVal);
+    uint16_t getSpeedValueForUnitek(void);
+    void setSpeedValueForUnitek(uint16_t userSpeedVal);
 
-    float getTemperatureMotorLimit(void);   //These functions might require a convertToCelsius() funct
-    float getTemperatureMotor(void);
-    float getTemperatureOutputStage(void);
-    float getTemperatureInterior(void);
+    uint16_t getSpeedValueFromUnitek(void);
+    void setSpeedValueFromUnitek(uint16_t recSpeedValue);
+
+    uint16_t getTemperatureMotorLimit(void);   //These functions might require a convertToCelsius() funct
+    void setTemperatureMotorLimit(uint16_t tempMotorLimit);
+    uint16_t getTemperatureMotor(void);
+    void setTemperatureMotor(uint16_t tempMotor);
+    uint16_t getTemperatureOutputStage(void);
+    void setTemperatureOutputStage(uint16_t tempOutputStage);
+    uint16_t getTemperatureInterior(void);
+    void setTemperatureInterior(uint16_t tempInterior);
+
+    uint16_t getVoltageHvBus(void);
+    void setVoltageHvBus(uint16_t hvBusVoltage);
 
     ErrorReg_0x8F getErrorReg_0x8F(void);
     void setErrorReg_0x8F(uint16_t input);
@@ -212,11 +223,12 @@ class Unitek : public BaseModel
     bool     I_RunReg_0xE8;                 //Lazy
     uint8_t  goStatusReg_0xE3;              //Lazy
     uint16_t hvBusVoltageReg_0xEB;          //Active
-    uint16_t speedCmdValBeforeRampReg_0x31; //Active
-    uint16_t speedValRnReg_0x30;            //Active
+    uint16_t speedCmdValBeforeRampReg_0x31; //Active - 
+    uint16_t speedValRnReg_0x30;            //Active -
     uint16_t tempMotorReg_0x49;             //Active
     uint16_t tempOutputStageMCReg_0x4A;     //Active
     uint16_t tempInteriorMCReg_0x4B;        //Active
+    uint16_t tempLimitMotorReg_0xA3;        //
 
 };