NITFPRIV(NITF_BOOL) toInt(nitf_Field * field,
NITF_DATA * outData,
size_t length, nitf_Error * error)
{
/* First we have to figure out what we are storing...
See, its okay to convert a BCS-N to an int, and...
its also okay to maintain a binary int... */
NITF_BOOL status = NITF_FAILURE;
if (field->type == NITF_BINARY)
{
switch (field->length)
{
case 2:
status = toInt16(field, (nitf_Int16 *) outData, error);
break;
case 4:
status = toInt32(field, (nitf_Int32 *) outData, error);
break;
case 8:
status = toInt64(field, (nitf_Int64 *) outData, error);
break;
default:
nitf_Error_initf(error, NITF_CTXT,
NITF_ERR_INVALID_PARAMETER,
"Unexpected field size for int [%d]",
field->length);
}
}
else
{
status = fromStringToInt(field, outData, length, error);
}
return status;
}
static void lengthAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Local<v8::Object> holder = info.Holder();
ExceptionState exceptionState(ExceptionState::SetterContext, "length", "TestIntegerIndexed", holder, info.GetIsolate());
TestIntegerIndexed* impl = V8TestIntegerIndexed::toImpl(holder);
int cppValue = toInt16(info.GetIsolate(), v8Value, NormalConversion, exceptionState);
if (exceptionState.throwIfNeeded())
return;
impl->setLength(cppValue);
}
/* We may want to rethink this function a bit.
* The NITF spec. has many fields with a BINARY_INTEGER type
* This could mean that the field contains 3 8-bit binary integers
* For that example, the length of the field is 3, which isn't an integer size
* Thus, that wouldn't work here if we just assumed BINARY_INTEGER has ONE integer in the field
*/
NITFPRIV(NITF_BOOL) fromIntToString(nitf_Field * field, char *outValue,
size_t length, nitf_Error * error)
{
char buffer[256];
size_t actualLength = 0;
/* These are all two-step processes 1) get native int 2) NITF_SNPRINTF */
switch (field->length)
{
case 2:
{
nitf_Int16 int16;
if (!toInt16(field, &int16, error))
goto CATCH_ERROR;
actualLength = NITF_SNPRINTF(buffer, 256, "%d", int16);
}
break;
case 4:
{
nitf_Int32 int32;
if (!toInt32(field, &int32, error))
goto CATCH_ERROR;
actualLength = NITF_SNPRINTF(buffer, 256, "%ld", (long) int32);
}
break;
case 8:
{
nitf_Int64 int64;
if (!toInt64(field, &int64, error))
goto CATCH_ERROR;
actualLength = NITF_SNPRINTF(buffer, 256, "%lld", int64);
}
break;
default:
{
/* otherwise, it must not be an integer value */
return fromStringToString(field, outValue, length, error);
}
}
if (actualLength > length)
{
nitf_Error_initf(error, NITF_CTXT, NITF_ERR_INVALID_PARAMETER,
"Out value too small [%d] size required",
strlen(buffer));
return NITF_FAILURE;
}
strcpy(outValue, buffer);
return NITF_SUCCESS;
CATCH_ERROR:
return NITF_FAILURE;
}
//call periodically to keep serial console alive. Every call will produce a
//log on the dataflash
void logWriteLog(int16_t rightWingPWM,int16_t leftWingPWM,int16_t tailPWM,int16_t curThrottle){
if(_enableLog == LOGGING_ENABLED){
//===================
//gather data
//===================
_entry.header = LOG_PACKET_HEADER;
_entry.time = micros(); //running time in useconds
//AHRS values
Vector3f drift = _Ahrs->get_gyro_drift();
_entry.roll = toIntDeg(_Ahrs->roll,100);
_entry.pitch = toIntDeg(_Ahrs->pitch,100);
_entry.yaw = toIntDeg(_Ahrs->yaw,100);
_entry.driftX = toIntDeg(drift.x,1000);
_entry.driftY = toIntDeg(drift.y,1000);
_entry.driftZ = toIntDeg(drift.z,1000);
//Compass Heading Value
_entry.heading = toInt16(100*ToDeg(_Compass->calculate_heading(_Ahrs->get_dcm_matrix())));
//IMU raw values
Vector3f accel = _IMU->get_accel();
Vector3f gyro = _IMU->get_gyro();
_entry.accX = toInt16(100*accel.x);
_entry.accY = toInt16(100*accel.y);
_entry.accZ = toInt16(100*accel.z);
_entry.gyroX = toIntDeg(gyro.x,100);
_entry.gyroY = toIntDeg(gyro.y,100);
_entry.gyroZ = toIntDeg(gyro.z,100);
//servo / throttle outputs
_entry.rightWingPWM = rightWingPWM;
_entry.leftWingPWM = leftWingPWM;
_entry.tailPWM = tailPWM;
_entry.curThrottle = curThrottle;
//write log
logWriteEntry(&_entry);
}//end active log check
}
int16_t toInt16(v8::Handle<v8::Value> value)
{
NonThrowableExceptionState exceptionState;
return toInt16(value, NormalConversion, exceptionState);
}
static inline int16_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
{
return toInt16(value, configuration, exceptionState);
}
static inline int16_t toIntegral(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
{
return toInt16(isolate, value, configuration, exceptionState);
}
