////////////////////////////////////////////////////////////////////////// // @brief processes a single decl from the streamout stream. Reads 4 components from the input // stream and writes N components to the output buffer given the componentMask or if // a hole, just increments the buffer pointer // @param pStream - pointer to current attribute // @param pOutBuffers - pointers to the current location of each output buffer // @param decl - input decl void buildDecl(Value* pStream, Value* pOutBuffers[4], const STREAMOUT_DECL& decl) { // @todo add this to x86 macros Function* maskStore = Intrinsic::getDeclaration(JM()->mpCurrentModule, Intrinsic::x86_avx_maskstore_ps); uint32_t numComponents = _mm_popcnt_u32(decl.componentMask); uint32_t packedMask = (1 << numComponents) - 1; if (!decl.hole) { // increment stream pointer to correct slot Value* pAttrib = GEP(pStream, C(4 * decl.attribSlot)); // load 4 components from stream Type* simd4Ty = VectorType::get(IRB()->getFloatTy(), 4); Type* simd4PtrTy = PointerType::get(simd4Ty, 0); pAttrib = BITCAST(pAttrib, simd4PtrTy); Value *vattrib = LOAD(pAttrib); // shuffle/pack enabled components Value* vpackedAttrib = VSHUFFLE(vattrib, vattrib, PackMask(decl.componentMask)); // store to output buffer // cast SO buffer to i8*, needed by maskstore Value* pOut = BITCAST(pOutBuffers[decl.bufferIndex], PointerType::get(mInt8Ty, 0)); // cast input to <4xfloat> Value* src = BITCAST(vpackedAttrib, simd4Ty); CALL(maskStore, {pOut, ToMask(packedMask), src}); } // increment SO buffer pOutBuffers[decl.bufferIndex] = GEP(pOutBuffers[decl.bufferIndex], C(numComponents)); }
uint8_t Change_Sensor_Frequency_Request(packetXBee * receivedPaq) // APP_ID = 7 { uint8_t error = 2; #ifdef CH_SENS_FREQ_REQ_DEBUG USB.println("CH_SENS_FREQ_REQ"); #endif // 1. Check if sender is authorized if( !PackUtils.authorizeSender(receivedPaq) ) { COMM.sendError(NODE_RECEIVED_AN_UNAUTHORIZED_REQUEST_OF_CH_SENS_FREQ_REQUEST); return 1; } else { #ifdef CH_SENS_FREQ_REQ_DEBUG USB.println("sender authorized"); #endif } // 2. Check if the node has an Ipsum ID: it checks if the node has been invited // to the network via an 'ADD_NODE_REQ' packet. if( !xbeeZB.inNetwork ) { COMM.sendError(NODE_HAS_NOT_BEEN_INVITED_TO_THE_NETWORK_YET___USE_ADD_NODE_REQ); return 1; } //uint16_t receivedToChangeSensorsMask = ( (unsigned int) receivedPaq->data[0]*256) + receivedPaq->data[1]; uint16_t receivedToChangeSensorsMask = ToMask(receivedPaq->data); //( (unsigned int) receivedPaq->data[0]*256) + receivedPaq->data[1]; #ifdef CH_SENS_FREQ_REQ_DEBUG USB.print("to change mask: "); USB.println( (int) receivedToChangeSensorsMask); #endif // 3. SET INDIVIDUAL SENSOR TIMES AND NEW ACTIVE MASK error = xbeeZB.changeSensorFrequencies(receivedPaq->data); if(!error) { PackUtils.insertFrequenciesInPacketData(receivedToChangeSensorsMask); char * contentToSend = (char *) calloc(PackUtils.packetSize*2 + 1, sizeof(char)); PackUtils.escapeZerosInPacketData(contentToSend); error = COMM.sendMessage(xbeeZB.GATEWAY_MAC, CH_SENS_FREQ_RES, contentToSend); free(contentToSend); contentToSend = NULL; return 0; } else { // 3B. If error occured, send error COMM.sendError(NODE_HAD_AN_ERROR_IN_XBEEZB_CHANGE_SENSOR_FREQUENCIES); return 1; } }
uint8_t Change_Node_Frequency_Request(packetXBee * receivedPaq) // APP_ID = 5 { uint8_t error = 2; #ifdef ADD_NODE_REQ_DEBUG USB.println("CH_NODE_FREQ_REQ"); #endif // 1. Check if sender is authorized if( !PackUtils.authorizeSender(receivedPaq) ) { COMM.sendError(NODE_RECEIVED_AN_UNAUTHORIZED_REQUEST_OF_CH_NODE_FREQ_REQUEST); return 1; } else { #ifdef ADD_NODE_REQ_DEBUG_2 USB.println("sender authorized"); #endif } // 2. Check if the node has an Ipsum ID: it checks if the node has been invited // to the network via an 'ADD_NODE_REQ' packet. if( !xbeeZB.inNetwork ) { COMM.sendError(NODE_HAS_NOT_BEEN_INVITED_TO_THE_NETWORK_YET___USE_ADD_NODE_REQ); return 1; } // 3. If authorized try to set the new frequency RTCUt.getTime(); if( !xbeeZB.setNewDefaultTime2Sleep( ToMask(receivedPaq->data ) ) ) { // 4A. If ok, send answer containing the new default frequency back PackUtils.packetSize = 2; //needed in escapZeros function PackUtils.packetData[0] = MSByte(xbeeZB.defaultTime2WakeInt); PackUtils.packetData[1] = LSByte(xbeeZB.defaultTime2WakeInt); char * contentToSend = (char *) calloc(PackUtils.packetSize + 1, sizeof(char)); PackUtils.escapeZerosInPacketData(contentToSend); error = COMM.sendMessage(xbeeZB.GATEWAY_MAC, CH_NODE_FREQ_RES, contentToSend); free(contentToSend); contentToSend = NULL; return 0; } else { // 4B. If invalid, send error COMM.sendError(NODE_RECEIVED_INVALID_NEW_DEFAULT_SLEEP_TIME); return 1; } }
void PAQUtils::getPacketMask(packetXBee * paq) { mask = ToMask(paq->data); }
uint8_t SensorUtils::sensorValue2Chars(float value, SensorType type) { uint8_t error = 2; //unsigned int i = 0; uint16_t i = 0; switch(type) { case TEMPERATURE: { // TEMPERATURE SENSOR: RANGE: -40° -> +125° //USB.print("temp value = "); USB.println( value ); value += 40; // negative values start at 0 value *= 100; // accuracy: 2 decimals (1 dec is ok but have 4 bits left anyway) /* i = (unsigned int) value; temp[0] = i/256; // (i & 0xFF00)>>8; temp[1] = i%256; // i & 0x00FF; */ temp[0] = MSByte(value); temp[1] = LSByte(value); (unsigned int) value == ToMask(temp) ? error = 0 : error = 1; } break; case HUMIDITY: { hum = (unsigned int) value; error = 0; } break; case PRESSURE: { value *= 100; // accuracy: 2 decimals i = (unsigned int) value; pres[0] = MSByte(i); pres[1] = LSByte(i); (unsigned int) i == ToMask(pres) ? error = 0 : error = 1; } break; case BATTERY: { bat = (unsigned int) value; error = 0; } break; case CO2: { co_2[0] = MSByte(value); co_2[1] = LSByte(value); (unsigned int) value == ToMask(co_2) ? error = 0 : error = 1; } break; case ANEMO: { an = (unsigned int) value; error = 0; } case VANE: // No conversion needed, value is sent in PAQUtils::InsertVane() error = 0; break; case PLUVIO: { rain_count[0] = MSByte(value); rain_count[1] = LSByte(value); (unsigned int) value == ToMask(rain_count) ? error = 0 : error = 1; } break; case LUMINOSITY: { value *= 100; value /= MAX_LUMINOSITY; // To a percentage lum = (unsigned int) value; error = 0; } break; case SOLAR_RADIATION: { i = ( unsigned int ) value; radiation[0] = MSByte(i); radiation[1] = LSByte(i); error = 0; } break; default: { error = 1; COMM.sendError(NODE_HAD_AN_ERROR_IN_SENSOR_VALUE_2_CHARS); } break; } return error; }
constexpr bool Contains(E e) const { return (mask & ToMask(e)) != 0; }
void Add(const E e) { mask |= ToMask(e); }
constexpr EnumBitSet(E e, Args&&... args) :mask(ToMask(e, args...)) {}
static constexpr I ToMask(E e, Args&&... args) { return ToMask(e) | ToMask(args...); }