int main (void) { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(udpecho_server_auto); MBED_HOSTTEST_DESCRIPTION(UDP echo server); MBED_HOSTTEST_START("NET_5"); EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("MBED: Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT); UDPSocket server; server.bind(ECHO_SERVER_PORT); Endpoint client; char buffer[BUFFER_SIZE] = {0}; printf("MBED: Waiting for packet...\r\n"); while (true) { int n = server.receiveFrom(client, buffer, sizeof(buffer)); if (n > 0) { //printf("Received packet from: %s\n", client.get_address()); const int buffer_string_end_index = n >= BUFFER_SIZE ? BUFFER_SIZE-1 : n; buffer[buffer_string_end_index] = '\0'; //printf("Server received: %s\n", buffer); server.sendTo(client, buffer, n); } } }
void app_start(int argc, char *argv[]) { (void)argc; (void)argv; MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(tcpecho_client_auto); MBED_HOSTTEST_DESCRIPTION(TCP echo client); MBED_HOSTTEST_START("NET_4"); socket_error_t err = lwipv4_socket_init(); TEST_EQ(err, SOCKET_ERROR_NONE); memset(buffer, 0, sizeof(buffer)); port = 0; s_ip_address ip_addr = {0, 0, 0, 0}; printf("TCPClient waiting for server IP and port..." NL); scanf("%d.%d.%d.%d:%d", &ip_addr.ip_1, &ip_addr.ip_2, &ip_addr.ip_3, &ip_addr.ip_4, &port); printf("Address received:%d.%d.%d.%d:%d" NL, ip_addr.ip_1, ip_addr.ip_2, ip_addr.ip_3, ip_addr.ip_4, port); eth.init(); //Use DHCP eth.connect(); printf("TCPClient IP Address is %s" NL, eth.getIPAddress()); sprintf(buffer, "%d.%d.%d.%d", ip_addr.ip_1, ip_addr.ip_2, ip_addr.ip_3, ip_addr.ip_4); client = new TCPEchoClient(SOCKET_STACK_LWIP_IPV4); { FunctionPointer2<void, char *, uint16_t> fp(client, &TCPEchoClient::start_test); minar::Scheduler::postCallback(fp.bind(buffer, port)); } }
int main() { printf("{{start}}\r\n"); EthernetInterface eth; /* Initialise with DHCP, connect, and start up the stack */ eth.init(); eth.connect(); lwipv4_socket_init(); printf("UDP client IP Address is %s\r\n", eth.getIPAddress()); /* Get the current time */ UDPGetTime gt; { FunctionPointer1<void, const char*> fp(>, &UDPGetTime::startGetTime); minar::Scheduler::postCallback(fp.bind(HTTP_SERVER_NAME)); } minar::Scheduler::start(); printf("UDP: %lu seconds since 01/01/1900 00:00 GMT\r\n", gt.time()); eth.disconnect(); float years = (float) gt.time() / 60 / 60 / 24 / 365; printf("{{%s}}\r\n",(years < YEARS_TO_PASS ?"failure":"success")); printf("{{end}}\r\n"); return 0; }
void app_start(int /*argc*/, char* /*argv*/[]) { //Sets the console baud-rate output.baud(115200); // MAC address handling mbed_mac_address(mmac); // This sets up the network interface configuration which will be used // by LWM2M Client API to communicate with mbed Device server. //eth.init("192.168.1.248","255.255.255.0","192.168.1.1"); eth.init(); //Use DHCP eth.connect(); lwipv4_socket_init(); output.printf("IP address %s\r\n", eth.getIPAddress()); // On press of SW3 button on K64F board, example application // will call unregister API towards mbed Device Server unreg_button.fall(&mbed_client,&MbedClient::test_unregister); // On press of SW2 button on K64F board, example application // will send observation towards mbed Device Server obs_button.fall(&mbed_client,&MbedClient::update_resource); // Create LWM2M Client API interface to manage register and unregister mbed_client.create_interface(); // Create LWM2M server object specifying mbed device server // information. M2MSecurity* register_object = mbed_client.create_register_object(); // Create LWM2M device object specifying device resources // as per OMA LWM2M specification. M2MDevice* device_object = mbed_client.create_device_object(); // Create Generic object specifying custom resources M2MObject* generic_object = mbed_client.create_generic_object(); // Create LED Object M2MObject* led_object = mbed_client.create_led_object(); // Add all the objects that you would like to register // into the list and pass the list for register API. M2MObjectList object_list; object_list.push_back(device_object); object_list.push_back(generic_object); object_list.push_back(led_object); mbed_client.set_register_object(register_object); // Issue register command. FunctionPointer2<void, M2MSecurity*, M2MObjectList> fp(&mbed_client, &MbedClient::test_register); minar::Scheduler::postCallback(fp.bind(register_object,object_list)); minar::Scheduler::postCallback(&mbed_client,&MbedClient::test_update_register).period(minar::milliseconds(25000)); }
void setupEthernet() { lcd.printf("Setup Ethernet...\r\n"); // Starting eth.init(); // Initialize while (eth.connect()) { // timeout and loop until connected lcd.printf("Connect timeout\r\n"); }; lcd.printf("IP Address is %s\r\n", eth.getIPAddress()); // successful connect }
void app_start(int argc, char *argv[]) { (void) argc; (void) argv; eth.init(); //Use DHCP eth.connect(); lwipv4_socket_init(); printf("MBED: Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT); mbed::FunctionPointer1<void, uint16_t> fp(&server, &TCPEchoServer::start); minar::Scheduler::postCallback(fp.bind(ECHO_SERVER_PORT)); }
void ethSetup() { EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("IP Address is %s\n", eth.getIPAddress()); udp.init(); udp.bind(5683); udp.set_blocking(false, 10000); }
int main() { char buffer[BUFFER_SIZE] = {0}; char out_buffer[BUFFER_SIZE] = {0}; s_ip_address ip_addr = {0, 0, 0, 0}; int port = 0; printf("MBED: TCPCllient waiting for server IP and port...\r\n"); scanf("%d.%d.%d.%d:%d", &ip_addr.ip_1, &ip_addr.ip_2, &ip_addr.ip_3, &ip_addr.ip_4, &port); printf("MBED: Address received: %d.%d.%d.%d:%d\r\n", ip_addr.ip_1, ip_addr.ip_2, ip_addr.ip_3, ip_addr.ip_4, port); EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("MBED: TCPClient IP Address is %s\r\n", eth.getIPAddress()); sprintf(buffer, "%d.%d.%d.%d", ip_addr.ip_1, ip_addr.ip_2, ip_addr.ip_3, ip_addr.ip_4); TCPSocketConnection socket; while (socket.connect(buffer, port) < 0) { printf("MBED: TCPCllient unable to connect to %s:%d\r\n", buffer, port); wait(1); } // Test loop for multiple client connections bool result = true; int count_error = 0; for (int i = 0; i < MAX_ECHO_LOOPS; i++) { std::generate(out_buffer, out_buffer + BUFFER_SIZE, char_rand); socket.send_all(out_buffer, BUFFER_SIZE); int n = socket.receive(buffer, BUFFER_SIZE); if (n > 0) { bool echoed = memcmp(out_buffer, buffer, BUFFER_SIZE) == 0; result = result && echoed; if (echoed == false) { count_error++; // Count error messages } } } printf("MBED: Loop messages passed: %d / %d\r\n", MAX_ECHO_LOOPS - count_error, MAX_ECHO_LOOPS); if (notify_completion_str(result, buffer)) { socket.send_all(buffer, strlen(buffer)); } socket.close(); eth.disconnect(); notify_completion(result); return 0; }
void tcpClient_main(intptr_t exinf) { EthernetInterface network; TCPSocketConnection socket; /* syslogの設定 */ SVC_PERROR(syslog_msk_log(LOG_UPTO(LOG_INFO), LOG_UPTO(LOG_EMERG))); syslog(LOG_NOTICE, "tcpClient:"); syslog(LOG_NOTICE, "Sample program starts (exinf = %d).", (int_t) exinf); syslog(LOG_NOTICE, "LOG_NOTICE: Network Setting up..."); #if (USE_DHCP == 1) if (network.init() != 0) { //for DHCP Server #else if (network.init(IP_ADDRESS, SUBNET_MASK, DEFAULT_GATEWAY) != 0) { //for Static IP Address (IPAddress, NetMasks, Gateway) #endif syslog(LOG_NOTICE, "Network Initialize Error"); return; } syslog(LOG_NOTICE, "Network was initialized successfully"); while (network.connect(5000) != 0) { syslog(LOG_NOTICE, "LOG_NOTICE: Network Connect Error"); } syslog(LOG_NOTICE, "MAC Address is %s", network.getMACAddress()); syslog(LOG_NOTICE, "IP Address is %s", network.getIPAddress()); syslog(LOG_NOTICE, "NetMask is %s", network.getNetworkMask()); syslog(LOG_NOTICE, "Gateway Address is %s", network.getGateway()); syslog(LOG_NOTICE, "Network Setup OK..."); while (socket.connect(SERVER, HTTP_PORT) < 0) { syslog(LOG_EMERG, "Unable to connect to (%s) on port (%d)", SERVER, HTTP_PORT); wait(1.0); } ClientGreet(&socket); socket.close(); syslog(LOG_NOTICE, "program end"); } // set mac address void mbed_mac_address(char *mac) { // PEACH1 mac[0] = 0x00; mac[1] = 0x02; mac[2] = 0xF7; mac[3] = 0xF0; mac[4] = 0x00; mac[5] = 0x00; }
void app_start(int /*argc*/, char* /*argv*/[]) { //Sets the console baud-rate output.baud(115200); output.printf("In app_start()\r\n"); // This sets up the network interface configuration which will be used // by LWM2M Client API to communicate with mbed Device server. eth.init(); //Use DHCP if (eth.connect() != 0) { output.printf("Failed to form a connection!\r\n"); } if (lwipv4_socket_init() != 0) { output.printf("Error on lwipv4_socket_init!\r\n"); } output.printf("IP address %s\r\n", eth.getIPAddress()); output.printf("Device name %s\r\n", MBED_ENDPOINT_NAME); // we create our button and LED resources auto state_resource = new StateResource(); doorIndicator.onStateChange(mbed::util::FunctionPointer1<void, DoorIndicator::WarnStatus>(state_resource, &StateResource::handle_state_change)); // Unregister button (SW3) press will unregister endpoint from connector.mbed.com unreg_button.fall(&mbed_client, &MbedClient::test_unregister); // Create endpoint interface to manage register and unregister mbed_client.create_interface(); // Create Objects of varying types, see simpleclient.h for more details on implementation. M2MSecurity* register_object = mbed_client.create_register_object(); // server object specifying connector info M2MDevice* device_object = mbed_client.create_device_object(); // device resources object // Create list of Objects to register M2MObjectList object_list; // Add objects to list object_list.push_back(device_object); object_list.push_back(state_resource->get_object()); // Set endpoint registration object mbed_client.set_register_object(register_object); mbed_client.on_object_registered(mbed::util::FunctionPointer0<void>(&doorIndicator, &DoorIndicator::init)); // Issue register command. FunctionPointer2<void, M2MSecurity*, M2MObjectList> fp(&mbed_client, &MbedClient::test_register); minar::Scheduler::postCallback(fp.bind(register_object,object_list)); minar::Scheduler::postCallback(&mbed_client,&MbedClient::test_update_register).period(minar::milliseconds(25000)); }
int main() { eth.init(); eth.connect(); printf("IP Address: %s\n", eth.getIPAddress()); while (true) { int response = m2xClient.postDeviceUpdates(deviceId, 2, streamNames, counts, ats, values); printf("Response code: %d\n", response); if (response == -1) while (true) ; delay(5000); } }
control_t test_echo_udp_client() { socket_error_t err = lwipv4_socket_init(); TEST_ASSERT_EQUAL_MESSAGE(SOCKET_ERROR_NONE, err, "Failed to init LWIPv4 socket!"); printf("MBED: Initializing ethernet connection." NL); //Use DHCP TEST_ASSERT_EQUAL_MESSAGE(0, eth.init(), "Failed to init LWIPv4 socket!"); eth.connect(); printf("MBED: IP Address is %s" NL, eth.getIPAddress()); greentea_send_kv("target_ip", eth.getIPAddress()); memset(buffer, 0, sizeof(buffer)); port = 0; printf("UDPClient waiting for server IP and port..." NL); char recv_key[] = "host_port"; char port_value[] = "65325"; greentea_send_kv("host_ip", " "); TEST_ASSERT_NOT_EQUAL_MESSAGE(0, greentea_parse_kv(recv_key, buffer, sizeof(recv_key), sizeof(buffer)), "MBED: Failed to recv/parse key value from host!"); greentea_send_kv("host_port", " "); TEST_ASSERT_NOT_EQUAL_MESSAGE(0, greentea_parse_kv(recv_key, port_value, sizeof(recv_key), sizeof(port_value)), "MBED: Failed to recv/parse key value from host!"); sscanf(port_value, "%d", &port); client = new UDPEchoClient(SOCKET_STACK_LWIP_IPV4); { mbed::util::FunctionPointer2<void, char *, uint16_t> fp(client, &UDPEchoClient::start_test); minar::Scheduler::postCallback(fp.bind(buffer, port)); } return CaseTimeout(25000); }
int main(void) { EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("Server IP Address is %s:%d\n", eth.getIPAddress(), ECHO_SERVER_PORT); Thread UdpServerTask(udp_server_task, NULL, osPriorityNormal, DEFAULT_STACK_SIZE * 2.25); Thread UdpClientTask(udp_client_task, NULL, osPriorityNormal, DEFAULT_STACK_SIZE * 2.25); // Control TCP server to get mbed statistics { const int TELNET_SERVER_PORT = 23; const int BUFFER_SIZE = 256; TCPSocketServer server; server.bind(TELNET_SERVER_PORT); server.listen(); while (true) { printf("Wait for new connection...\n"); TCPSocketConnection client; server.accept(client); client.set_blocking(false, 1500); // Timeout after (1.5)s printf("Connection from: %s\n", client.get_address()); char buffer[BUFFER_SIZE] = { 0 }; while (true) { int n = client.receive(buffer, sizeof(buffer)); //if (n <= 0) break; if (n > 0) { printf("Recv %d chars\r\n", n); const int buffer_string_end_index = n >= BUFFER_SIZE ? BUFFER_SIZE - 1 : n; buffer[buffer_string_end_index] = '\0'; // client.send_all(buffer, strlen(buffer)); if (strncmp(buffer, "stat", 4) == 0) { sprintf(buffer, "received_packets %d\nforwarded_packets %d\nmax_queue_len %d", received_packets, forwarded_packets, max_queue_len); client.send_all(buffer, strlen(buffer)); // printf("%s", buffer); } } //if (n <= 0) break; } client.close(); } } }
/** * The main loop of the TCP Echo Server example * @return 0; however the main loop should never return. */ int main (void) { EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); lwipv4_socket_init(); printf("MBED: Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT); TCPEchoServer server; { mbed::FunctionPointer1<void, uint16_t> fp(&server, &TCPEchoServer::start); minar::Scheduler::postCallback(fp.bind(ECHO_SERVER_PORT)); } minar::Scheduler::start(); return 0; }
int main() { Thread * thread; pc.baud(115200); pc.printf("\r\nStarting Mbed ...\r\n"); //Initialize the LCD pc.printf("Initializing LCD ...\r\n"); init_LCD(); printf("Initializing USB Mass Storage ...\r\n"); printf("Inititalizing ethernet ....\r\n"); eth.init(); // Use DHCP eth.connect(); printf("IP Address is %s\n", eth.getIPAddress()); // After initializing the ethernet interface // run it in its own thread printf("Starting blinker thread ...\r\n"); thread = new Thread(led1_thread); // Start the shell printf("Starting debug shell ...\r\n"); shell.addCommand("ls", cmd_ls); shell.addCommand("load", cmd_load); shell.addCommand("mem", cmd_mem); shell.addCommand("sensor", cmd_sensor); shell.start(osPriorityNormal, SHELL_STACK_SIZ, shellStack); printf("Shell now running!\r\n"); printf("Available Memory : %d\r\n", get_mem()); // Do something logical here // other than looping while(1) { printf("Temperature : %d °C\r\n", htu21d.sample_ctemp()); printf("Humitdity : %d%%\r\n", htu21d.sample_humid()); wait(10); } thread->terminate(); delete thread; }
int main (void) { EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("IP Address is %s\n", eth.getIPAddress()); UDPSocket server; server.bind(ECHO_SERVER_PORT); Endpoint client; char buffer[256]; while (true) { printf("\nWait for packet...\n"); int n = server.receiveFrom(client, buffer, sizeof(buffer)); printf("Received packet from: %s\n", client.get_address()); server.sendTo(client, buffer, n); } }
HTTPAPI_RESULT HTTPAPI_Init(void) { LogInfo("HTTPAPI_Init::Start\r\n"); time_t ctTime; ctTime = time(NULL); HTTPAPI_RESULT result; LogInfo("HTTAPI_Init::Time is now (UTC) %s\r\n", ctime(&ctTime)); if (eth.init()) { LogInfo("HTTPAPI_Init::Error with initing the Ethernet Interface\r\n"); result = HTTPAPI_INIT_FAILED; } else { LogInfo("HTTPAPI_Init::Ethernet interface was inited!\r\n"); if (eth.connect(30000)) { LogError("HTTPAPI_Init::Error with connecting.\r\n"); result = HTTPAPI_INIT_FAILED; } else { LogInfo("HTTAPI_Init::Ethernet interface was connected (brought up)!\r\n"); LogInfo("HTTAPI_Init::MAC address %s\r\n", eth.getMACAddress()); LogInfo("HTTAPI_Init::IP address %s\r\n", eth.getIPAddress()); if (ntp.setTime("0.pool.ntp.org") == 0) { LogInfo("HTTAPI_Init:: Successfully set time\r\n"); LogInfo("HTTAPI_Init::Time is now (UTC) %s\r\n", ctime(&ctTime)); result = HTTPAPI_OK; } else { LogError("HTTPAPI_INIT::Unable to set time. Init failed"); result = HTTPAPI_INIT_FAILED; } } } LogInfo("HTTPAPI_Init::End\r\n"); return result; }
int main() { bool result = false; EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("UDP client IP Address is %s\n", eth.getIPAddress()); UDPSocket sock; sock.init(); Endpoint nist; nist.set_address(HTTP_SERVER_NAME, HTTP_SERVER_PORT); char out_buffer[] = "plop"; // Does not matter sock.sendTo(nist, out_buffer, sizeof(out_buffer)); union { char in_buffer_tab[4]; unsigned int in_buffer_uint; }; const int n = sock.receiveFrom(nist, in_buffer_tab, sizeof(in_buffer_tab)); if (n > 0) { result = true; const unsigned int timeRes = ntohl(in_buffer_uint); const float years = timeRes / 60.0 / 60.0 / 24.0 / 365; printf("UDP: Received %d bytes from server %s on port %d\r\n", n, nist.get_address(), nist.get_port()); printf("UDP: %u seconds since 01/01/1900 00:00 GMT ... %s\r\n", timeRes, timeRes > 0 ? "[OK]" : "[FAIL]"); printf("UDP: %.2f years since 01/01/1900 00:00 GMT ... %s\r\n", years, timeRes > YEARS_TO_PASS ? "[OK]" : "[FAIL]"); if (years < YEARS_TO_PASS) { result = false; } } sock.close(); eth.disconnect(); notify_completion(result); return 0; }
int main (void) { EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("Server IP Address is %s:%d\n", eth.getIPAddress(), ECHO_SERVER_PORT); UDPSocket server; server.bind(ECHO_SERVER_PORT); Endpoint client; char buffer[BUFFER_SIZE] = {0}; while (true) { printf("Wait for packet...\n"); int n = server.receiveFrom(client, buffer, sizeof(buffer)); if (n > 0) { printf("Received packet from: %s\n", client.get_address()); const int buffer_string_end_index = n >= BUFFER_SIZE ? BUFFER_SIZE-1 : n; buffer[buffer_string_end_index] = '\0'; printf("Server received: %s\n", buffer); server.sendTo(client, buffer, n); } } }
void app_start (int argc, char *argv[]) { (void) argc; (void) argv; eth.init(); //Use DHCP eth.connect(); socket_error_t err = lwipv4_socket_init(); if (err) { printf("MBED: Failed to initialize socket stack (%d)\r\n", err); return; } udpserver = new UDPSocket(SOCKET_STACK_LWIP_IPV4); printf("MBED: UDP Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT); udpserver->setOnError(UDPSocket::ErrorHandler_t(onError)); udpserver->open(SOCKET_AF_INET4); err = udpserver->bind("0.0.0.0",ECHO_SERVER_PORT); udpserver->error_check(err); udpserver->setOnReadable(UDPSocket::ReadableHandler_t(onRx)); printf("MBED: Waiting for packet...\r\n"); }
void main(void) { //***************** BEGINNING OF ETHERNET SETUP [DONT EDIT] *****************// EthernetInterface eth; eth.init(); //Use DHCP eth.connect(); printf("IP Address is %s\n", eth.getIPAddress()); UDPSocket server; server.bind(ECHO_SERVER_PORT); Endpoint client; char buffer[256]; //***************** END OF ETHERNET SETUP **********************************// //***************** BEGINNING OF WIRELESS SETUP [DONT EDIT] *****************// uint8_t channel = 6; //Set the Channel. 0 is default, 15 is max mrf.SetChannel(channel); //Start the timer timer.start(); //***************** END OF WIRELESS SETUP **********************************// raiseAllPins(); dropAllPins(); speedChecker.attach(&speedLogic,0.005); //sets ticker for interrupts dcOUT=0; // turns DC motor off initially int cycles = 0; int flush = 0; int startChar =0; while(1) { dcPWM.write(dutyCycle); cycles = cycles-1; if(needsInput==true) { //What MBED is receiving from client? if(flush) { int lengthBuffer = strlen(buffer); for(int i = 0; i <lengthBuffer; i++) { buffer[i]='\0'; } } printf("\nWait for packet...\n\r"); lightShow.drawChar('@'); //this should draw the character on the screen int n = server.receiveFrom(client, buffer, sizeof(buffer)); printf("\nReceived packet...\n\r"); printf("\nReceived integer n...%i\n\r",n); buffer[n]='\0'; printf("\nyour word is: %s\n\r",buffer); server.sendTo(client, buffer, n); //echo protocol needsInput=false; cycles=n; /*revive code*/ sendDelay = slowSpeed; //pins dutyCycle = slowMotor; //motor dcOUT = 1; //turn on motor off=false; slow = true; startChar=0; } if(cycles<=0) { needsInput= true; slow = false; off=true; dcOUT = 0; //turn motor off sendDelay = slowSpeed; //pins dutyCycle = slowMotor; //for whenever it turns on after you turned it off using REDUCE } if(!off) { char character = getNextCharacter(startChar, buffer); startChar=1; printf("\nchar: %c\n\r",character); int pinBinary = braille.matchCharacter(character); if(braille.isNumber(character)) { handleNumberCase(character); } led1=1; lightShow.drawChar(character); //this should draw the character on the screen led1=0; wait_ms(sendDelay); sendNumber(pinBinary); printf("Pinbinary: %i\n\r",pinBinary); //***** ACKNOWLEDGE CODE ******// int recLength = rf_receive(rxbuffer,128); while(recLength<=0) { led2=1; recLength = rf_receive(rxbuffer,128); } led2=0; //***** END ACKNOWLEDGE CODE ******// }//end if motor stopped code dropAllPins(); }//end while loop }//end all code
void app_start(int /*argc*/, char* /*argv*/[]) { //Sets the console baud-rate output.baud(115200); // start the accelerometer acc.enable(); // print device name for easy reference output.printf("Device Name is '%s'\r\n\r\n",MBED_ENDPOINT_NAME); // This sets up the network interface configuration which will be used // by LWM2M Client API to communicate with mbed Device server. eth.init(); //Use DHCP eth.connect(); output.printf("%s\n", eth.getMACAddress()); char *ip = eth.getIPAddress(); if (ip) { output.printf("IP Address is: %s\n", ip); } else { error("Failed to aquire IP address\n"); } lwipv4_socket_init(); // On press of SW3 button on K64F board, example application // will call unregister API towards mbed Device Server // unreg_button.fall(&mbed_client,&MbedClient::test_unregister); // Create LWM2M Client API interface to manage register and unregister mbed_client.create_interface(); // Create LWM2M server object specifying mbed device server // information. M2MSecurity* register_object = mbed_client.create_register_object(); // Create LWM2M device object specifying device resources // as per OMA LWM2M specification. M2MDevice* device_object = mbed_client.create_device_object(); // Create Generic object specifying custom resources M2MObject* sdw_object = mbed_client.create_sdw_object(); // Create Generic object specifying custom resources M2MObject* led_object = mbed_client.create_led_object(); // Add all the objects that you would like to register // into the list and pass the list for register API. M2MObjectList object_list; object_list.push_back(device_object); object_list.push_back(sdw_object); object_list.push_back(led_object); mbed_client.set_register_object(register_object); // Issue register command. FunctionPointer2<void, M2MSecurity*, M2MObjectList> fp(&mbed_client, &MbedClient::test_register); minar::Scheduler::postCallback(fp.bind(register_object, object_list)); minar::Scheduler::postCallback(&mbed_client, &MbedClient::update_sdw_resource).period(minar::milliseconds(1000)); minar::Scheduler::postCallback(&mbed_client, &MbedClient::test_update_register).period(minar::milliseconds(25000)); }
int UDPSocket::join_multicast_group(EthernetInterface& eth, const char* address) { return picotcp_join_multicast(_ep,address,eth.getIPAddress()); }