TaskDatahandler.cpp

00001 /*
00002  * TaskDatahandler.cpp
00003  *
00004  *  Created on: May 27, 2016
00005  *      Author: Adrian
00006  */
00007 
00008 #include "TaskDatahandler.h "
00009 
00010 TaskDatahandler::TaskDatahandler(LoRa* lora,Mutex* mutexLora, QueueBundle queueBundle,
00011         osPriority priority,uint32_t stackSize, unsigned char* stackPointer){
00012     setLoRa(lora);
00013     setMutex(mutexLora);
00014     setQueueBundle(queueBundle);
00015     setPriority(priority);
00016     setStackSize(stackSize);
00017     setStackPointer(stackPointer);
00018     setState(SLEEPING);
00019 }
00020 
00021 TaskDatahandler::~TaskDatahandler() {
00022     // TODO Auto-generated destructor stub
00023 }
00024 
00025 osStatus TaskDatahandler::start(){
00026     setState(RUNNING);
00027     this->thread = new rtos::Thread(callBack,this);
00028     attachIdleHook(NULL);
00029 }
00030 
00031 osStatus TaskDatahandler::stop(){
00032     thread->terminate();
00033     setState(SLEEPING);
00034     delete this->thread;
00035 }
00036 
00037 void TaskDatahandler::callBack(void const* data){
00038     // WOODHAMMER METHOD of Casting!
00039     const TaskDatahandler* constInstance = static_cast<const TaskDatahandler* >(data);
00040     TaskDatahandler* instance = const_cast<TaskDatahandler*>(constInstance);
00041 
00042     instance->handleData();
00043 }
00044 
00045 void TaskDatahandler::attachIdleHook(void (*fptr) (void)){
00046     this->thread->attach_idle_hook(fptr);
00047 }
00048 
00049 void TaskDatahandler::handleData(){
00050 
00051     while(true){
00052         getMessagesFromSensorQueues();
00053         forwardSensorMessages();
00054         osDelay(std::max((uint32_t)DATAHANLDER_TASK_DELAY_MS,(uint32_t)lora->getNextTxMs()));
00055     }
00056 }
00057 
00058 void TaskDatahandler::getMessagesFromSensorQueues(){
00059     lightMeasureEvent = queueBundle.queueLight->get(0);
00060     temperatureMeasureEvent = queueBundle.queueTemperature->get(0);
00061     pressureMeasureEvent = queueBundle.queuePressure->get(0);
00062     humidityMeasureEvent = queueBundle.queueHumidity->get(0);
00063     accelerationMeasureEvent = queueBundle.queueAcceleration->get(0);
00064     gyroscopeMeasureEvent = queueBundle.queueGyro->get(0);
00065     teslaMeasureEvent = queueBundle.queueTesla->get(0);
00066     proximityMeasureEvent = queueBundle.queueProximity->get(0);
00067     gpsMeasureEvent = queueBundle.queueGps->get(0);
00068     flowMeasureEvent = queueBundle.queueFlowMeter->get(0);
00069     loraMeasureEvent = queueBundle.queueLoRaMeasurments->get(0);
00070 }
00071 
00072 void TaskDatahandler::forwardSensorMessages(){
00073     std::string loraMessage;
00074     std::vector<uint8_t> dataToSend;
00075     std::vector<uint8_t> dataReceived;
00076 
00077     int32_t ret;
00078 
00079     debugSerial->printf("\n");
00080     if (lightMeasureEvent.status == osEventMessage) {
00081         MAX44009Message* luxMessage = (MAX44009Message*) lightMeasureEvent.value.p;
00082         debugSerial->printf("%s\n",luxMessage->getLoRaMessageString());
00083         loraMessage.append(luxMessage->getLoRaMessageString());
00084     }
00085 
00086     if (temperatureMeasureEvent.status == osEventMessage) {
00087         BME280TemperatureMessage* temperatureMessage = (BME280TemperatureMessage*) temperatureMeasureEvent.value.p;
00088         debugSerial->printf("%s\n",temperatureMessage->getLoRaMessageString());
00089         loraMessage.append(temperatureMessage->getLoRaMessageString());
00090     }
00091 
00092     if (pressureMeasureEvent.status == osEventMessage) {
00093         BME280PressureMessage* pressureMessage = (BME280PressureMessage*) pressureMeasureEvent.value.p;
00094         debugSerial->printf("%s\n",pressureMessage->getLoRaMessageString());
00095         loraMessage.append(pressureMessage->getLoRaMessageString());
00096     }
00097     
00098     if (humidityMeasureEvent.status == osEventMessage) {
00099         BME280HumidityMessage* humidityMessage = (BME280HumidityMessage*) humidityMeasureEvent.value.p;
00100         debugSerial->printf("%s\n",humidityMessage->getLoRaMessageString());
00101         loraMessage.append(humidityMessage->getLoRaMessageString());
00102     }
00103     
00104     if (accelerationMeasureEvent.status == osEventMessage) {
00105         MPU9250AccelerationMessage* accelerationMessage = (MPU9250AccelerationMessage*) accelerationMeasureEvent.value.p;
00106         debugSerial->printf("%s\n",accelerationMessage->getLoRaMessageString());
00107         loraMessage.append(accelerationMessage->getLoRaMessageString());
00108     }
00109     
00110     if (gyroscopeMeasureEvent.status == osEventMessage) {
00111         MPU9250GyroscopeMessage* gyroscopeMessage = (MPU9250GyroscopeMessage*) gyroscopeMeasureEvent.value.p;
00112         debugSerial->printf("%s\n",gyroscopeMessage->getLoRaMessageString());
00113         loraMessage.append(gyroscopeMessage->getLoRaMessageString());
00114     }
00115 
00116     if (teslaMeasureEvent.status == osEventMessage) {
00117         MPU9250TeslaMessage* teslaMessage = (MPU9250TeslaMessage*) teslaMeasureEvent.value.p;
00118         debugSerial->printf("%s\n",teslaMessage->getLoRaMessageString());
00119         loraMessage.append(teslaMessage->getLoRaMessageString());
00120     }
00121 
00122     if(proximityMeasureEvent.status == osEventMessage){
00123         SI1143ProximityMessage* si1143ProximityMessage = (SI1143ProximityMessage*) proximityMeasureEvent.value.p;
00124         debugSerial->printf("%s\n",si1143ProximityMessage->getLoRaMessageString());
00125         loraMessage.append(si1143ProximityMessage->getLoRaMessageString());
00126     }
00127 
00128     if(gpsMeasureEvent.status == osEventMessage){
00129         UBloxGPSMessage* uBloxGpsMessage = (UBloxGPSMessage*) gpsMeasureEvent.value.p;
00130         debugSerial->printf("%s\n",uBloxGpsMessage->getLoRaMessageString());
00131         loraMessage.append(uBloxGpsMessage->getLoRaMessageString());
00132     }
00133     if(flowMeasureEvent.status == osEventMessage){
00134         FlowMeterMessage* flowMeterMessage = (FlowMeterMessage*) flowMeasureEvent.value.p;
00135         debugSerial->printf("%s\n",flowMeterMessage->getLoRaMessageString());
00136         loraMessage.append(flowMeterMessage->getLoRaMessageString());
00137     }
00138     if(loraMeasureEvent.status == osEventMessage){
00139         LoRaMeasurementMessage* loraMeasurementMessage = (LoRaMeasurementMessage*) loraMeasureEvent.value.p;
00140         debugSerial->printf("%s\n",loraMeasurementMessage->getLoRaMessageString());
00141         loraMessage.append(loraMeasurementMessage->getLoRaMessageString());
00142     }
00143 
00144     debugSerial->printf("\n");
00145 
00146     // format data for sending to the gateway
00147     for (std::string::iterator it = loraMessage.begin(); it != loraMessage.end(); it++){
00148         dataToSend.push_back((uint8_t) *it);
00149     }
00150     loraMessage.clear();
00151 
00152     mutexLora->lock(osWaitForever);
00153     lora->send(dataToSend);
00154     lora->recv(dataReceived);
00155     mutexLora->unlock();
00156 
00157     dataToSend.clear();
00158     dataReceived.clear();
00159 
00160 }
00161 
00162 void TaskDatahandler::setMutex(Mutex* mutexLora){
00163     this->mutexLora = mutexLora;
00164 }
00165 
00166 void TaskDatahandler::setQueueBundle(QueueBundle queueBundle){
00167     this->queueBundle = queueBundle;
00168 }
00169 
00170 void TaskDatahandler::setPriority(osPriority priority){
00171     this->priority = priority;
00172 }
00173 
00174 void TaskDatahandler::setStackSize(uint32_t stacksize){
00175     this->stack_size = stacksize;
00176 }
00177 
00178 void TaskDatahandler::setStackPointer(unsigned char* stackPointer){
00179     this->stack_pointer = stackPointer;
00180 }
00181 
00182 void TaskDatahandler::setDebugSerial(RawSerial* debugSerial){
00183     this->debugSerial = debugSerial;
00184 }
00185 
00186 void TaskDatahandler::setLoRa(LoRa* lora){
00187     this->lora = lora;
00188 }
00189 
00190 void TaskDatahandler::setState(TASK_STATE state){
00191     this->state = state;
00192 }
00193 
00194 TASK_STATE TaskDatahandler::getState(){
00195     return state;
00196 }
00197 
00198 
00199 
00200