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     loraMeasureEvent = queueBundle.queueLoRaMeasurments->get(0);
00069 }
00070 
00071 void TaskDatahandler::forwardSensorMessages(){
00072     std::string loraMessage;
00073     std::vector<uint8_t> dataToSend;
00074     std::vector<uint8_t> dataReceived;
00075 
00076     int32_t ret;
00077 
00078     debugSerial->printf("\n");
00079     if (lightMeasureEvent.status == osEventMessage) {
00080         MAX44009Message* luxMessage = (MAX44009Message*) lightMeasureEvent.value.p;
00081         debugSerial->printf("%s\n",luxMessage->getLoRaMessageString());
00082         loraMessage.append(luxMessage->getLoRaMessageString());
00083     }
00084 
00085     if (temperatureMeasureEvent.status == osEventMessage) {
00086         BME280TemperatureMessage* temperatureMessage = (BME280TemperatureMessage*) temperatureMeasureEvent.value.p;
00087         debugSerial->printf("%s\n",temperatureMessage->getLoRaMessageString());
00088         loraMessage.append(temperatureMessage->getLoRaMessageString());
00089     }
00090 
00091     if (pressureMeasureEvent.status == osEventMessage) {
00092         BME280PressureMessage* pressureMessage = (BME280PressureMessage*) pressureMeasureEvent.value.p;
00093         debugSerial->printf("%s\n",pressureMessage->getLoRaMessageString());
00094         loraMessage.append(pressureMessage->getLoRaMessageString());
00095     }
00096     
00097     if (humidityMeasureEvent.status == osEventMessage) {
00098         BME280HumidityMessage* humidityMessage = (BME280HumidityMessage*) humidityMeasureEvent.value.p;
00099         debugSerial->printf("%s\n",humidityMessage->getLoRaMessageString());
00100         loraMessage.append(humidityMessage->getLoRaMessageString());
00101     }
00102     
00103     if (accelerationMeasureEvent.status == osEventMessage) {
00104         MPU9250AccelerationMessage* accelerationMessage = (MPU9250AccelerationMessage*) accelerationMeasureEvent.value.p;
00105         debugSerial->printf("%s\n",accelerationMessage->getLoRaMessageString());
00106         loraMessage.append(accelerationMessage->getLoRaMessageString());
00107     }
00108     
00109     if (gyroscopeMeasureEvent.status == osEventMessage) {
00110         MPU9250GyroscopeMessage* gyroscopeMessage = (MPU9250GyroscopeMessage*) gyroscopeMeasureEvent.value.p;
00111         debugSerial->printf("%s\n",gyroscopeMessage->getLoRaMessageString());
00112         loraMessage.append(gyroscopeMessage->getLoRaMessageString());
00113     }
00114 
00115     if (teslaMeasureEvent.status == osEventMessage) {
00116         MPU9250TeslaMessage* teslaMessage = (MPU9250TeslaMessage*) teslaMeasureEvent.value.p;
00117         debugSerial->printf("%s\n",teslaMessage->getLoRaMessageString());
00118         loraMessage.append(teslaMessage->getLoRaMessageString());
00119     }
00120 
00121     if(proximityMeasureEvent.status == osEventMessage){
00122         SI1143ProximityMessage* si1143ProximityMessage = (SI1143ProximityMessage*) proximityMeasureEvent.value.p;
00123         debugSerial->printf("%s\n",si1143ProximityMessage->getLoRaMessageString());
00124         loraMessage.append(si1143ProximityMessage->getLoRaMessageString());
00125     }
00126 
00127     if(gpsMeasureEvent.status == osEventMessage){
00128         UBloxGPSMessage* uBloxGpsMessage = (UBloxGPSMessage*) gpsMeasureEvent.value.p;
00129         debugSerial->printf("%s\n",uBloxGpsMessage->getLoRaMessageString());
00130         loraMessage.append(uBloxGpsMessage->getLoRaMessageString());
00131     }
00132 
00133     if(loraMeasureEvent.status == osEventMessage){
00134         LoRaMeasurementMessage* loraMeasurementMessage = (LoRaMeasurementMessage*) loraMeasureEvent.value.p;
00135         debugSerial->printf("%s\n",loraMeasurementMessage->getLoRaMessageString());
00136         loraMessage.append(loraMeasurementMessage->getLoRaMessageString());
00137     }
00138 
00139     debugSerial->printf("\n");
00140 
00141     // format data for sending to the gateway
00142     for (std::string::iterator it = loraMessage.begin(); it != loraMessage.end(); it++){
00143         dataToSend.push_back((uint8_t) *it);
00144     }
00145     loraMessage.clear();
00146 
00147     mutexLora->lock(osWaitForever);
00148     lora->send(dataToSend);
00149 //  lora->recv(dataReceived);
00150     mutexLora->unlock();
00151 
00152     dataToSend.clear();
00153     dataReceived.clear();
00154 
00155 }
00156 
00157 void TaskDatahandler::setMutex(Mutex* mutexLora){
00158     this->mutexLora = mutexLora;
00159 }
00160 
00161 void TaskDatahandler::setQueueBundle(QueueBundle queueBundle){
00162     this->queueBundle = queueBundle;
00163 }
00164 
00165 void TaskDatahandler::setPriority(osPriority priority){
00166     this->priority = priority;
00167 }
00168 
00169 void TaskDatahandler::setStackSize(uint32_t stacksize){
00170     this->stack_size = stacksize;
00171 }
00172 
00173 void TaskDatahandler::setStackPointer(unsigned char* stackPointer){
00174     this->stack_pointer = stackPointer;
00175 }
00176 
00177 void TaskDatahandler::setDebugSerial(RawSerial* debugSerial){
00178     this->debugSerial = debugSerial;
00179 }
00180 
00181 void TaskDatahandler::setLoRa(LoRa* lora){
00182     this->lora = lora;
00183 }
00184 
00185 void TaskDatahandler::setState(TASK_STATE state){
00186     this->state = state;
00187 }
00188 
00189 TASK_STATE TaskDatahandler::getState(){
00190     return state;
00191 }
00192 
00193 
00194 
00195