void supla_client_channels::on_channel_value_changed(void *srpc, int DeviceId, int ChannelId) {
supla_client_channel *channel;
bool r = false;
safe_array_lock(arr);
for(int a=0;a<safe_array_count(arr);a++) {
channel = (supla_client_channel *)safe_array_get(arr, a);
if ( channel
&& channel->getDeviceId() == DeviceId
&& ( ChannelId == 0 || channel->getId() == ChannelId ) ) {
channel->mark_for_remote_update(CC_REMOTEUPDATE_CHANNELVALUE);
r = true;
}
}
safe_array_unlock(arr);
if ( srpc && r ) {
remote_update(srpc);
}
}
void remote_get_velocity_vector_from_remote(remote_t* remote, control_command_t* controls)
{
remote_update(remote);
controls->tvel[X]= - 10.0f * remote_get_pitch(remote) * RC_INPUT_SCALE;
controls->tvel[Y]= 10.0f * remote_get_roll(remote) * RC_INPUT_SCALE;
controls->tvel[Z]= - 1.5f * remote_get_throttle(remote);
controls->rpy[YAW] = remote_get_yaw(remote) * RC_INPUT_SCALE;
}
void remote_get_command_from_remote(remote_t* remote, control_command_t* controls)
{
remote_update(remote);
controls->rpy[ROLL]= remote_get_roll(remote) * RC_INPUT_SCALE;
controls->rpy[PITCH]= remote_get_pitch(remote) * RC_INPUT_SCALE;
controls->rpy[YAW]= remote_get_yaw(remote) * RC_INPUT_SCALE;
controls->thrust = remote_get_throttle(remote);
}
void remote_mode_update(remote_t* remote)
{
remote_mode_t* remote_mode = &remote->mode;
bool do_update = false;
remote_update(remote);
// Check whether modes should be updated
if ( remote_mode->use_disable_remote_mode_switch == true )
{
if ( remote->channels[remote_mode->disable_remote_mode_channel] >= 0.5f )
{
do_update = true;
}
else
{
do_update = false;
}
}
else
{
do_update = true;
}
// Do update if required
if( do_update == true )
{
// Fallback to safety
mav_mode_t new_desired_mode = remote_mode->safety_mode;
// Get armed flag from stick combinaison
mode_flag_armed_t flag_armed = get_armed_flag(remote);
if ( remote->channels[remote_mode->safety_channel] > 0 )
{
// Safety switch UP => Safety mode ON
new_desired_mode = remote_mode->safety_mode;
// Allow arm and disarm in safety mode
new_desired_mode.ARMED = flag_armed;
}
else
{
// Normal mode
// Get base mode
if ( remote->channels[remote_mode->mode_switch_channel] >= 0.5f )
{
// Mode switch UP
new_desired_mode = remote_mode->mode_switch_up;
}
else if ( remote->channels[remote_mode->mode_switch_channel] < 0.5f &&
remote->channels[remote_mode->mode_switch_channel] > -0.5f )
{
// Mode switch MIDDLE
new_desired_mode = remote_mode->mode_switch_middle;
}
else if ( remote->channels[remote_mode->mode_switch_channel] <= -0.5f )
{
// Mode switch DOWN
new_desired_mode = remote_mode->mode_switch_down;
}
// Apply custom flag
if ( remote_mode->use_custom_switch == true )
{
if ( remote->channels[remote_mode->custom_switch_channel] > 0.0f )
{
// Custom channel at 100% => CUSTOM_ON;
new_desired_mode.CUSTOM = CUSTOM_ON;
}
else
{
// Custom channel at -100% => CUSTOM_OFF;
new_desired_mode.CUSTOM = CUSTOM_OFF;
}
}
// Apply test flag
if ( remote_mode->use_test_switch == true )
{
if ( remote->channels[remote_mode->test_switch_channel] > 0.0f )
{
// Test channel at 100% => TEST_ON
new_desired_mode.TEST = TEST_ON;
}
else
{
// Test channel at -100% => TEST_OFF;
new_desired_mode.TEST = TEST_OFF;
}
}
// Allow only disarm in normal mode
if ( flag_armed == ARMED_OFF )
{
new_desired_mode.ARMED = ARMED_OFF;
}
else
{
// Keep current armed flag
new_desired_mode.ARMED = remote_mode->current_desired_mode.ARMED;
}
}
// Store desired mode
remote_mode->current_desired_mode = new_desired_mode;
}
}
signal_quality_t remote_check(remote_t* remote)
{
remote_update(remote);
return remote->signal_quality;
}
int main(int argc, char ** argv)
{
pami_client_t client;
pami_context_t context;
pami_result_t status = PAMI_ERROR;
pami_configuration_t pami_config;
pami_geometry_t world_geo;
size_t barrier_alg_num[2];
pami_algorithm_t* bar_always_works_algo = NULL;
pami_metadata_t* bar_always_works_md = NULL;
pami_algorithm_t* bar_must_query_algo = NULL;
pami_metadata_t* bar_must_query_md = NULL;
pami_xfer_t barrier;
int my_id;
volatile int is_fence_done = 0;
volatile int is_barrier_done = 0;
/* create PAMI client */
RC( PAMI_Client_create("TEST", &client, NULL, 0) );
DBG_FPRINTF((stderr,"Client created successfully at 0x%p\n",client));
/* create PAMI context */
RC( PAMI_Context_createv(client, NULL, 0, &context, 1) );
DBG_FPRINTF((stderr,"Context created successfully at 0x%p\n",context));
/* query my task id */
bzero(&pami_config, sizeof(pami_configuration_t));
pami_config.name = PAMI_CLIENT_TASK_ID;
RC( PAMI_Client_query(client, &pami_config, 1) );
my_id = pami_config.value.intval;
DBG_FPRINTF((stderr,"My task id is %d\n", my_id));
/* get the world geometry */
RC( PAMI_Geometry_world(client, &world_geo) );
DBG_FPRINTF((stderr,"World geometry is at 0x%p\n",world_geo));
/* query number of barrier algorithms */
RC( PAMI_Geometry_algorithms_num(world_geo, PAMI_XFER_BARRIER,
barrier_alg_num) );
DBG_FPRINTF((stderr,"%d-%d algorithms are available for barrier op\n",
barrier_alg_num[0], barrier_alg_num[1]));
if (barrier_alg_num[0] <= 0) {
fprintf (stderr, "Error. No (%lu) algorithm is available for barrier op\n",
barrier_alg_num[0]);
return 1;
}
/* query barrier algorithm list */
bar_always_works_algo =
(pami_algorithm_t*)malloc(sizeof(pami_algorithm_t)*barrier_alg_num[0]);
bar_always_works_md =
(pami_metadata_t*)malloc(sizeof(pami_metadata_t)*barrier_alg_num[0]);
bar_must_query_algo =
(pami_algorithm_t*)malloc(sizeof(pami_algorithm_t)*barrier_alg_num[1]);
bar_must_query_md =
(pami_metadata_t*)malloc(sizeof(pami_metadata_t)*barrier_alg_num[1]);
RC( PAMI_Geometry_algorithms_query(world_geo, PAMI_XFER_BARRIER,
bar_always_works_algo, bar_always_works_md, barrier_alg_num[0],
bar_must_query_algo, bar_must_query_md, barrier_alg_num[1]) );
DBG_FPRINTF((stderr,"Algorithm [%s] at 0x%p will be used for barrier op\n",
bar_always_works_md[0].name, bar_always_works_algo[0]));
/* begin PAMI fence */
RC( PAMI_Fence_begin(context) );
DBG_FPRINTF((stderr,"PAMI fence begins\n"));
/* ------------------------------------------------------------------------ */
pami_extension_t extension;
const char ext_name[] = "EXT_hfi_extension";
const char sym_name[] = "hfi_remote_update";
hfi_remote_update_fn remote_update = NULL;
hfi_remote_update_info_t remote_info;
pami_memregion_t mem_region;
size_t mem_region_sz = 0;
unsigned long long operand = 1234;
unsigned long long orig_val = 0;
int offset = (operand)%MAX_TABLE_SZ;
/* initialize table for remote update operation */
int i;
for (i = 0; i < MAX_TABLE_SZ; i ++) {
table[i] = (unsigned long long) i;
}
orig_val = table[offset];
/* open PAMI extension */
RC( PAMI_Extension_open (client, ext_name, &extension) );
DBG_FPRINTF((stderr,"Open %s successfully.\n", ext_name));
/* load PAMI extension function */
remote_update = (hfi_remote_update_fn)
PAMI_Extension_symbol (extension, sym_name);
if (remote_update == (void *)NULL)
{
fprintf (stderr, "Error. Failed to load %s function in %s\n",
sym_name, ext_name);
return 1;
} else {
DBG_FPRINTF((stderr,"Loaded function %s in %s successfully.\n",
sym_name, ext_name));
}
/* create a memory region for remote update operation */
RC( PAMI_Memregion_create(context, table,
MAX_TABLE_SZ*sizeof(unsigned long long),
&mem_region_sz, &mem_region) );
DBG_FPRINTF((stderr,"%d-byte PAMI memory region created successfully.\n",
mem_region_sz));
/* perform a PAMI barrier */
is_barrier_done = 0;
barrier.cb_done = barrier_done;
barrier.cookie = (void*)&is_barrier_done;
barrier.algorithm = bar_always_works_algo[0];
RC( PAMI_Collective(context, &barrier) );
DBG_FPRINTF((stderr,"PAMI barrier op invoked successfully.\n"));
while (is_barrier_done == 0)
PAMI_Context_advance(context, 1000);
DBG_FPRINTF((stderr,"PAMI barrier op finished successfully.\n"));
RC( PAMI_Context_lock(context) );
/* prepare remote update info */
remote_info.dest = my_id^1;
remote_info.op = 0; /* op_add */
remote_info.atomic_operand = operand;
remote_info.dest_buf = (unsigned long long)(&(table[offset]));
/* invoke remote update PAMI extension function */
RC( remote_update(context, 1, &remote_info) );
DBG_FPRINTF((stderr,"Function %s invoked successfully.\n",
sym_name));
RC( PAMI_Context_unlock(context) );
/* perform a PAMI fence */
is_fence_done = 0;
RC( PAMI_Fence_all(context, fence_done, (void*)&is_fence_done) );
DBG_FPRINTF((stderr,"PAMI_Fence_all invoked successfully.\n"));
while (is_fence_done == 0)
PAMI_Context_advance(context, 1000);
DBG_FPRINTF((stderr,"PAMI_Fence_all finished successfully.\n"));
/* perform a PAMI barrier */
is_barrier_done = 0;
barrier.cb_done = barrier_done;
barrier.cookie = (void*)&is_barrier_done;
barrier.algorithm = bar_always_works_algo[0];
RC( PAMI_Collective(context, &barrier) );
DBG_FPRINTF((stderr,"PAMI barrier op invoked successfully.\n"));
while (is_barrier_done == 0)
PAMI_Context_advance(context, 1000);
DBG_FPRINTF((stderr,"PAMI barrier op finished successfully.\n"));
/* verify data after remote update operation */
if (table[offset] != orig_val + operand) {
printf("Data verification at offset %d with operand %lu failed: "
"[%lu expected with %lu updated]\n",
offset, operand, orig_val+operand, table[offset]);
} else {
printf("Data verification at offset %d with operand %lu passed: "
"[%lu expected with %lu updated].\n",
offset, operand, orig_val+operand, table[offset]);
}
/* destroy the memory region after remote update operation */
RC( PAMI_Memregion_destroy(context, &mem_region) );
DBG_FPRINTF((stderr,"PAMI memory region removed successfully.\n"));
/* close PAMI extension */
RC( PAMI_Extension_close (extension) );
DBG_FPRINTF((stderr,"Close %s successfully.\n", ext_name));
/* ------------------------------------------------------------------------ */
/* end PAMI fence */
RC( PAMI_Fence_end(context) );
DBG_FPRINTF((stderr,"PAMI fence ends\n"));
/* destroy PAMI context */
RC( PAMI_Context_destroyv(&context, 1) );
DBG_FPRINTF((stderr, "PAMI context destroyed successfully\n"));
/* destroy PAMI client */
RC( PAMI_Client_destroy(&client) );
DBG_FPRINTF((stderr, "PAMI client destroyed successfully\n"));
return 0;
}
