int osc_controller::_deactivate_cb(const char* path, const char* types,
lo_arg** argv, int argc, lo_message msg)
{
if (!m_restricted || is_target (lo_message_get_source(msg))) {
pair<int,int> net_id(argv[0]->i, argv[1]->i);
map<pair<int,int>, int>::iterator it = m_local_id.find(net_id);
world_node obj;
if (it != m_local_id.end() &&
!(obj = m_world->find_node(it->second)).is_null()) {
m_skip++;
m_world->deactivate_node(obj);
m_skip--;
if (m_broadcast) {
lo_message newmsg = lo_message_new();
lo_message_add_int32(newmsg, argv[0]->i);
lo_message_add_int32(newmsg, argv[1]->i);
broadcast_message_from(PSYNTH_OSC_MSG_DEACTIVATE, newmsg, lo_message_get_source(msg));
lo_message_free(newmsg);
}
}
}
return 0;
}
int osc_controller::_add_cb(const char* path, const char* types,
lo_arg** argv, int argc, lo_message msg)
{
if (!m_restricted || is_target(lo_message_get_source(msg))) {
pair<int,int> net_id(argv[0]->i, argv[1]->i);
m_skip++;
world_node obj = m_world->add_node(std::string(&argv[2]->s));
m_skip--;
if (!obj.is_null()) {
int local_id = obj.get_id ();
m_net_id[local_id] = net_id;
m_local_id[net_id] = local_id;
if (m_broadcast) {
lo_message newmsg = lo_message_new();
lo_message_add_int32(newmsg, argv[0]->i);
lo_message_add_int32(newmsg, argv[1]->i);
lo_message_add_string(newmsg, &argv[2]->s);
broadcast_message_from(PSYNTH_OSC_MSG_ADD, newmsg, lo_message_get_source(msg));
lo_message_free(newmsg);
}
}
}
return 0;
}
void nfosc_stop() {
int i;
if (!running) return;
running = false;
if( main_thread ) pthread_detach(main_thread);
main_thread = NULL;
lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE);
for (i=0;i<buffer_size;i++) {
lo_message del_message = lo_message_new();
lo_message_add_int32(del_message, tag_buffer[i].device_id);
lo_message_add_int32(del_message, tag_buffer[i].symbol_id);
lo_message_add_int32(del_message, tag_buffer[i].type_id);
lo_message_add_string(del_message, tag_buffer[i].uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message);
if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].session_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str);
}
lo_timetag frame_time;
lo_timetag_now (&frame_time);
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]==NULL) continue;
lo_message frm_message = lo_message_new();
lo_message_add_int32(frm_message, -1);
lo_message_add_timetag(frm_message, frame_time);
lo_message_add_int32(frm_message, 0); // sensor dim
if (device_count>1) sprintf(source_string, "NFOSC:%d",dev);
lo_message_add_string(frm_message, source_string); // source name
lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message);
lo_message sid_message = lo_message_new();
lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message);
}
int ret = lo_send_bundle(target, osc_bundle);
if(ret == -1) {
fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target));
exit(1);
}
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]!=NULL) {
printf("closing NFC reader #%d: %s\n",dev,nfc_device_get_name(pnd[dev]));
nfc_close(pnd[dev]);
}
}
nfc_exit(context);
write_database();
}
static void message_add_coerced_signal_value(lo_message m,
mapper_signal sig,
mapper_signal_instance si,
const char coerce_type)
{
int i;
if (sig->props.type == 'f') {
float *v = si->value;
if (coerce_type == 'f') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_float(m, v[i]);
}
else if (coerce_type == 'i') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_int32(m, (int)v[i]);
}
else if (coerce_type == 'd') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_double(m, (double)v[i]);
}
}
else if (sig->props.type == 'i') {
int *v = si->value;
if (coerce_type == 'i') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_int32(m, v[i]);
}
else if (coerce_type == 'f') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_float(m, (float)v[i]);
}
else if (coerce_type == 'd') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_double(m, (double)v[i]);
}
}
else if (sig->props.type == 'd') {
double *v = si->value;
if (coerce_type == 'd') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_double(m, (int)v[i]);
}
else if (coerce_type == 'i') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_int32(m, (int)v[i]);
}
else if (coerce_type == 'f') {
for (i = 0; i < sig->props.length; i++)
lo_message_add_float(m, (float)v[i]);
}
}
}
void send_joystick_info(int joy_idx)
{
SDL_Joystick * joy = joysticks.find( joy_idx )->second;
lo_message m1 = lo_message_new();
lo_message_add_string( m1, SDL_JoystickName(joy_idx) );
lo_message_add_int32( m1, joy_idx );
lo_message_add_int32( m1, SDL_JoystickNumAxes(joy) );
lo_message_add_int32( m1, SDL_JoystickNumButtons(joy) );
lo_message_add_int32( m1, SDL_JoystickNumHats(joy) );
lo_message_add_int32( m1, SDL_JoystickNumBalls(joy) );
lo_send_message_from( t, s, "/joystick/info", m1 );
}
lo_message get_joystick_info_msg(int joy_idx, SDL_Joystick * joy )
{
// SDL_Joystick * joy = joysticks.find( joy_idx )->second;
lo_message m1 = lo_message_new();
lo_message_add_string( m1, SDL_JoystickName(joy_idx) );
lo_message_add_int32( m1, joy_idx );
lo_message_add_int32( m1, SDL_JoystickNumAxes(joy) );
lo_message_add_int32( m1, SDL_JoystickNumButtons(joy) );
lo_message_add_int32( m1, SDL_JoystickNumHats(joy) );
lo_message_add_int32( m1, SDL_JoystickNumBalls(joy) );
// lo_send_message_from( t, s, "/joystick/info", m1 );
return m1;
}
lo_message make_message(int i, char *s)
{
lo_message msg = lo_message_new();
lo_message_add_int32(msg, i);
lo_message_add_string(msg, s);
return msg;
}
void mapper_slot_add_props_to_message(lo_message msg, mapper_slot slot,
int is_dest, int staged)
{
char temp[16];
if (is_dest)
snprintf(temp, 16, "@dst");
else if (slot->id == 0)
snprintf(temp, 16, "@src");
else
snprintf(temp, 16, "@src.%d", slot->id);
int len = strlen(temp);
if (!staged && slot->signal->local) {
// include length from associated signal
snprintf(temp+len, 16-len, "%s", mapper_protocol_string(AT_LENGTH));
lo_message_add_string(msg, temp);
lo_message_add_int32(msg, slot->signal->length);
// include type from associated signal
snprintf(temp+len, 16-len, "%s", mapper_protocol_string(AT_TYPE));
lo_message_add_string(msg, temp);
lo_message_add_char(msg, slot->signal->type);
}
mapper_table_add_to_message(0, staged ? slot->staged_props : slot->props,
msg);
if (staged) {
// clear the staged properties
mapper_table_clear(slot->staged_props);
}
}
void osc_controller::handle_activate_node(world_node& obj)
{
if (!m_skip) {
int local_id(obj.get_id ());
pair<int,int> net_id = m_net_id[local_id];
lo_message msg = lo_message_new();
lo_message_add_int32(msg, net_id.first);
lo_message_add_int32(msg, net_id.second);
broadcast_message(PSYNTH_OSC_MSG_ACTIVATE, msg);
lo_message_free(msg);
}
}
void Client::send( const osc::Message &message )
{
lo_message msg = lo_message_new();
for ( size_t i = 0; i < message.getNumArgs(); i++ )
{
switch ( message.getArgType( i ) )
{
case 'i':
lo_message_add_int32( msg, message.getArg< int32_t >( i ) );
break;
case 'f':
lo_message_add_float( msg, message.getArg< float >( i ) );
break;
case 's':
lo_message_add_string( msg, message.getArg< std::string >( i ).c_str() );
break;
default:
break;
}
}
lo_send_message( mAddress, message.getAddressPattern().c_str(), msg );
lo_message_free( msg );
}
void mapper_monitor_link(mapper_monitor mon,
const char* source_device,
const char* dest_device,
mapper_db_link_t *props,
unsigned int props_flags)
{
if (props && (props_flags & LINK_NUM_SCOPES) && props->num_scopes &&
((props_flags & LINK_SCOPE_NAMES) || (props_flags & LINK_SCOPE_HASHES))) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_string(m, source_device);
lo_message_add_string(m, dest_device);
lo_message_add_string(m, "@scope");
int i;
if (props_flags & LINK_SCOPE_NAMES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_string(m, props->scope_names[i]);
}
}
else if (props_flags & LINK_SCOPE_HASHES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_int32(m, props->scope_hashes[i]);
}
}
lo_send_message(mon->admin->admin_addr, "/link", m);
free(m);
}
else
mapper_admin_send_osc( mon->admin, 0, "/link", "ss",
source_device, dest_device );
}
void osc_controller::handle_set_param_node(world_node& obj, int param_id)
{
if (!m_skip) {
int local_id(obj.get_id ());
pair<int,int> net_id = m_net_id[local_id];
lo_message msg = lo_message_new();
lo_message_add_int32(msg, net_id.first);
lo_message_add_int32(msg, net_id.second);
lo_message_add_int32(msg, param_id);
switch(obj.get_param_type(param_id)) {
case graph::node_param::INT: {
int val;
obj.get_param(param_id, val);
lo_message_add_int32(msg, val);
break;
}
case graph::node_param::FLOAT: {
float val;
obj.get_param(param_id, val);
lo_message_add_float(msg, val);
break;
}
case graph::node_param::STRING: {
string val;
obj.get_param(param_id, val);
lo_message_add_string(msg, val.c_str());
break;
}
case graph::node_param::VECTOR2F: {
base::vector_2f val;
obj.get_param(param_id, val);
lo_message_add_float(msg, val.x);
lo_message_add_float(msg, val.y);
break;
}
default:
break;
}
broadcast_message(PSYNTH_OSC_MSG_PARAM, msg);
lo_message_free(msg);
}
}
// Generate OSC message with default format
void genOscMsg(lo_bundle *bundle, char *name, int buffIndex) {
if (handMode || posConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
for (int i = 0; i < nDimensions; i++)
lo_message_add_float(msg, jointCoords[i]);
lo_bundle_add_message(*bundle, "/joint", msg);
}
if (!kitchenMode && sendOrient && orientConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
// x data is in first column
lo_message_add_float(msg, jointOrients[0]);
lo_message_add_float(msg, jointOrients[0+3]);
lo_message_add_float(msg, jointOrients[0+6]);
// y data is in 2nd column
lo_message_add_float(msg, jointOrients[1]);
lo_message_add_float(msg, jointOrients[1+3]);
lo_message_add_float(msg, jointOrients[1+6]);
// z data is in 3rd column
lo_message_add_float(msg, jointOrients[2]);
lo_message_add_float(msg, jointOrients[2+3]);
lo_message_add_float(msg, jointOrients[2+6]);
lo_bundle_add_message(*bundle, "/orient", msg);
}
}
//=========================================================
void io_simple_int(char *path, int i)
{
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_int32(msgio, i);
lo_send_message(loio, path, msgio);
lo_message_free(msgio);
}
}
static void
connect_callback (jack_port_id_t a, jack_port_id_t b, int yn, void* arg)
{
lo_message reply=lo_message_new();
lo_message_add_int32(reply,a);
lo_message_add_int32(reply,b);
if(yn)
{
lo_send_message (loa, "/oscev/port/connected", reply);
}
else
{
lo_send_message (loa, "/oscev/port/disconnected", reply);
}
lo_message_free (reply);
printf ("Ports %d and %d %s\n", a, b, (yn ? "connected" : "disconnected"));
}
void osc_controller::handle_add_node(world_node& obj)
{
if (!m_skip) {
int local_id(obj.get_id ());
pair<int,int> net_id(m_id, local_id);
m_local_id[net_id] = local_id;
m_net_id[local_id] = net_id;
lo_message msg = lo_message_new();
lo_message_add_int32(msg, net_id.first);
lo_message_add_int32(msg, net_id.second);
lo_message_add_string(msg, obj.get_name().c_str());
broadcast_message(PSYNTH_OSC_MSG_ADD, msg);
lo_message_free(msg);
}
}
// parse a list of Prolog terms and add arguments to an OSC message
static int add_msg_args(lo_message msg, term_t list)
{
term_t head=PL_new_term_ref();
// copy term ref so as not to modify original
list=PL_copy_term_ref(list);
while (PL_get_list(list,head,list)) {
atom_t name;
int arity;
const char *type;
if (!PL_get_name_arity(head,&name,&arity)) return type_error(head,"term");
type=PL_atom_chars(name);
switch (arity) {
case 1: {
term_t a1=PL_new_term_ref();
PL_get_arg(1,head,a1);
if (!strcmp(type,"int")) {
int x;
if (!PL_get_integer(a1,&x)) return type_error(a1,"integer");
lo_message_add_int32(msg,x);
} else if (!strcmp(type,"double")) {
double x;
if (!PL_get_float(a1,&x)) return type_error(a1,"float");
lo_message_add_double(msg,x);
} else if (!strcmp(type,"string")) {
char *x;
if (!PL_get_chars(a1,&x,CVT_ATOM|CVT_STRING)) return type_error(a1,"string");
lo_message_add_string(msg,x);
} else if (!strcmp(type,"symbol")) {
char *x;
if (!PL_get_chars(a1,&x,CVT_ATOM)) return type_error(a1,"atom");
lo_message_add_symbol(msg,x);
} else if (!strcmp(type,"float")) {
double x;
if (!PL_get_float(a1,&x)) return type_error(a1,"float");
lo_message_add_float(msg,(float)x);
}
break;
}
case 0: {
if (!strcmp(type,"true")) lo_message_add_true(msg);
else if (!strcmp(type,"false")) lo_message_add_false(msg);
else if (!strcmp(type,"nil")) lo_message_add_nil(msg);
else if (!strcmp(type,"inf")) lo_message_add_infinitum(msg);
break;
}
}
}
if (!PL_get_nil(list)) return type_error(list,"nil");
return TRUE;
}
int text_read(char **_path, lo_message *_m, lo_timetag *_tt)
{
const char *delim = " \r\n";
char str[1024];
if (!fgets(str, 1024, input_file))
return 1;
char *t, *p, *s = strtok_r(str, delim, &p);
lo_timetag tt;
lo_message m = lo_message_new();
char *path;
if (s) {
tt.sec = atoi(s);
}
s = strtok_r(0, delim, &p);
if (s) {
tt.frac = atoi(s);
}
s = strtok_r(0, delim, &p);
if (s) {
path = s;
}
s = strtok_r(0, delim, &p);
if (s) {
t = s;
}
while ((s = strtok_r(0, delim, &p))) {
switch (*t) {
case 'i':
lo_message_add_int32(m, atoi(s));
break;
case 'f':
lo_message_add_float(m, atof(s));
break;
case 's':
lo_message_add_string(m, s);
break;
}
if (*(t+1))
t++;
}
_tt->sec = tt.sec;
_tt->frac = tt.frac;
*_m = m;
*_path = strdup(path);
return 0;
}
void mapper_receiver_send_release_request(mapper_receiver rc,
mapper_signal sig,
mapper_signal_instance si,
mapper_timetag_t tt)
{
mapper_receiver_signal rs = rc->signals;
mapper_connection c;
if (!mapper_receiver_in_scope(rc, si->id_map->group))
return;
while (rs) {
if (rs->signal == sig)
break;
rs = rs->next;
}
if (!rs)
return;
//lo_bundle b = lo_bundle_new(tt);
lo_bundle b = lo_bundle_new(LO_TT_IMMEDIATE);
c = rs->connections;
while (c) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_int32(m, si->id_map->group);
lo_message_add_int32(m, si->id_map->remote);
lo_message_add_false(m);
lo_bundle_add_message(b, c->props.src_name, m);
c = c->next;
}
if (lo_bundle_count(b))
lo_send_bundle_from(rc->props.src_addr, rc->device->server, b);
lo_bundle_free_messages(b);
}
void *veejay_message_new_widget( void *osc, const char *str1,const char *str2, int n_names )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_int32( lmsg, n_names );
return (void*) lmsg;
}
void veejay_bundle_sample_add_fx_atom( void *osc, int id,int entry, const char *word, const char *format, int type, void *value )
{
char osc_path[256];
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
sprintf(osc_path, "/sample_%d/fx_%d/%s", id, entry,word );
lo_message lmsg = lo_message_new();
char realwin[128];
sprintf(realwin, "%sFX%d", c->window, entry );
lo_message_add_string(lmsg, realwin );
lo_message_add_string(lmsg, osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
int mapper_router_send_query(mapper_router rtr, mapper_signal sig,
mapper_timetag_t tt)
{
if (!sig->local->update_handler) {
trace("not sending queries since signal has no handler.\n");
return 0;
}
// find the corresponding router_signal
mapper_router_signal rs = rtr->signals;
while (rs && rs->signal != sig)
rs = rs->next;
// exit without failure if signal is not mapped
if (!rs)
return 0;
// for each map, query remote signals
int i, j, count = 0;
char query_string[256];
for (i = 0; i < rs->num_slots; i++) {
if (!rs->slots[i])
continue;
mapper_map map = rs->slots[i]->map;
if (map->status != STATUS_ACTIVE)
continue;
lo_message msg = lo_message_new();
if (!msg)
continue;
lo_message_add_string(msg, sig->path);
lo_message_add_int32(msg, sig->length);
lo_message_add_char(msg, sig->type);
// TODO: include response address as argument to allow TCP queries?
// TODO: always use TCP for queries?
if (rs->slots[i]->direction == MAPPER_DIR_OUTGOING) {
snprintf(query_string, 256, "%s/get", map->destination.signal->path);
send_or_bundle_message(map->destination.link, query_string, msg, tt);
}
else {
for (j = 0; j < map->num_sources; j++) {
snprintf(query_string, 256, "%s/get", map->sources[j]->signal->path);
send_or_bundle_message(map->sources[j]->link, query_string, msg, tt);
}
}
++count;
}
return count;
}
static void
port_callback (jack_port_id_t port, int yn, void* arg)
{
lo_message reply=lo_message_new();
lo_message_add_int32(reply,port);
if(yn)
{
lo_send_message (loa, "/oscev/port/registered", reply);
}
else
{
lo_send_message (loa, "/oscev/port/unregistered", reply);
}
lo_message_free (reply);
printf ("Port %d %s\n", port, (yn ? "registered" : "unregistered"));
}
static int _vevo_get_int( void *port, const char *key, int n_elem, lo_message lmsg )
{
int32_t *values = NULL;
if( n_elem == 0 )
return VEVO_NO_ERROR;
values = (int32_t*) vj_malloc(sizeof(int32_t) * n_elem );
int i;
int error;
for( i = 0; i < n_elem; i ++ )
{
error = vevo_property_get( port, key, i, &(values[i]));
lo_message_add_int32( lmsg, values[i]);
}
return VEVO_NO_ERROR;
}
void veejay_bundle_add_atom( void *osc, const char *osc_path, const char *format, int type, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg,c->window );
lo_message_add_string( lmsg,osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
void veejay_bundle_plugin_add( void *osc, const char *window, const char *path, const char *format, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, window );
lo_message_add_string(lmsg, path );
int n_elem = strlen( format );
int ival;
char *str;
double gval;
uint64_t val;
switch(*format)
{
case 's':
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case 'i':
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case 'd':
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case 'h':
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
void ModuleManager::deleteModuleList()
{
int sock, n, d_len;
struct sockaddr_in addr;
void *data;
char path[] = "/ModuleList/deleteMList";
char p[64];
int mColor;
strcpy(p, OSCAddr);
strcat(p, mPath);
//create lo_message
lo_message m = lo_message_new();
lo_message_add_string(m, IPAddr);
lo_message_add_string(m, p);
lo_message_add_int32(m, mColor);
data = lo_message_serialise(m, path, NULL, NULL);
d_len = lo_message_length(m, path);
//create socket
int opt = 1;
sock = socket(AF_INET, SOCK_DGRAM, 0);
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(int));
addr.sin_family = AF_INET;
addr.sin_port = htons(6340);
inet_pton(AF_INET, "255.255.255.255", &addr.sin_addr.s_addr);
//send(念のため3回)
for (int j=0; j<3; j++) {
n = sendto(sock, data, d_len, 0, (struct sockaddr *)&addr, sizeof(addr));
if (n < 1) {
perror("sendto");
}
usleep(1000);
}
lo_message_free(m);
close(sock);
}
int info_handler(const char *path, const char *types, lo_arg **argv, int argc,
void *data, void *user_data)
{
// printf("info message\n");
// fflush(stdout);
lo_bundle b = lo_bundle_new( LO_TT_IMMEDIATE );
int num_joysticks = SDL_NumJoysticks();
// printf("Found %d joystick(s)\n\n", num_joysticks);
lo_message m1 = lo_message_new();
lo_message_add_int32( m1, num_joysticks );
lo_bundle_add_message( b, "/joystick/number", m1 );
int joy_idx;
for(joy_idx = 0; joy_idx < num_joysticks; ++joy_idx)
{
SDL_Joystick* joy = SDL_JoystickOpen(joy_idx);
if (!joy)
{
fprintf(stderr, "Unable to open joystick %d\n", joy_idx);
}
else
{
lo_message m2 = get_joystick_info_msg( joy_idx, joy );
lo_bundle_add_message( b, "/joystick/info", m2 );
// print_joystick_info(joy_idx, joy);
SDL_JoystickClose(joy);
}
// }
}
if ( lo_send_bundle_from( t, s, b ) == -1 ){
{ printf("sd2osc/info: OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); }
}
lo_bundle_free( b );
fflush(stdout);
return 0;
}
int osc_send_ints( const char *port, const char *msg, int count, int *val)
{
lo_address t = lo_address_new(NULL, port);
lo_message message = lo_message_new();
int i;
for( i = 0; i < count; i++)
{
lo_message_add_int32( message, val[i]);
}
if( !lo_send_message( t, msg, message))
{
printf("OSC error %d: %s\n", lo_address_errno(t),
lo_address_errstr(t));
}
if( osc_log) osc_log_print( msg, message);
lo_message_free( message);
lo_address_free( t);
return 0;
}
void main_loop(void *data) {
int i,j,n;
int32_t fseq = 0;
//verbose = 2;
// get the local IP adress for the TUIO2 source attribute
char hostname[64];
struct hostent *hp = NULL;
struct in_addr *addr = NULL;
gethostname(hostname, 64);
hp = gethostbyname(hostname);
if (hp==NULL) {
sprintf(hostname, "%s.local", hostname);
hp = gethostbyname(hostname);
}
if (hp!=NULL) {
for (i = 0; hp->h_addr_list[i] != 0; ++i) {
addr = (struct in_addr *)(hp->h_addr_list[i]);
}
} else {
//generate a random internet address
srand ( (unsigned int)time(NULL) );
int32_t r = rand();
addr = (struct in_addr*)&r;
}
while (running) {
uint8_t tag_count = 0;
bool updated = false;
lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE);
nfc_target ant[MAX_TARGET_COUNT];
// List ISO14443A targets
if (verbose>1) printf("polling for a ISO14443A (MIFARE) tag:\n");
nfc_modulation nm = {
.nmt = NMT_ISO14443A,
.nbr = NBR_106,
};
lo_timetag frame_time;
lo_timetag_now (&frame_time);
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev] == NULL) continue;
if (!running) return;
lo_message frm_message = lo_message_new();
lo_message_add_int32(frm_message, fseq);
lo_message_add_timetag(frm_message, frame_time);
lo_message_add_int32(frm_message, 0); // sensor dim
if (device_count>1) sprintf(source_string, "NFOSC:%d",dev);
lo_message_add_string(frm_message, source_string); // source name
lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message);
fseq++;
int szTargetFound = nfc_initiator_list_passive_targets (pnd[dev], nm, ant, MAX_TARGET_COUNT);
if (szTargetFound<0) {
if (no_devices==1) printf("NFC reader disconnected ...\n");
else printf("NFC reader #%d disconnected ...\n",dev);
pnd[dev] = NULL;
device_count--;
if (device_count==0) {
running=false;
return;
}
continue;
} else if (szTargetFound>0) {
for (n = 0; n < szTargetFound; n++) {
if (!running) return;
bool added = false;
nfosc_t found_tag;
found_tag.type_id = MIFARE_OTHER;
found_tag.device_id = dev;
decode_hex(ant[n].nti.nai.abtUid,ant[n].nti.nai.szUidLen);
strcpy(found_tag.uid_str,uid_str);
if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x09)) {
if (verbose>1) printf("NXP MIFARE Mini - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_MINI;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x08)) {
if (verbose>1) printf("NXP MIFARE Classic 1K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_1K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x18)) {
if (verbose>1) printf("NXP MIFARE Classic 4K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_4K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x38)) {
if (verbose>1) printf("Nokia MIFARE Classic 4K - emulated - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_4K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x44) && (ant[n].nti.nai.btSak == 0x00)) {
if (verbose>1) printf("NXP MIFARE Ultralight - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_ULTRALIGHT;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x03) && (ant[n].nti.nai.abtAtqa[1] == 0x44) && (ant[n].nti.nai.btSak == 0x20)) {
if (verbose>1) printf("NXP MIFARE DESFire - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x03) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x28)) {
if (verbose>1) printf("NXP JCOP31 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x48) && (ant[n].nti.nai.btSak == 0x20)) {
/* @todo handle ATS to be able to know which one it is */
if (verbose>1) printf("NXP JCOP31 or JCOP41 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x28)) {
if (verbose>1) printf("NXP JCOP41 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x88)) {
if (verbose>1) printf("Infineon MIFARE Classic 1K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_1K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x98)) {
if (verbose>1) printf("Gemplus MPCOS - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x0C) && (ant[n].nti.nai.abtAtqa[1] == 0x00)) {
/* @note not sure if Jewel can be detected using this modulation */
if (verbose>1) printf("Innovision R&T Jewel - UID: %s\n",uid_str);
} else {
if (verbose>1) {
printf("ATQA (SENS_RES): %s\n", decode_hex(ant[n].nti.nai.abtAtqa,2));
printf(" UID (NFCID%c): ",(ant[n].nti.nai.abtUid[0]==0x08?'3':'1')); printf("%s\n",decode_hex(ant[n].nti.nai.abtUid,ant[n].nti.nai.szUidLen));
printf(" SAK (SEL_RES): %s\n", decode_hex(&ant[n].nti.nai.btSak,1));
if (ant[n].nti.nai.szAtsLen) {
printf(" ATS (ATR): %s\n",decode_hex(ant[n].nti.nai.abtAts,ant[n].nti.nai.szAtsLen));
}
printf("\n");
}
}
int32_t symbol_id = max_symbol_id;
int32_t i;
for (i=0;i<max_symbol_id;i++) {
if (strcmp(tag_database[i].uid_str,found_tag.uid_str)==0) {
symbol_id = i;
found_tag.symbol_id = symbol_id;
break;
}
}
if (symbol_id==max_symbol_id) {
symbol_id = max_symbol_id;
max_symbol_id++;
found_tag.symbol_id = symbol_id;
session_id++;
found_tag.session_id = session_id;
tag_database[symbol_id] = found_tag;
tag_buffer[buffer_size] = found_tag;
buffer_size++;
if (verbose) printf("assigning ID %d to UID %s\n",found_tag.symbol_id,found_tag.uid_str);
added = true;
} else {
int32_t b_pos = buffer_size;
for (i=0;i<buffer_size;i++) {
if ((strcmp(tag_buffer[i].uid_str,found_tag.uid_str)==0) && (tag_buffer[i].device_id==found_tag.device_id)) {
found_tag.session_id = tag_buffer[i].session_id;
b_pos=i;
break;
}
}
if (b_pos==buffer_size) {
session_id++;
found_tag.session_id = session_id;
tag_buffer[buffer_size] = found_tag;
buffer_size++;
added=true;
}
}
lo_message sym_message = lo_message_new();
lo_message_add_int32(sym_message, found_tag.session_id);
lo_message_add_int32(sym_message, found_tag.type_id);
lo_message_add_int32(sym_message, found_tag.symbol_id);
switch (found_tag.type_id) {
case MIFARE_ULTRALIGHT:
lo_message_add_string(sym_message, "mifare/ul");
break;
case MIFARE_CLASSIC_1K:
lo_message_add_string(sym_message, "mifare/1k");
break;
case MIFARE_CLASSIC_4K:
lo_message_add_string(sym_message, "mifare/4k");
break;
case MIFARE_MINI:
lo_message_add_string(sym_message, "mifare/mini");
break;
default:
lo_message_add_string(sym_message, "mifare/other");
}
lo_message_add_string(sym_message, found_tag.uid_str);
lo_bundle_add_message(osc_bundle, "/tuio2/sym", sym_message);
if (added) {
lo_message add_message = lo_message_new();
lo_message_add_int32(add_message, found_tag.device_id);
lo_message_add_int32(add_message, found_tag.symbol_id);
lo_message_add_int32(add_message, found_tag.type_id);
lo_message_add_string(add_message, found_tag.uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/add", add_message);
updated = true;
if (verbose) printf("add %d %d %d %s\n",found_tag.device_id,found_tag.symbol_id,found_tag.type_id,found_tag.uid_str);
}
frame_buffer[tag_count] = found_tag;
tag_count++;
}
}
lo_message sid_message = lo_message_new();
for (i=0;i<tag_count;i++)
if (frame_buffer[i].device_id==dev) lo_message_add_int32(sid_message, frame_buffer[i].session_id);
lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message);
}
for (i=0;i<buffer_size;i++) {
bool removed = true;
for (j=0;j<=tag_count;j++) {
if ((strcmp(tag_buffer[i].uid_str,frame_buffer[j].uid_str)==0) && (tag_buffer[i].device_id == frame_buffer[j].device_id)) {
removed=false;
break;
}
}
if (removed) {
lo_message del_message = lo_message_new();
lo_message_add_int32(del_message, tag_buffer[i].device_id);
lo_message_add_int32(del_message, tag_buffer[i].symbol_id);
lo_message_add_int32(del_message, tag_buffer[i].type_id);
lo_message_add_string(del_message, tag_buffer[i].uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message);
updated = true;
if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].device_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str);
}
}
if (updated) {
if(lo_send_bundle(target, osc_bundle) == -1) {
fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target));
}
}
if (verbose>1) {
if (tag_count==0) printf("no tag was found ...\n\n");
else if (tag_count==1) printf("1 tag was found ...\n\n");
else printf("%d tags were found ...\n\n",tag_count);
}
buffer_size = tag_count;
for (i=0; i<tag_count; i++) {
tag_buffer[i] = frame_buffer[i];
frame_buffer[i] = empty_tag;
}
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev] == NULL) continue;
if (nfc_device_set_property_bool(pnd[dev],NP_ACTIVATE_FIELD,false)<0) {
if (running) {
if (no_devices==1) printf("NFC reader disconnected ...\n");
else printf("NFC reader #%d disconnected ...\n",dev);
}
pnd[dev] = NULL;
device_count--;
if (device_count==0) {
running=false;
return;
}
} else {
nfc_device_set_property_bool(pnd[dev],NP_ACTIVATE_FIELD,true);
}
}
usleep(1000/no_devices);
}
}
