void app_start(int, char**) {
// setup the EthernetInterface
eth.init(); // DHCP
eth.connect();
// initialize the ipv4 tcp/ip stack
lwipv4_socket_init();
// setup the M2MInterface
srand(time(NULL));
uint16_t port = rand() % 65535 + 12345;
srv = M2MInterfaceFactory::create_interface(observer,endpoint,type,
lifetime,port,domain,M2MInterface::UDP,M2MInterface::LwIP_IPv4,context_address);
// setup the Security object
sec = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer);
sec->set_resource_value(M2MSecurity::M2MServerUri,address);
sec->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::NoSecurity);
// setup the Device object
dev = M2MInterfaceFactory::create_device();
dev->create_resource(M2MDevice::Manufacturer,"Freescale");
dev->create_resource(M2MDevice::DeviceType,"frdm-k64f");
dev->create_resource(M2MDevice::ModelNumber,"M64FN1MOVLL12");
dev->create_resource(M2MDevice::SerialNumber,"EB1524XXXX");
// setup the sensor objects
obj = M2MInterfaceFactory::create_object("loc");
M2MObjectInstance* ins = obj->create_object_instance();
M2MResource* resx = ins->create_dynamic_resource("x","accel",M2MResourceInstance::INTEGER,true);
resx->set_operation(M2MBase::GET_PUT_ALLOWED);
resx->set_value((const uint8_t*)"0",1);
M2MResource* resy = ins->create_dynamic_resource("y","accel",M2MResourceInstance::INTEGER,true);
resy->set_operation(M2MBase::GET_PUT_ALLOWED);
resy->set_value((const uint8_t*)"0",1);
// Assemble the list of objects to register
M2MObjectList list;
list.push_back(dev);
list.push_back(obj);
// setup registration event
Ticker timer;
timer.attach(®,&Registrar::update,20);
// enable accelerometer
printf("Initializied accelerometer\r\n");
accel.enable();
Ticker sampler;
sampler.attach(sample,5);
// schedule
FunctionPointer1<void, M2MObjectList> fp(®, &Registrar::setup);
minar::Scheduler::postCallback(fp.bind(list));
minar::Scheduler::postCallback(sample).period(minar::milliseconds(10000));
minar::Scheduler::start();
}
int main() {
GREENTEA_SETUP(60, "default_auto");
bool result = false;
const time_t TIME1970 = 2208988800L;
int ntp_send_values[12] = {0};
int ntp_recv_values[12] = {0};
EthernetInterface eth;
eth.connect();
printf("UDP client IP Address is %s\n", eth.get_ip_address());
UDPSocket sock;
sock.open(ð);
sock.set_timeout(15000);
SocketAddress nist(ð, HTTP_SERVER_NAME, HTTP_SERVER_PORT);
printf("UDP: NIST server %s address: %s on port %d\r\n", HTTP_SERVER_NAME, nist.get_ip_address(), nist.get_port());
memset(ntp_send_values, 0x00, sizeof(ntp_send_values));
ntp_send_values[0] = '\x1b';
while(1) {
memset(ntp_recv_values, 0x00, sizeof(ntp_recv_values));
int ret_send = sock.sendto(nist, (void*)ntp_send_values, sizeof(ntp_send_values));
printf("UDP: Sent %d Bytes to NTP server \n", ret_send);
SocketAddress source;
const int n = sock.recvfrom(&source, (void*)ntp_recv_values, sizeof(ntp_recv_values));
printf("UDP: Recved from NTP server %d Bytes \n", n);
if (n > 0 && strcmp(source.get_ip_address(), nist.get_ip_address()) == 0) {
result = true;
printf("UDP: Values returned by NTP server: \n");
for (size_t i=0; i < sizeof(ntp_recv_values) / sizeof(ntp_recv_values[0]); ++i) {
printf("\t[%02d] 0x%X", i, ntohl(ntp_recv_values[i]));
if (i == 10) {
time_t timestamp = ntohl(ntp_recv_values[i]) - TIME1970;
printf("\tNTP timestamp is %s", ctime(×tamp));
} else {
printf("\n");
}
}
break;
}
printf("Failed to receive data, retrying in 5 seconds...\n");
wait(5);
}
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
void app_start(int argc, char *argv[])
{
(void) argc;
(void) argv;
MBED_HOSTTEST_TIMEOUT(5);
MBED_HOSTTEST_SELECT(default);
MBED_HOSTTEST_DESCRIPTION(Socket Abstraction Layer construction and utility test);
MBED_HOSTTEST_START("SAL_INIT_UTIL");
int tests_pass = 1;
int rc;
EthernetInterface eth;
/* Initialise with DHCP, connect, and start up the stack */
eth.init();
eth.connect();
do {
socket_error_t err = lwipv4_socket_init();
if (!TEST_EQ(err,SOCKET_ERROR_NONE)) {
tests_pass = 0;
break;
}
rc = socket_api_test_create_destroy(SOCKET_STACK_LWIP_IPV4, SOCKET_AF_INET6);
tests_pass = tests_pass && rc;
rc = socket_api_test_socket_str2addr(SOCKET_STACK_LWIP_IPV4, SOCKET_AF_INET6);
tests_pass = tests_pass && rc;
} while (0);
MBED_HOSTTEST_RESULT(tests_pass);
}
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;
}
int main()
{
EthernetInterface eth;
NTPClient ntp;
eth.init(); //Use DHCP
eth.connect();
// NTP set time
{
bool result = true;
const char *url_ntp_server = "0.pool.ntp.org";
printf("NTP_SETTIME: Trying to update time... \r\n");
const int ret = ntp.setTime(url_ntp_server);
if (ret == 0) {
time_t ctTime = time(NULL);
printf("NTP_SETTIME: UTC Time read successfully ... [OK]\r\n");
printf("NTP_SETTIME: %s\r\n", ctime(&ctTime));
}
else {
printf("NTP_SETTIME: Error(%d) ... [FAIL]\r\n", ret);
result = false;
}
if (result == false) {
notify_completion(false);
exit(ret);
}
}
eth.disconnect();
notify_completion(true);
return 0;
}
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));
}
}
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 net_bringup() {
int err = net.connect();
TEST_ASSERT_EQUAL(0, err);
printf("MBED: Connected to network\n");
printf("MBED: IP Address: %s\n", net.get_ip_address());
ip_literal = net.get_ip_address();
ip_pref = SocketAddress(ip_literal).get_ip_version();
ip_pref_repr = (ip_pref == NSAPI_IPv4) ? "ipv4" :
(ip_pref == NSAPI_IPv6) ? "ipv6" : "unspec";
}
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() {
GREENTEA_SETUP(20, "udp_echo");
EthernetInterface eth;
eth.connect();
printf("UDP client IP Address is %s\n", eth.get_ip_address());
greentea_send_kv("target_ip", eth.get_ip_address());
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
UDPSocket sock;
sock.open(ð);
sock.set_timeout(MBED_CFG_UDP_CLIENT_ECHO_TIMEOUT);
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: UDP Server IP address received: %s:%d \n", ipbuf, port);
SocketAddress udp_addr(ipbuf, port);
int success = 0;
for (int i=0; i < ECHO_LOOPS; ++i) {
prep_buffer(tx_buffer, sizeof(tx_buffer));
const int ret = sock.sendto(udp_addr, tx_buffer, sizeof(tx_buffer));
printf("[%02d] sent...%d Bytes \n", i, ret);
SocketAddress temp_addr;
const int n = sock.recvfrom(&temp_addr, rx_buffer, sizeof(rx_buffer));
printf("[%02d] recv...%d Bytes \n", i, n);
if ((temp_addr == udp_addr &&
n == sizeof(tx_buffer) &&
memcmp(rx_buffer, tx_buffer, sizeof(rx_buffer)) == 0)) {
success += 1;
}
}
bool result = (success > 3*ECHO_LOOPS/4);
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
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;
}
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);
}
}
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() {
GREENTEA_SETUP(20, "tcp_echo_client");
EthernetInterface eth;
eth.connect();
printf("MBED: TCPClient IP address is '%s'\n", eth.get_ip_address());
printf("MBED: TCPClient waiting for server IP and port...\n");
greentea_send_kv("target_ip", eth.get_ip_address());
bool result = false;
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: Server IP address received: %s:%d \n", ipbuf, port);
TCPSocket sock(ð);
SocketAddress tcp_addr(ipbuf, port);
if (sock.connect(tcp_addr) == 0) {
printf("HTTP: Connected to %s:%d\r\n", ipbuf, port);
printf("tx_buffer buffer size: %u\r\n", sizeof(tx_buffer));
printf("rx_buffer buffer size: %u\r\n", sizeof(rx_buffer));
prep_buffer(tx_buffer, sizeof(tx_buffer));
sock.send(tx_buffer, sizeof(tx_buffer));
// Server will respond with HTTP GET's success code
const int ret = sock.recv(rx_buffer, sizeof(rx_buffer));
result = !memcmp(tx_buffer, rx_buffer, sizeof(tx_buffer));
TEST_ASSERT_EQUAL(ret, sizeof(rx_buffer));
TEST_ASSERT_EQUAL(true, result);
}
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
int main() {
GREENTEA_SETUP(20, "udp_echo_client");
EthernetInterface eth;
eth.connect();
printf("UDP client IP Address is %s\n", eth.get_ip_address());
greentea_send_kv("target_ip", eth.get_ip_address());
bool result = true;
char recv_key[] = "host_port";
char ipbuf[60] = {0};
char portbuf[16] = {0};
unsigned int port = 0;
UDPSocket sock;
sock.open(ð);
greentea_send_kv("host_ip", " ");
greentea_parse_kv(recv_key, ipbuf, sizeof(recv_key), sizeof(ipbuf));
greentea_send_kv("host_port", " ");
greentea_parse_kv(recv_key, portbuf, sizeof(recv_key), sizeof(ipbuf));
sscanf(portbuf, "%u", &port);
printf("MBED: UDP Server IP address received: %s:%d \n", ipbuf, port);
SocketAddress addr(ipbuf, port);
for (int i=0; i < ECHO_LOOPS; ++i) {
prep_buffer(tx_buffer, sizeof(tx_buffer));
const int ret = sock.sendto(addr, tx_buffer, sizeof(tx_buffer));
printf("[%02d] sent...%d Bytes \n", i, ret);
const int n = sock.recvfrom(&addr, rx_buffer, sizeof(rx_buffer));
printf("[%02d] recv...%d Bytes \n", i, n);
if (memcmp(rx_buffer, tx_buffer, sizeof(rx_buffer))) {
result = false;
break;
}
}
sock.close();
eth.disconnect();
GREENTEA_TESTSUITE_RESULT(result);
}
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;
}
void tuvp_tcp_init(void) {
mbed_socket::init_sockets();
// _eth.init(); // this will make dynamic address
// or set static address
// _eth.init("IP Addrss", "Mask", "Gateway");
#if defined (MBED_IP_ADDRESS)
_eth.init(MBED_IP_ADDRESS, MBED_IP_MASK, MBED_IP_GATEWAY);
#else
_eth.init();
#endif
_eth.connect();
//TDDDLOG(".. MBED Board IP Address is %s", _eth.getIPAddress());
lwipv4_socket_init();
}
int main(void)
{
(void)printf("Initializing mbed specific things...\r\n");
mbed_log_init();
mbedtime_init();
EthernetInterface eth;
if (eth.init() || eth.connect())
{
(void)printf("Error initializing EthernetInterface.\r\n");
return -1;
}
return run_tests();
}
int main() {
EthernetInterface eth;
eth.init(); //Use DHCP
eth.connect();
UDPSocket sock;
sock.init();
Endpoint multicast_group;
multicast_group.set_address(MCAST_GRP, MCAST_PORT);
char out_buffer[] = "very important data";
while (true) {
printf("Multicast to group: %s\n", MCAST_GRP);
sock.sendTo(multicast_group, out_buffer, sizeof(out_buffer));
Thread::wait(1000);
}
}
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;
}
// DNS tests
void test_dns_query() {
SocketAddress addr;
int err = net.gethostbyname(MBED_DNS_TEST_HOST, &addr);
printf("DNS: query \"%s\" => \"%s\"\n",
MBED_DNS_TEST_HOST, addr.get_ip_address());
TEST_ASSERT_EQUAL(0, err);
TEST_ASSERT((bool)addr);
TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
}
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);
}
}
void test_dns_literal() {
SocketAddress addr;
int err = net.gethostbyname(ip_literal, &addr);
printf("DNS: literal \"%s\" => \"%s\"\n",
ip_literal, addr.get_ip_address());
TEST_ASSERT_EQUAL(0, err);
TEST_ASSERT((bool)addr);
TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
TEST_ASSERT(strcmp(ip_literal, addr.get_ip_address()) == 0);
}
void terminate(bool status, UDPEchoClient* )
{
if (client) {
printf("MBED: Test finished!");
delete client;
client = NULL;
eth.disconnect();
TEST_ASSERT_TRUE_MESSAGE(status, "MBED: test failed!");
Harness::validate_callback();
}
}
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;
}
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;
}
