void
test_int32_to_text(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_TEXT, 0);
cast_int32(2929);
cut_assert_equal_string("2929", GRN_TEXT_VALUE(&dest));
}
void
test_int32_to_float(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_FLOAT, 0);
cast_int32(29);
cut_assert_equal_double(29, 0.1, GRN_FLOAT_VALUE(&dest));
}
void
test_int32_to_uint32(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_UINT32, 0);
cast_int32(29292929);
cut_assert_equal_uint(29292929, GRN_UINT32_VALUE(&dest));
}
virtual void on_pdo_message(PDO_MESSAGE * pdo, int size)
{
int stride = parent->device->oversampling_rate;
int32_t cyc = cast_int32(cycle, pdo->buffer, 0);
if(lastCycle == cyc)
{
// skip duplicates
//printf("%s Duplicate %d\n", parent->portName, cyc);
return;
}
if((lastCycle + 1) % 65536 != cyc)
{
xfc->lock();
xfc->incMissed();
xfc->unlock();
}
lastCycle = cyc;
int16_t * samples = (int16_t *)(pdo->buffer + sample->offset);
wave->lock();
for(int s = 0; s < stride; s++)
{
wave->setPutsample(samples[s]);
}
wave->unlock();
}
void
test_int32_to_int16(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_INT16, 0);
cast_int32(-2929);
cut_assert_equal_int(-2929, GRN_INT16_VALUE(&dest));
}
void
test_int32_to_uint64(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_UINT64, 0);
cast_int32(29292929);
gcut_assert_equal_uint64(G_GUINT64_CONSTANT(29292929),
GRN_UINT64_VALUE(&dest));
}
void
test_int32_to_bool(gconstpointer data)
{
grn_obj_reinit(&context, &dest, GRN_DB_BOOL, 0);
cast_int32(gcut_data_get_int(data, "number"));
cut_assert_equal_boolean(gcut_data_get_uint(data, "expected"),
GRN_BOOL_VALUE(&dest));
}
int main(void)
{
cast_int8();
cast_int16();
cast_int32();
cast_string();
exit(0);
}
void
test_int32_to_time(void)
{
long long int sec, usec;
grn_obj_reinit(&context, &dest, GRN_DB_TIME, 0);
cast_int32(1259009530);
GRN_TIME_UNPACK(GRN_TIME_VALUE(&dest), sec, usec);
cut_assert_equal_int(1259009530, sec);
cut_assert_equal_int(0, usec);
}
int show_pdo_data(char * buffer, int size, EC_CONFIG *cfg)
{
static int c = 0;
if(c%1000==0)
{
c=0;
}
else
{
c++;
return 0;
}
EC_MESSAGE * msg = (EC_MESSAGE *)buffer;
assert(msg->tag == MSG_PDO);
int n;
for(n = 0; n < size; n++)
{
printf("%02x ", (unsigned char)buffer[n]);
if((n % 8) == 15)
{
printf("\n");
}
}
printf("\n");
printf("bus cycle %d working counter %d state %d\n", msg->pdo.cycle, msg->pdo.working_counter,
msg->pdo.wc_state);
ELLNODE * node;
for(node = ellFirst(&cfg->devices); node; node = ellNext(node))
{
EC_DEVICE * device = (EC_DEVICE *)node;
printf("%s\n", device->name);
ELLNODE * node1;
for(node1 = ellFirst(&device->pdo_entry_mappings); node1; node1 = ellNext(node1))
{
EC_PDO_ENTRY_MAPPING * mapping = (EC_PDO_ENTRY_MAPPING *)node1;
printf(" %s ", mapping->pdo_entry->parent->name);
printf( "%s ", mapping->pdo_entry->datatype);
if(mapping->pdo_entry->oversampling)
{
for(n = 0; n < mapping->parent->oversampling_rate; n++)
{
printf("%d ", cast_int32(mapping, msg->pdo.buffer, n));
}
printf("\n");
}
else
{
int32_t val = cast_int32(mapping, msg->pdo.buffer, 0);
printf("%d\n", val);
}
}
}
printf("\n");
// store these in the ASYN int32 attributes for this device
return 0;
}
void ecAsyn::on_pdo_message(PDO_MESSAGE * pdo, int size)
{
lock();
char * meta = pdo->buffer + pdo->size + SLAVE_METADATA_CNT * devid;
assert(meta + 1 - pdo->buffer < size);
epicsInt32 slave_info = meta[0];
epicsInt32 al_state = meta[1];
epicsInt32 error_flag = meta[2];
epicsInt32 disable = pdo->wc_state != EC_WC_COMPLETE
|| al_state != EC_AL_STATE_OP
|| slave_info != 0;
asynStatus paramStatus = asynSuccess;
if (slave_info != 0)
{
paramStatus = asynDisconnected;
}
// perhaps set paramStatus to
// asynDisabled if pdo->wc_state != EC_WC_COMPLETE
setIntegerParam(P_SLAVEINFO, slave_info);
setIntegerParam(P_AL_STATE, al_state);
setParamStatus(P_AL_STATE, paramStatus);
setIntegerParam(P_ERROR_FLAG, error_flag);
setParamStatus(P_ERROR_FLAG, paramStatus);
setIntegerParam(P_DISABLE, disable);
setParamStatus(P_DISABLE, paramStatus);
for(ELLNODE * node = ellFirst(&device->pdo_entry_mappings); node; node = ellNext(node))
{
EC_PDO_ENTRY_MAPPING * mapping = (EC_PDO_ENTRY_MAPPING *)node;
int mpdoe_param = mapping->pdo_entry->parameter;
if (mapping->pdo_entry->datatype[0] == 'F')
{
double val = cast_double(mapping, pdo->buffer, 0);
if (disable)
{
setDoubleParam(mpdoe_param, MINFLOAT);
}
else
{
setDoubleParam(mpdoe_param, val);
}
setParamStatus(mpdoe_param, paramStatus);
}
else
{
int32_t val = cast_int32(mapping, pdo->buffer, 0);
// can't make SDIS work with I/O intr (some values get lost)
// so using this for now
if(disable)
{
setIntegerParam(mpdoe_param, INT32_MIN);
}
else
{
setIntegerParam(mpdoe_param, val);
}
setParamStatus(mpdoe_param, paramStatus);
}
}
callParamCallbacks();
unlock();
}
virtual void on_pdo_message(PDO_MESSAGE * pdo, int size)
{
wave->lock();
wave->setPutsample(cast_int32(sample, pdo->buffer, 0));
wave->unlock();
}
