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); } }