//////////////////////////////////////////////////////////////////////////
// @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...);
}
