Merge branch 'master' of https://github.com/mbedmicro/mbed

libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_MCU_K64F/TARGET_MTS_GAMBIT/PinNames.h

@@ -206,6 +206,37 @@ typedef enum {
     USBTX = PTB17,
     USBRX = PTB16,
 
+    // SPI Pins
+    SPI0_SOUT = PTC6,
+    SPI0_SIN = PTC7,
+    SPI0_SCK = PTC5,
+
+    SPI1_SOUT = PTE3,
+    SPI1_SIN = PTE1,
+    SPI1_SCK = PTE2,
+
+    // SPI Chip Select Pins
+    SPI0_NCS0 = PTC4,
+    SPI0_NCS1 = PTC3,
+    SPI0_NCS2 = PTC2,
+    SPI0_NCS3 = PTC1,
+
+    SPI1_NCS0 = PTE4,
+    SPI1_NCS1 = PTE0,
+    SPI1_NCS2 = PTE5,
+    SPI1_NCS3 = PTE6,
+
+    // GPIO's
+    AP1_GPIO1 = PTB7,
+    AP1_GPIO2 = PTB6,
+    AP1_GPIO3 = PTB5,
+    AP1_GPIO4 = PTB4,
+
+    AP2_GPIO1 = PTA27,
+    AP2_GPIO2 = PTA26,
+    AP2_GPIO3 = PTA25,
+    AP2_GPIO4 = PTA24,
+
     DAC0_OUT = 0xFEFE, /* DAC does not have Pin Name in RM */
 
     // Not connected

libraries/tests/mbed/echo/main.cpp

@@ -1,24 +1,16 @@
 #include "mbed.h"
 #include "test_env.h"
 
-#if defined(TARGET_NUCLEO_F103RB) || \
-    defined(TARGET_NUCLEO_L152RE) || \
-    defined(TARGET_NUCLEO_F302R8) || \
-    defined(TARGET_NUCLEO_F030R8) || \
-    defined(TARGET_NUCLEO_F401RE) || \
-    defined(TARGET_NUCLEO_F411RE) || \
-    defined(TARGET_NUCLEO_F072RB) || \
-    defined(TARGET_NUCLEO_F334R8) || \
-    defined(TARGET_NUCLEO_L053R8)
-#define TXPIN     STDIO_UART_TX
-#define RXPIN     STDIO_UART_RX
-#else
 #define TXPIN     USBTX
 #define RXPIN     USBRX
-#endif
+
+
+namespace {
+    const int BUFFER_SIZE = 48;
+}
 
 int main() {
-    char buf[256];
+    char buffer[BUFFER_SIZE] = {0};
 
     Serial pc(TXPIN, RXPIN);
     pc.baud(115200);
@@ -28,7 +20,7 @@ int main() {
     pc.puts("}}");
 
     while (1) {
-        pc.gets(buf, 256);
+        pc.gets(buffer, BUFFER_SIZE - 1);
-        pc.printf("%s", buf);
+        pc.printf("%s", buffer);
     }
 }

libraries/tests/mbed/env/test_env.cpp

@@ -7,6 +7,7 @@ const char* TEST_ENV_FAILURE = "failure";
 const char* TEST_ENV_MEASURE = "measure";
 const char* TEST_ENV_END = "end";
 
+
 static void led_blink(PinName led, float delay)
 {
     if (led != NC) {
@@ -41,11 +42,20 @@ void notify_performance_coefficient(const char* measurement_name, const double v
 
 void notify_completion(bool success)
 {
-    printf("{{%s}}" NL, success ? TEST_ENV_SUCCESS : TEST_ENV_FAILURE);
+    printf("{{%s}}" NL "{{%s}}" NL, success ? TEST_ENV_SUCCESS : TEST_ENV_FAILURE, TEST_ENV_END);
-    printf("{{%s}}" NL, TEST_ENV_END);
     led_blink(LED1, success ? 1.0 : 0.1);
 }
 
+bool notify_completion_str(bool success, char* buffer)
+{
+    bool result = false;
+    if (buffer) {
+        sprintf(buffer, "{{%s}}" NL "{{%s}}" NL, success ? TEST_ENV_SUCCESS : TEST_ENV_FAILURE, TEST_ENV_END);
+        result = true;
+    }
+    return result;
+}
+
 // -DMBED_BUILD_TIMESTAMP=1406208182.13
 unsigned int testenv_randseed()
 {

libraries/tests/mbed/env/test_env.h

@@ -17,6 +17,7 @@ extern const char* TEST_ENV_END;
 // Test result related notification functions
 void notify_start();
 void notify_completion(bool success);
+bool notify_completion_str(bool success, char* buffer);
 void notify_performance_coefficient(const char* measurement_name, const int value);
 void notify_performance_coefficient(const char* measurement_name, const unsigned int value);
 void notify_performance_coefficient(const char* measurement_name, const double value);

libraries/tests/mbed/hello/main.cpp

@@ -2,6 +2,7 @@
 
 int main()
 {
-    printf("Hello World\n");
+    notify_start();
+    printf("Hello World\r\n");
     while(1);
 }

libraries/tests/mbed/stdio/main.cpp

@@ -7,24 +7,31 @@
  */
 
 int main() {
+    DigitalOut led1(LED1);
+    DigitalOut led2(LED2);
+    
     union {
         int value_int;
     };
 
     notify_start();
 
+    const char* PRINT_PATTERN = "MBED: Your value was: %d\r\n";
+    
     while (true)
     {
         // SCANF PRINTF family
         value_int = 0;
+        led1 = 1;
         scanf("%d", &value_int);
-        printf("Your value was: %d\r\n", value_int);
+        printf(PRINT_PATTERN, value_int);
+        led1 = 0;
 
         // FSCANF, FPRINTF family
         value_int = 0;
+        led2 = 1;
         fscanf(stdin, "%d", &value_int);
-        fprintf(stdout, "Your value was: %d\r\n", value_int);
+        fprintf(stdout, PRINT_PATTERN, value_int);
-
+        led2 = 0;
-        //...
     }
 }

libraries/tests/net/echo/tcp_client_loop/main.cpp

@@ -1,40 +1,47 @@
 #include "mbed.h"
 #include "test_env.h"
 #include "EthernetInterface.h"
+#include <algorithm>
 
-struct s_ip_address
+namespace {
-{
+    const int BUFFER_SIZE = 64;
-    int ip_1;
+    const int MAX_ECHO_LOOPS = 1000;
-    int ip_2;
+    const char ASCII_MAX = '~' - ' ';
-    int ip_3;
-    int ip_4;
-};
 
-#define MAX_ECHO_LOOPS   100
+    struct s_ip_address
+    {
+        int ip_1;
+        int ip_2;
+        int ip_3;
+        int ip_4;
+    };
+}
+
+char char_rand() {
+    return (rand() % ASCII_MAX) + ' ';
+}
 
 
 int main() {
-    char buffer[256] = {0};
+    char buffer[BUFFER_SIZE] = {0};
-    char out_buffer[] = "Hello World\n";
+    char out_buffer[BUFFER_SIZE] = {0};
-    char out_success[] = "{{success}}\n{{end}}\n";
-    char out_failure[] = "{{failure}}\n{{end}}\n";
     s_ip_address ip_addr = {0, 0, 0, 0};
     int port = 0;
 
-    printf("TCPCllient waiting for server IP and port...\r\n");
+    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("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);
+    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("TCPClient IP Address is %s\r\n", eth.getIPAddress());
+    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("TCPCllient unable to connect to %s:%d\r\n", buffer, port);
+        printf("MBED: TCPCllient unable to connect to %s:%d\r\n", buffer, port);
         wait(1);
     }
 
@@ -42,14 +49,13 @@ int main() {
     bool result = true;
     int count_error = 0;
     for (int i = 0; i < MAX_ECHO_LOOPS; i++) {
-        socket.send_all(out_buffer, sizeof(out_buffer) - 1);
+        std::generate(out_buffer, out_buffer + BUFFER_SIZE, char_rand);
+        socket.send_all(out_buffer, BUFFER_SIZE);
 
-        int n = socket.receive(buffer, sizeof(buffer));
+        int n = socket.receive(buffer, BUFFER_SIZE);
         if (n > 0)
         {
-            buffer[n] = '\0';
+            bool echoed = memcmp(out_buffer, buffer, BUFFER_SIZE) == 0;
-            printf("%s", buffer);
-            bool echoed = strncmp(out_buffer, buffer, sizeof(out_buffer) - 1) == 0;
             result = result && echoed;
             if (echoed == false) {
                 count_error++;  // Count error messages
@@ -57,15 +63,13 @@ int main() {
         }
     }
 
-    printf("Loop messages passed: %d/%d\r\n", MAX_ECHO_LOOPS - count_error, MAX_ECHO_LOOPS);
+    printf("MBED: Loop messages passed: %d / %d\r\n", MAX_ECHO_LOOPS - count_error, MAX_ECHO_LOOPS);
 
-    if (result) {
+    if (notify_completion_str(result, buffer)) {
-        socket.send_all(out_success, sizeof(out_success) - 1);
+        socket.send_all(buffer, strlen(buffer));
-    }
-    else {
-        socket.send_all(out_failure, sizeof(out_failure) - 1);
     }
     socket.close();
     eth.disconnect();
+    notify_completion(result);
     return 0;
 }

libraries/tests/net/echo/tcp_server/main.cpp

@@ -3,35 +3,38 @@
 
 namespace {
     const int ECHO_SERVER_PORT = 7;
-    const int BUFFER_SIZE = 256;
+    const int BUFFER_SIZE = 64;
 }
 
 int main (void) {
+    char buffer[BUFFER_SIZE] = {0};
     EthernetInterface eth;
     eth.init(); //Use DHCP
     eth.connect();
-    printf("Server IP Address is %s:%d\n", eth.getIPAddress(), ECHO_SERVER_PORT);
+    printf("MBED: Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT);
 
     TCPSocketServer server;
     server.bind(ECHO_SERVER_PORT);
     server.listen();
 
     while (true) {
-        printf("Wait for new connection...\n");
+        printf("MBED: 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());
+        printf("MBED: Connection from: %s\r\n", client.get_address());
 
         while (true) {
-            char buffer[BUFFER_SIZE] = {0};
+            const int n = client.receive(buffer, sizeof(buffer));
-            int n = client.receive(buffer, sizeof(buffer));
+            if (n <= 0) {
-            if (n <= 0) break;
+                break;
+            }
             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);
             client.send_all(buffer, n);
-            if (n <= 0) break;
+            if (n <= 0) {
+                break;
+            }
         }
         client.close();
     }

libraries/tests/net/echo/udp_client/main.cpp

@@ -1,28 +1,40 @@
 #include "mbed.h"
 #include "rtos.h"
+#include "test_env.h"
 #include "EthernetInterface.h"
+#include <algorithm>
 
-#define CHECK(RC, STEP)       if (RC < 0) error(STEP": %d\n", RC)
+#define CHECK(RC, STEP)       if (RC < 0) error(STEP": %d\r\n", RC)
+
+namespace {
+    const int BUFFER_SIZE = 64;
+    const int MAX_ECHO_LOOPS = 100;
+    const char ASCII_MAX = '~' - ' ';
+
+    struct s_ip_address
+    {
+        int ip_1;
+        int ip_2;
+        int ip_3;
+        int ip_4;
+    };
+}
+
+char char_rand() {
+    return (rand() % ASCII_MAX) + ' ';
+}
 
-struct s_ip_address
-{
-    int ip_1;
-    int ip_2;
-    int ip_3;
-    int ip_4;
-};
 
 int main() {
-    char buffer[256] = {0};
+    char buffer[BUFFER_SIZE] = {0};
-    char out_buffer[] = "Hello World\n";
+    char out_buffer[BUFFER_SIZE] = {0};
-    char out_success[] = "{{success}}\n{{end}}\n";
-    char out_failure[] = "{{failure}}\n{{end}}\n";
     s_ip_address ip_addr = {0, 0, 0, 0};
     int port = 0;
+    bool result = true;
 
-    printf("UDPCllient waiting for server IP and port...\r\n");
+    printf("MBED: UDPCllient 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("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);
+    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;
     int rc = eth.init(); //Use DHCP
@@ -36,30 +48,33 @@ int main() {
     rc = socket.init();
     CHECK(rc, "socket init");
 
-    printf("UDPClient IP Address is %s\r\n", eth.getIPAddress());
+    printf("MBED: UDPClient 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);
 
     Endpoint echo_server;
     rc = echo_server.set_address(buffer, port);
     CHECK(rc, "set_address");
 
-    rc = socket.sendTo(echo_server, out_buffer, sizeof(out_buffer));
+    for (int i =0; i < MAX_ECHO_LOOPS; i++) {
-    CHECK(rc, "sendTo");
+        std::generate(out_buffer, out_buffer + BUFFER_SIZE, char_rand);
+        rc = socket.sendTo(echo_server, out_buffer, sizeof(out_buffer));
+        CHECK(rc, "sendTo");
 
-    int n = socket.receiveFrom(echo_server, buffer, sizeof(buffer));
+        const int n = socket.receiveFrom(echo_server, buffer, sizeof(buffer));
-    CHECK(n, "receiveFrom");
+        CHECK(n, "receiveFrom");
-    if (n > 0)
+
-    {
+        if (memcmp(buffer, out_buffer, BUFFER_SIZE) != 0) {
-        buffer[n] = '\0';
+            result = false;
-        printf("%s", buffer);
+            break;
-        if (strncmp(out_buffer, buffer, sizeof(out_buffer) - 1) == 0) {
-            socket.sendTo(echo_server, out_success, sizeof(out_success) - 1);
         }
     }
 
-    socket.sendTo(echo_server, out_failure, sizeof(out_failure) - 1);
+    if (notify_completion_str(result, buffer)) {
+        socket.sendTo(echo_server, buffer, strlen(buffer));
+    }
 
     socket.close();
     eth.disconnect();
+    notify_completion(result);
     return 0;
 }

libraries/tests/net/echo/udp_link_layer/main.cpp

@@ -12,24 +12,24 @@
 
 // Evil globals
 namespace {
-Mutex cli_serv_mutex;
+    // IP and port used to store HOST address info
-// cli_serv_mutex.lock(); // LOCK
+    char host_address[32] = {0};
-// cli_serv_mutex.unlock(); // LOCK
+    volatile int host_port = 0;
 
-const int ECHO_SERVER_PORT = 7;
+    const int ECHO_SERVER_PORT = 7;
-const int BUFFER_SIZE = 256;
+    const int BUFFER_SIZE = 64;
 
-// Forwarding packet queue
+    // Forwarding packet queue
-std::list<std::string> datagram_queue;
+    std::list<std::string> datagram_queue;
 
-// IP and port used to store HOST address info
+    // Statistics (mbed)
-char host_address[32] = { 0 };
+    volatile int received_packets = 0;
-volatile int host_port = 0;
+    volatile int forwarded_packets = 0;
+    volatile int max_queue_len = 0;
 
-// Statistics (mbed)
+    Mutex cli_serv_mutex;
-volatile int received_packets = 0;
+    // cli_serv_mutex.lock(); // LOCK
-volatile int forwarded_packets = 0;
+    // cli_serv_mutex.unlock(); // LOCK
-volatile int max_queue_len = 0;
 }
 
 void udp_server_task(void const *argument)
@@ -107,13 +107,14 @@ int main(void)
 
     eth.init(); //Use DHCP
     eth.connect();
-    printf("Server IP Address is %s:%d\n", eth.getIPAddress(), ECHO_SERVER_PORT);
+    printf("MBED: Server IP Address is %s:%d\r\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
+    // Control TCP server to get MBED statistics
     {
+        char buffer[BUFFER_SIZE] = {0};
         const int TELNET_SERVER_PORT = 23;
         const int BUFFER_SIZE = 256;
         TCPSocketServer server;
@@ -121,18 +122,17 @@ int main(void)
         server.listen();
 
         while (true) {
-            printf("Wait for new connection...\n");
+            printf("MBED: Wait for new connection...\r\n");
             TCPSocketConnection client;
             server.accept(client);
             client.set_blocking(false, 1500); // Timeout after (1.5)s
-            printf("Connection from: %s\n", client.get_address());
+            printf("MBED: Connection from: %s\r\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);
+                    // 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));

libraries/tests/net/echo/udp_server/main.cpp

@@ -3,28 +3,28 @@
 
 namespace {
     const int ECHO_SERVER_PORT = 7;
-    const int BUFFER_SIZE = 256;
+    const int BUFFER_SIZE = 64;
 }
 
 int main (void) {
     EthernetInterface eth;
     eth.init(); //Use DHCP
     eth.connect();
-    printf("Server IP Address is %s:%d\n", eth.getIPAddress(), ECHO_SERVER_PORT);
+    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) {
-        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());
+            //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);
+            //printf("Server received: %s\n", buffer);
             server.sendTo(client, buffer, n);
         }
     }

libraries/tests/net/protocols/HTTPClient_HelloWorld/main.cpp

@@ -3,7 +3,10 @@
 #include "EthernetInterface.h"
 #include "HTTPClient.h"
 
-#define BUFFER_SIZE 512
+
+namespace {
+    const int BUFFER_SIZE = 512;
+}
 
 int main()
 {
@@ -27,6 +30,7 @@ int main()
         }
 
         if (result == false) {
+            eth.disconnect();
             notify_completion(false);
             exit(ret);
         }
@@ -51,6 +55,7 @@ int main()
         }
 
         if (result == false) {
+            eth.disconnect();
             notify_completion(false);
             exit(ret);
         }

workspace_tools/build_travis.py

@@ -30,12 +30,14 @@ build_list = (
     { "target": "LPC1768",       "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "eth", "usb_host", "usb", "ublox", "fat"] },
     { "target": "LPC2368",       "toolchains": "GCC_ARM", "libs": ["fat"]  },
     { "target": "LPC11U24",      "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
-    { "target": "OC_MBUINO",    "toolchains": "GCC_ARM", "libs": ["fat"]  },
+    { "target": "OC_MBUINO",     "toolchains": "GCC_ARM", "libs": ["fat"]  },
 
     { "target": "LPC11U24_301",  "toolchains": "GCC_ARM", "libs": ["fat"] },
     { "target": "NUCLEO_F103RB", "toolchains": "GCC_ARM", "libs": ["fat"] },
 
     { "target": "NUCLEO_F401RE", "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
+    { "target": "NUCLEO_F411RE", "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
+    { "target": "DISCO_F407VG",  "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
     { "target": "LPC1114",       "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
     { "target": "LPC11U35_401",  "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },
     { "target": "UBLOX_C027",    "toolchains": "GCC_ARM", "libs": ["dsp", "rtos", "fat"] },

workspace_tools/export/gcc_arm_nucleo_f401re.tmpl

@@ -0,0 +1,77 @@
+# This file was automagically generated by mbed.org. For more information, 
+# see http://mbed.org/handbook/Exporting-to-GCC-ARM-Embedded
+
+GCC_BIN = 
+PROJECT = {{name}}
+OBJECTS = {% for f in to_be_compiled %}{{f}} {% endfor %}
+SYS_OBJECTS = {% for f in object_files %}{{f}} {% endfor %}
+INCLUDE_PATHS = {% for p in include_paths %}-I{{p}} {% endfor %}
+LIBRARY_PATHS = {% for p in library_paths %}-L{{p}} {% endfor %}
+LIBRARIES = {% for lib in libraries %}-l{{lib}} {% endfor %}
+LINKER_SCRIPT = {{linker_script}}
+
+############################################################################### 
+AS      = $(GCC_BIN)arm-none-eabi-as
+CC      = $(GCC_BIN)arm-none-eabi-gcc
+CPP     = $(GCC_BIN)arm-none-eabi-g++
+LD      = $(GCC_BIN)arm-none-eabi-gcc
+OBJCOPY = $(GCC_BIN)arm-none-eabi-objcopy
+OBJDUMP = $(GCC_BIN)arm-none-eabi-objdump
+SIZE 	= $(GCC_BIN)arm-none-eabi-size
+
+CPU = -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=$(FLOAT_ABI)
+CC_FLAGS = $(CPU) -c -g -fno-common -fmessage-length=0 -Wall -fno-exceptions -ffunction-sections -fdata-sections
+CC_FLAGS += -MMD -MP
+CC_SYMBOLS = {% for s in symbols %}-D{{s}} {% endfor %}
+
+LD_FLAGS = $(CPU) -Wl,--gc-sections --specs=nano.specs -u _printf_float -u _scanf_float
+LD_FLAGS += -Wl,-Map=$(PROJECT).map,--cref
+LD_SYS_LIBS = -lstdc++ -lsupc++ -lm -lc -lgcc -lnosys
+
+ifeq ($(HARDFP),1)
+	FLOAT_ABI = hard
+else
+	FLOAT_ABI = softfp
+endif
+
+ifeq ($(DEBUG), 1)
+  CC_FLAGS += -DDEBUG -O0
+else
+  CC_FLAGS += -DNDEBUG -Os
+endif
+
+all: $(PROJECT).bin $(PROJECT).hex size
+
+clean:
+	rm -f $(PROJECT).bin $(PROJECT).elf $(PROJECT).hex $(PROJECT).map $(PROJECT).lst $(OBJECTS) $(DEPS)
+
+.s.o:
+	$(AS) $(CPU) -o $@ $<
+
+.c.o:
+	$(CC)  $(CC_FLAGS) $(CC_SYMBOLS) -std=gnu99   $(INCLUDE_PATHS) -o $@ $<
+
+.cpp.o:
+	$(CPP) $(CC_FLAGS) $(CC_SYMBOLS) -std=gnu++98 $(INCLUDE_PATHS) -o $@ $<
+
+
+$(PROJECT).elf: $(OBJECTS) $(SYS_OBJECTS)
+	$(LD) $(LD_FLAGS) -T$(LINKER_SCRIPT) $(LIBRARY_PATHS) -o $@ $^ $(LIBRARIES) $(LD_SYS_LIBS) $(LIBRARIES) $(LD_SYS_LIBS)
+
+$(PROJECT).bin: $(PROJECT).elf
+	@$(OBJCOPY) -O binary $< $@
+
+$(PROJECT).hex: $(PROJECT).elf
+	@$(OBJCOPY) -O ihex $< $@
+
+$(PROJECT).lst: $(PROJECT).elf
+	@$(OBJDUMP) -Sdh $< > $@
+
+lst: $(PROJECT).lst
+
+size:
+	$(SIZE) $(PROJECT).elf
+
+DEPS = $(OBJECTS:.o=.d) $(SYS_OBJECTS:.o=.d)
+-include $(DEPS)
+

workspace_tools/export/gcc_arm_nucleo_f411re.tmpl

@@ -0,0 +1,77 @@
+# This file was automagically generated by mbed.org. For more information, 
+# see http://mbed.org/handbook/Exporting-to-GCC-ARM-Embedded
+
+GCC_BIN = 
+PROJECT = {{name}}
+OBJECTS = {% for f in to_be_compiled %}{{f}} {% endfor %}
+SYS_OBJECTS = {% for f in object_files %}{{f}} {% endfor %}
+INCLUDE_PATHS = {% for p in include_paths %}-I{{p}} {% endfor %}
+LIBRARY_PATHS = {% for p in library_paths %}-L{{p}} {% endfor %}
+LIBRARIES = {% for lib in libraries %}-l{{lib}} {% endfor %}
+LINKER_SCRIPT = {{linker_script}}
+
+############################################################################### 
+AS      = $(GCC_BIN)arm-none-eabi-as
+CC      = $(GCC_BIN)arm-none-eabi-gcc
+CPP     = $(GCC_BIN)arm-none-eabi-g++
+LD      = $(GCC_BIN)arm-none-eabi-gcc
+OBJCOPY = $(GCC_BIN)arm-none-eabi-objcopy
+OBJDUMP = $(GCC_BIN)arm-none-eabi-objdump
+SIZE 	= $(GCC_BIN)arm-none-eabi-size
+
+CPU = -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=$(FLOAT_ABI)
+CC_FLAGS = $(CPU) -c -g -fno-common -fmessage-length=0 -Wall -fno-exceptions -ffunction-sections -fdata-sections
+CC_FLAGS += -MMD -MP
+CC_SYMBOLS = {% for s in symbols %}-D{{s}} {% endfor %}
+
+LD_FLAGS = $(CPU) -Wl,--gc-sections --specs=nano.specs -u _printf_float -u _scanf_float
+LD_FLAGS += -Wl,-Map=$(PROJECT).map,--cref
+LD_SYS_LIBS = -lstdc++ -lsupc++ -lm -lc -lgcc -lnosys
+
+ifeq ($(HARDFP),1)
+	FLOAT_ABI = hard
+else
+	FLOAT_ABI = softfp
+endif
+
+ifeq ($(DEBUG), 1)
+  CC_FLAGS += -DDEBUG -O0
+else
+  CC_FLAGS += -DNDEBUG -Os
+endif
+
+all: $(PROJECT).bin $(PROJECT).hex size
+
+clean:
+	rm -f $(PROJECT).bin $(PROJECT).elf $(PROJECT).hex $(PROJECT).map $(PROJECT).lst $(OBJECTS) $(DEPS)
+
+.s.o:
+	$(AS) $(CPU) -o $@ $<
+
+.c.o:
+	$(CC)  $(CC_FLAGS) $(CC_SYMBOLS) -std=gnu99   $(INCLUDE_PATHS) -o $@ $<
+
+.cpp.o:
+	$(CPP) $(CC_FLAGS) $(CC_SYMBOLS) -std=gnu++98 $(INCLUDE_PATHS) -o $@ $<
+
+
+$(PROJECT).elf: $(OBJECTS) $(SYS_OBJECTS)
+	$(LD) $(LD_FLAGS) -T$(LINKER_SCRIPT) $(LIBRARY_PATHS) -o $@ $^ $(LIBRARIES) $(LD_SYS_LIBS) $(LIBRARIES) $(LD_SYS_LIBS)
+
+$(PROJECT).bin: $(PROJECT).elf
+	@$(OBJCOPY) -O binary $< $@
+
+$(PROJECT).hex: $(PROJECT).elf
+	@$(OBJCOPY) -O ihex $< $@
+
+$(PROJECT).lst: $(PROJECT).elf
+	@$(OBJDUMP) -Sdh $< > $@
+
+lst: $(PROJECT).lst
+
+size:
+	$(SIZE) $(PROJECT).elf
+
+DEPS = $(OBJECTS:.o=.d) $(SYS_OBJECTS:.o=.d)
+-include $(DEPS)
+

workspace_tools/export/gccarm.py

@@ -48,6 +48,9 @@ class GccArm(Exporter):
         'LPCCAPPUCCINO',
         'ARCH_BLE',
         'MTS_GAMBIT',
+        'ARCH_MAX',
+        'NUCLEO_F401RE',
+        'NUCLEO_F411RE',
     ]
 
     DOT_IN_RELATIVE_PATH = True

workspace_tools/export_test.py

@@ -122,6 +122,8 @@ if __name__ == '__main__':
             ('gcc_arm', 'DISCO_F407VG'),
             ('gcc_arm', 'DISCO_F303VC'),
             ('gcc_arm', 'NRF51822'),
+            ('gcc_arm', 'NUCLEO_F401RE'),
+            ('gcc_arm', 'NUCLEO_F411RE'),
 
 
             ('ds5_5', 'LPC1768'), ('ds5_5', 'LPC11U24'),

workspace_tools/host_tests/dev_null_auto.py

@@ -19,29 +19,42 @@ from host_test import DefaultTest
 from sys import stdout
 
 class DevNullTest(DefaultTest):
+
+    def check_readline(self, text):
+        """ Reads line from serial port and checks if text was part of read string
+        """
+        result = False
+        c = self.mbed.serial_readline()
+        if c is None:
+            self.print_result("ioerr_serial")
+            return None
+        if text in c:
+            result = True
+        return result
+
     def run(self):
         result = True
-        str = ''
+
-        for i in range(3):
+        # Test should print some text and later stop printing
-            c = self.mbed.serial_read(128)
+        res = self.check_readline("re-routing stdout to /null")   # 'MBED: re-routing stdout to /null'
-            if c is None:
+        if not res:
-                self.print_result("ioerr_serial")
+            # We haven't read preamble line
-                return
+            result = False
-            else:
+        else:
-                str += c
+            # Check if there are printed characters
-            # Check for expected and unexpected prints in Mbed output
+            str = ''
-            if "re-routing stdout to /null" not in str:
+            for i in range(3):
-                result = False
+                c = self.mbed.serial_read(32)
-            if "printf redirected to /null" in str:
+                if c is None:
-                result = False
+                    self.print_result("ioerr_serial")
-            if "{failure}" in str:
+                    return
-                result = False
+                else:
-            if not result:
+                    str += c
-                break
+                if len(str) > 0:
-        # Data from serial received correctly
+                    result = False
-        print "Received %d bytes:"% len(str)
+                    break
-        print str
+            print "Received %d bytes: %s"% (len(str), str)
-        stdout.flush()
+            stdout.flush()
         if result:
             self.print_result('success')
         else:

workspace_tools/host_tests/echo.py

@@ -14,6 +14,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
+import sys
 import uuid
 from sys import stdout
 from host_test import Test
@@ -24,40 +25,35 @@ class EchoTest(Test):
         Test.__init__(self)
         self.mbed.init_serial(115200)
         self.mbed.reset()
+        self.TEST_LOOP_COUNT = 50
 
     def test(self):
-        # Let's wait for Mbed to print its readiness, usually "{{start}}"
+        """ Test function, return True or False to get standard test notification on stdout
-        if self.mbed.serial_timeout(None) is None:
+        """
-            self.print_result("ioerr_serial")
+        c = self.mbed.serial_readline() # '{{start}}'
-            return
-
-        c = self.mbed.serial_read(len('{{start}}'))
         if c is None:
             self.print_result("ioerr_serial")
             return
-        print c
+        print c.strip()
         stdout.flush()
 
-        if self.mbed.serial_timeout(1) is None:
-            self.print_result("ioerr_serial")
-            return
-
         self.mbed.flush()
-        self.notify("Starting the ECHO test")
+        self.notify("HOST: Starting the ECHO test")
-        check = True
+        result = True
-        for i in range(1, 100):
+        for i in range(0, self.TEST_LOOP_COUNT):
-            TEST = str(uuid.uuid4())
+            TEST = str(uuid.uuid4()) + "\n"
-            self.mbed.serial_write(TEST + "\n")
+            self.mbed.serial_write(TEST)
-            l = self.mbed.serial.readline().strip()
+            c = self.mbed.serial_readline()
-            if not l: continue
+            if c is None:
-
+                self.print_result("ioerr_serial")
-            if l != TEST:
+                return
-                check = False
+            if c.strip() != TEST.strip():
-                self.notify('"%s" != "%s"' % (l, TEST))
+                self.notify('HOST: "%s" != "%s"'% (c, TEST))
+                result = False
             else:
-                if (i % 10) == 0:
+                sys.stdout.write('.')
-                    self.notify(TEST)
+                stdout.flush()
-        return check
+        return result
 
 
 if __name__ == '__main__':

workspace_tools/host_tests/hello_auto.py

@@ -23,23 +23,26 @@ class HelloTest(DefaultTest):
     HELLO_WORLD = "Hello World"
 
     def run(self):
-        c = self.mbed.serial_read(128)
+        c = self.mbed.serial_readline()
+        if c is None:
+           self.print_result("ioerr_serial")
+           return
+        print c.strip()
+        stdout.flush()
+
+        c = self.mbed.serial_readline()
         if c is None:
            self.print_result("ioerr_serial")
            return
         print "Read %d bytes"% len(c)
-        print c
+        print c.strip()
         stdout.flush()
         result = True
         # Because we can have targetID here let's try to decode
         if len(c) < len(self.HELLO_WORLD):
             result = False
-        elif c[0] == '$':
-            # We are looking for targetID here
-            res = re.search('^[$]+[0-9a-fA-F]+' + self.HELLO_WORLD, c)
-            result = res is not None
         else:
-            result = (c.startswith(self.HELLO_WORLD))
+            result = self.HELLO_WORLD in c
 
         if result: # Hello World received
             self.print_result('success')

workspace_tools/host_tests/host_test.py

@@ -24,7 +24,7 @@ except ImportError, e:
 
 import os
 from optparse import OptionParser
-from time import sleep
+from time import sleep, time
 from sys import stdout
 
 # This is a little tricky. We need to add upper directory to path so
@@ -128,6 +128,22 @@ class Mbed:
                 result = None
         return result
 
+    def serial_readline(self, timeout=5):
+        """ Wraps self.mbed.serial object read method to read one line from serial port
+        """
+        result = ''
+        start = time()
+        while (time() - start) < timeout:
+            if self.serial:
+                try:
+                    c = self.serial.read(1)
+                    result += c
+                except:
+                    result = None
+                if c == '\n':
+                    break
+        return result
+
     def serial_write(self, write_buffer):
         """ Wraps self.mbed.serial object write method
         """

workspace_tools/host_tests/rtc_auto.py

@@ -21,31 +21,29 @@ from time import strftime, gmtime
 from sys import stdout
 
 class RTCTest(DefaultTest):
-    PATTERN_RTC_VALUE = "^\[(\d+)\] \[(\d+-\d+-\d+ \d+:\d+:\d+ [AaPpMm]{2})\]\\n"
+    PATTERN_RTC_VALUE = "\[(\d+)\] \[(\d+-\d+-\d+ \d+:\d+:\d+ [AaPpMm]{2})\]"
     re_detect_rtc_value = re.compile(PATTERN_RTC_VALUE)
 
     def run(self):
         test_result = True
-        if self.mbed.serial_timeout(None) is None:
-            self.print_result("ioerr_serial")
-            return
         for i in range(0, 5):
-            c = self.mbed.serial_read(38)   # 38 len("[1256729742] [2009-10-28 11:35:42 AM]\n"
+            c = self.mbed.serial_readline()
             if c is None:
                 self.print_result("ioerr_serial")
                 return
-            stdout.flush()
+
             m = self.re_detect_rtc_value.search(c)
             if m and len(m.groups()):
                 sec = m.groups()[0]
                 time_str = m.groups()[1]
                 correct_time_str = strftime("%Y-%m-%d %H:%M:%S %p", gmtime(float(sec)))
                 test_result = test_result and (time_str == correct_time_str)
-                result_msg = "OK" if (time_str == correct_time_str) else "FAIL"
+                result_msg = "OK" if (time_str == correct_time_str and sec > 0) else "FAIL"
                 print "Got RTC time: " + c[:-1] + " ... " + result_msg
                 stdout.flush()
             else:
                 print c
+                stdout.flush()
                 test_result = False
                 break
 

workspace_tools/host_tests/stdio_auto.py

@@ -15,11 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import random
 import re
-from host_test import DefaultTest
+import random
-from time import time
 from sys import stdout
+from time import time
+from host_test import DefaultTest
 
 class StdioTest(DefaultTest):
     PATTERN_INT_VALUE = "Your value was: (-?\d+)"
@@ -28,52 +28,39 @@ class StdioTest(DefaultTest):
     def run(self):
         test_result = True
 
-        # Let's wait for Mbed to print its readiness, usually "{{start}}"
+        c = self.mbed.serial_readline() # {{start}} preamble
-        if self.mbed.serial_timeout(None) is None:
-            self.print_result("ioerr_serial")
-            return
-
-        c = self.mbed.serial_read(len('{{start}}'))
         if c is None:
             self.print_result("ioerr_serial")
             return
         print c
         stdout.flush()
 
-        if self.mbed.serial_timeout(1) is None:
+        for i in range(0, 10):
-            self.print_result("ioerr_serial")
-            return
-
-        for i in range(1, 5):
             random_integer = random.randint(-99999, 99999)
-            print "Generated number: " + str(random_integer)
+            print "HOST: Generated number: " + str(random_integer)
             stdout.flush()
             self.mbed.serial_write(str(random_integer) + "\n")
-            serial_stdio_msg = ""
 
-            ip_msg_timeout = self.mbed.options.timeout
+            serial_stdio_msg = self.mbed.serial_readline()
-            start_serial_pool = time();
+            if c is None:
-            while (time() - start_serial_pool) < ip_msg_timeout:
+                self.print_result("ioerr_serial")
-                c = self.mbed.serial_read(512)
+                return
-                if c is None:
+            print serial_stdio_msg.strip()
-                    self.print_result("ioerr_serial")
+            stdout.flush()
-                    return
+
-                stdout.write(c)
+            # Searching for reply with scanned values
+            m = self.re_detect_int_value.search(serial_stdio_msg)
+            if m and len(m.groups()):
+                int_value = m.groups()[0]
+                int_value_cmp = random_integer == int(int_value)
+                test_result = test_result and int_value_cmp
+                print "Number read %s ... [%s]"% (int_value, "OK" if int_value_cmp else "FAIL")
+                print
                 stdout.flush()
-                serial_stdio_msg += c
-                # Searching for reply with scanned values
-                m = self.re_detect_int_value.search(serial_stdio_msg)
-                if m and len(m.groups()):
-                    duration = time() - start_serial_pool
-                    print "Number: " + str(m.groups()[0])
-                    test_result = test_result and (random_integer == int(m.groups()[0]))
-                    stdout.flush()
-                    break
             else:
-                print "Error: No data from MUT sent"
+                test_result = False
-                self.print_result('error')
+                break
-                exit(-2)
+                
-
         if test_result: # All numbers are the same
             self.print_result('success')
         else:

workspace_tools/host_tests/tcpecho_client_auto.py

@@ -15,63 +15,73 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from SocketServer import BaseRequestHandler, TCPServer
+import sys
 import socket
-from host_test import Test
 from sys import stdout
 from time import sleep
+from host_test import Test
+from SocketServer import BaseRequestHandler, TCPServer
+
 
 SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
 SERVER_PORT = 7
 
+
 class TCPEchoClientTest(Test):
     def __init__(self):
         Test.__init__(self)
         self.mbed.init_serial()
 
     def send_server_ip_port(self, ip_address, port_no):
-        print "Resetting target..."
+        """ Set up network host. Reset target and and send server IP via serial to Mbed
+        """
+        print "HOST: Resetting target..."
         self.mbed.reset()
 
-        # Let's wait for Mbed to print its readiness, usually "{{start}}"
+        c = self.mbed.serial_readline() # 'TCPCllient waiting for server IP and port...'
-        if self.mbed.serial_timeout(None) is None:
-            self.print_result("ioerr_serial")
-            return
-
-        c = self.mbed.serial_read(len('TCPCllient waiting for server IP and port...'))
         if c is None:
             self.print_result("ioerr_serial")
             return
-        print c
-        stdout.flush()
 
-        if self.mbed.serial_timeout(1) is None:
+        print c.strip()
-            self.print_result("ioerr_serial")
+        print "HOST: Sending server IP Address to target...",
-            return
-
-        print "Sending server IP Address to target..."
         stdout.flush()
         connection_str = ip_address + ":" + str(port_no) + "\n"
         self.mbed.serial_write(connection_str)
+        print connection_str
+        stdout.flush()
+
+        # Two more strings about connection should be sent by MBED
+        for i in range(0, 2):
+            c = self.mbed.serial_readline()
+            if c is None:
+                self.print_result("ioerr_serial")
+                return
+            print c.strip()
+            stdout.flush()
 
 
 class TCPEchoClient_Handler(BaseRequestHandler):
-    def print_result(self, result):
-        print "\n{%s}\n{end}" % result
-
     def handle(self):
         """ One handle per connection """
-        print "connection received"
+        print "HOST: Connection received...",
+        count = 1;
         while True:
             data = self.request.recv(1024)
             if not data: break
             self.request.sendall(data)
-            print "echo: " + repr(data)
+            if '{{end}}' in str(data):
+                print
+                print str(data)
+            else:
+                if not count % 10:
+                    sys.stdout.write('.')
+                count += 1
             stdout.flush()
 
 
 server = TCPServer((SERVER_IP, SERVER_PORT), TCPEchoClient_Handler)
-print "listening for connections: " + SERVER_IP + ":" + str(SERVER_PORT)
+print "HOST: Listening for connections: " + SERVER_IP + ":" + str(SERVER_PORT)
 
 mbed_test = TCPEchoClientTest();
 mbed_test.send_server_ip_port(SERVER_IP, SERVER_PORT)

workspace_tools/host_tests/tcpecho_server_auto.py

@@ -15,67 +15,74 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import socket
 import re
-from host_test import DefaultTest
+import sys
-from time import time
+import uuid
+import socket
 from sys import stdout
+from time import time
+from host_test import DefaultTest
 
 class TCPEchoServerTest(DefaultTest):
     ECHO_SERVER_ADDRESS = ""
     ECHO_PORT = 0
+    ECHO_LOOPs = 100
     s = None # Socket
 
-    PATTERN_SERVER_IP = "^Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
+    PATTERN_SERVER_IP = "Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
     re_detect_server_ip = re.compile(PATTERN_SERVER_IP)
 
     def run(self):
-        ip_msg_timeout = self.mbed.options.timeout
+        result = False
-        serial_ip_msg = ""
+        c = self.mbed.serial_readline()
-        start_serial_pool = time();
+        if c is None:
-        while (time() - start_serial_pool) < ip_msg_timeout:
+            self.print_result("ioerr_serial")
-            c = self.mbed.serial_read(512)
+            return
-            if c is None:
+        print c
-                self.print_result("ioerr_serial")
+        stdout.flush()
-                return
+
-            stdout.write(c)
+        m = self.re_detect_server_ip.search(c)
+        if m and len(m.groups()):
+            self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
+            self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
+            print "HOST: TCP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT)
             stdout.flush()
-            serial_ip_msg += c
+
-            # Searching for IP address and port prompted by server
+            # We assume this test fails so can't send 'error' message to server
-            m = self.re_detect_server_ip.search(serial_ip_msg)
+            try:
-            if m and len(m.groups()):
+                self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
+                self.s.connect((self.ECHO_SERVER_ADDRESS, self.ECHO_PORT))
-                self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
+            except Exception, e:
-                duration = time() - start_serial_pool
+                print "HOST: Error: %s" % e
-                print "TCP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT) + " after " + "%.2f" % duration  + " sec"
+                self.print_result('error')
-                stdout.flush()
+                exit(-1)
-                break
+
+            print 'HOST: Sending %d echo strings...'% self.ECHO_LOOPs,
+            for i in range(0, self.ECHO_LOOPs):
+                TEST_STRING = str(uuid.uuid4())
+                self.s.sendall(TEST_STRING)
+                data = self.s.recv(128)
+                received_str = repr(data)[1:-1]
+                if TEST_STRING == received_str: # We need to cut not needed single quotes from the string
+                    sys.stdout.write('.')
+                    stdout.flush()
+                    result = True
+                else:
+                    print "Expected: "
+                    print "'%s'"% TEST_STRING
+                    print "received: "
+                    print "'%s'"% received_str
+                    result = False
+                    break
+            self.s.close()
         else:
-            print "Error: No IP and port information sent from server"
+            print "HOST: TCP Server not found"
-            self.print_result('error')
+            result = False
-            exit(-2)
 
-        # We assume this test fails so can't send 'error' message to server
+        if result:
-        try:
-            self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self.s.connect((self.ECHO_SERVER_ADDRESS, self.ECHO_PORT))
-        except Exception, e:
-            print "Error: %s" % e
-            self.print_result('error')
-            exit(-1)
-
-        TEST_STRING = 'Hello, world !!!'
-        self.s.sendall(TEST_STRING)
-
-        data = self.s.recv(1024)
-        received_str = repr(data)[1:-1]
-
-        if TEST_STRING == received_str: # We need to cut not needed single quotes from the string
-            print 'Received data: ' + received_str
             self.print_result('success')
         else:
             self.print_result('failure')
-        self.s.close()
 
         # Receiving
         try:

workspace_tools/host_tests/udp_link_layer_auto.py

@@ -21,13 +21,14 @@ make.py -m LPC1768 -t ARM -d E:\ -n NET_14
 udp_link_layer_auto.py -p COM20 -d E:\ -t 10
 """
 
-import thread
-from SocketServer import BaseRequestHandler, UDPServer
-import socket
 import re
-from host_test import DefaultTest
+import uuid
-from time import time, sleep
+import socket
+import thread
 from sys import stdout
+from time import time, sleep
+from host_test import DefaultTest
+from SocketServer import BaseRequestHandler, UDPServer
 
 
 # Received datagrams (with time)
@@ -39,7 +40,8 @@ dict_udp_sent_datagrams = dict()
 
 class UDPEchoClient_Handler(BaseRequestHandler):
     def handle(self):
-        """ One handle per connection """
+        """ One handle per connection
+        """
         _data, _socket = self.request
         # Process received datagram
         data_str = repr(_data)[1:-1]
@@ -47,9 +49,10 @@ class UDPEchoClient_Handler(BaseRequestHandler):
 
 
 def udp_packet_recv(threadName, server_ip, server_port):
-    """ This function will receive packet stream from mbed device """
+    """ This function will receive packet stream from mbed device
+    """
     server = UDPServer((server_ip, server_port), UDPEchoClient_Handler)
-    print "[UDP_COUNTER] Listening for connections... %s:%d"%(server_ip, server_port)
+    print "[UDP_COUNTER] Listening for connections... %s:%d"% (server_ip, server_port)
     server.serve_forever()
 
 
@@ -61,8 +64,9 @@ class UDPEchoServerTest(DefaultTest):
 
     TEST_PACKET_COUNT = 1000    # how many packets should be send
     TEST_STRESS_FACTOR = 0.001  # stress factor: 10 ms
+    PACKET_SATURATION_RATIO = 29.9 # Acceptable packet transmission in %
 
-    PATTERN_SERVER_IP = "^Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
+    PATTERN_SERVER_IP = "Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
     re_detect_server_ip = re.compile(PATTERN_SERVER_IP)
 
     def get_control_data(self, command="stat\n"):
@@ -75,38 +79,27 @@ class UDPEchoServerTest(DefaultTest):
         return data
 
     def run(self):
-        ip_msg_timeout = self.mbed.options.timeout
+        serial_ip_msg = self.mbed.serial_readline()
-        serial_ip_msg = ""
+        if serial_ip_msg is None:
-        start_serial_pool = time()
+            self.print_result("ioerr_serial")
-        while (time() - start_serial_pool) < ip_msg_timeout:
+            return
-            c = self.mbed.serial_read(512)
+        stdout.write(serial_ip_msg)
-            if c is None:
+        stdout.flush()
-                self.print_result("ioerr_serial")
+        # Searching for IP address and port prompted by server
-                return
+        m = self.re_detect_server_ip.search(serial_ip_msg)
-            stdout.write(c)
+        if m and len(m.groups()):
+            self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
+            self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
+            print "HOST: UDP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT)
             stdout.flush()
-            serial_ip_msg += c
-            # Searching for IP address and port prompted by server
-            m = self.re_detect_server_ip.search(serial_ip_msg)
-            if m and len(m.groups()):
-                self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
-                self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
-                duration = time() - start_serial_pool
-                print "UDP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT) + " after " + "%.2f" % duration  + " sec"
-                stdout.flush()
-                break
-        else:
-            print "Error: No IP and port information sent from server"
-            self.print_result('error')
-            exit(-2)
 
         # Open client socket to burst datagrams to UDP server in mbed
         try:
             self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         except Exception, e:
-            print "Error: %s" % e
+            print "HOST: Error: %s" % e
             self.print_result('error')
-            exit(-1)
+            return
 
         # UDP replied receiver works in background to get echoed datagrams
         SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
@@ -115,8 +108,8 @@ class UDPEchoServerTest(DefaultTest):
         sleep(0.5)
 
         # Burst part
-        TEST_STRING = 'Hello, world !!!'
         for no in range(self.TEST_PACKET_COUNT):
+            TEST_STRING = str(uuid.uuid4())
             payload = str(no) + "__" + TEST_STRING
             self.s.sendto(payload, (self.ECHO_SERVER_ADDRESS, self.ECHO_PORT))
             dict_udp_sent_datagrams[payload] = time()
@@ -124,26 +117,33 @@ class UDPEchoServerTest(DefaultTest):
         self.s.close()
 
         # Wait 5 seconds for packets to come
+        result = True
         print
-        print "Test Summary:"
+        print "HOST: Test Summary:"
         for d in range(5):
-            sleep(1)
+            sleep(1.0)
             summary_datagram_success = (float(len(dict_udp_recv_datagrams)) / float(self.TEST_PACKET_COUNT)) * 100.0
             # print dict_udp_recv_datagrams
-            print "Datagrams received after +%d sec: %.3f%% (%d / %d), stress=%.3f ms" % (d, summary_datagram_success, len(dict_udp_recv_datagrams), self.TEST_PACKET_COUNT, self.TEST_STRESS_FACTOR)
+            print "HOST: Datagrams received after +%d sec: %.3f%% (%d / %d), stress=%.3f ms" % (d, summary_datagram_success, len(dict_udp_recv_datagrams), self.TEST_PACKET_COUNT, self.TEST_STRESS_FACTOR)
+            result = result and (summary_datagram_success >= self.PACKET_SATURATION_RATIO)
             stdout.flush()
 
         # Getting control data from test
         print
-        print "Mbed Summary:"
+        print "HOST: Mbed Summary:"
         mbed_stats = self.get_control_data()
         print mbed_stats
         print
         stdout.flush()
 
+        if result:
+            self.print_result('success')
+        else:
+            self.print_result('failure')
+
         # Receiving serial data from mbed
         print
-        print "Remaining mbed serial port data:"
+        print "HOST: Remaining mbed serial port data:"
         try:
             while True:
                 c = self.mbed.serial_read(512)

workspace_tools/host_tests/udpecho_client_auto.py

@@ -14,60 +14,61 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
-from SocketServer import BaseRequestHandler, UDPServer
+
-from host_test import Test
+import sys
 import socket
 from sys import stdout
+from host_test import Test
+from SocketServer import BaseRequestHandler, UDPServer
+
 
 SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
 SERVER_PORT = 7
 
+
 class UDPEchoClientTest(Test):
     def __init__(self):
         Test.__init__(self)
         self.mbed.init_serial()
 
     def send_server_ip_port(self, ip_address, port_no):
-        print "Resetting target..."
+        print "HOST: Resetting target..."
         self.mbed.reset()
 
-        # Let's wait for Mbed to print its readiness, usually "{{start}}"
+        c = self.mbed.serial_readline() # 'UDPCllient waiting for server IP and port...'
-        if self.mbed.serial_timeout(None) is None:
-            self.print_result("ioerr_serial")
-            return
-
-        c = self.mbed.serial_read(len('UDPCllient waiting for server IP and port...'))
         if c is None:
             self.print_result("ioerr_serial")
             return
-        print c
+        print c.strip()
         stdout.flush()
 
-        if self.mbed.serial_timeout(1) is None:
+        print "HOST: Sending server IP Address to target..."
-            self.print_result("ioerr_serial")
-            return
-
-        print "Sending server IP Address to target..."
         connection_str = ip_address + ":" + str(port_no) + "\n"
         self.mbed.serial_write(connection_str)
 
+        c = self.mbed.serial_readline() # 'UDPCllient waiting for server IP and port...'
+        if c is None:
+            self.print_result("ioerr_serial")
+            return
+        print c.strip()
+        stdout.flush()
 
 class UDPEchoClient_Handler(BaseRequestHandler):
-    def print_result(self, result):
-        print "\n{%s}\n{end}" % result
-
     def handle(self):
-        """ One handle per connection """
+        """ One handle per connection
-        print "connection received"
+        """
         data, socket = self.request
-        print "client: ", self.client_address
-        print "data: ", data
         socket.sendto(data, self.client_address)
+        if '{{end}}' in data:
+            print
+            print data
+        else:
+            sys.stdout.write('.')
         stdout.flush()
 
 
 server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
-print "listening for connections"
+print "HOST: Listening for connections..."
 
 mbed_test = UDPEchoClientTest();
 mbed_test.send_server_ip_port(SERVER_IP, SERVER_PORT)

workspace_tools/host_tests/udpecho_server_auto.py

@@ -15,66 +15,66 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from socket import socket, AF_INET, SOCK_DGRAM
+
 import re
-from host_test import DefaultTest
+import sys
-from time import time
+import uuid
 from sys import stdout
+from time import time
+from host_test import DefaultTest
+from socket import socket, AF_INET, SOCK_DGRAM
+
 
 class UDPEchoServerTest(DefaultTest):
     ECHO_SERVER_ADDRESS = ""
     ECHO_PORT = 0
     s = None # Socket
 
-    PATTERN_SERVER_IP = "^Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
+    PATTERN_SERVER_IP = "Server IP Address is (\d+).(\d+).(\d+).(\d+):(\d+)"
     re_detect_server_ip = re.compile(PATTERN_SERVER_IP)
 
     def run(self):
-        ip_msg_timeout = self.mbed.options.timeout
+        result = True
-        serial_ip_msg = ""
+        serial_ip_msg = self.mbed.serial_readline()
-        start_serial_pool = time();
+        if serial_ip_msg is None:
-        while (time() - start_serial_pool) < ip_msg_timeout:
+            self.print_result("ioerr_serial")
-            c = self.mbed.serial_read(512)
+            return
-            if c is None:
+        stdout.write(serial_ip_msg)
-                self.print_result("ioerr_serial")
+        stdout.flush()
-                return
+        # Searching for IP address and port prompted by server
-            stdout.write(c)
+        m = self.re_detect_server_ip.search(serial_ip_msg)
+        if m and len(m.groups()):
+            self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
+            self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
+            print "HOST: UDP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT)
             stdout.flush()
-            serial_ip_msg += c
+
-            # Searching for IP address and port prompted by server
+            # We assume this test fails so can't send 'error' message to server
-            m = self.re_detect_server_ip.search(serial_ip_msg)
+            try:
-            if m and len(m.groups()):
+                self.s = socket(AF_INET, SOCK_DGRAM)
-                self.ECHO_SERVER_ADDRESS = ".".join(m.groups()[:4])
+            except Exception, e:
-                self.ECHO_PORT = int(m.groups()[4]) # must be integer for socket.connect method
+                print "HOST: Error: %s" % e
-                duration = time() - start_serial_pool
+                self.print_result('error')
-                print "UDP Server found at: " + self.ECHO_SERVER_ADDRESS + ":" + str(self.ECHO_PORT) + " after " + "%.2f" % duration  + " sec"
+                exit(-1)
+
+            for i in range(0, 100):
+                TEST_STRING = str(uuid.uuid4())
+                self.s.sendto(TEST_STRING, (self.ECHO_SERVER_ADDRESS, self.ECHO_PORT))
+                data = self.s.recv(len(TEST_STRING))
+                received_str = repr(data)[1:-1]
+                if TEST_STRING != received_str:
+                    result = False
+                    break
+                sys.stdout.write('.')
                 stdout.flush()
-                break
         else:
-            print "Error: No IP and port information sent from server"
+            result = False
-            self.print_result('error')
-            exit(-2)
 
-        # We assume this test fails so can't send 'error' message to server
+        self.s.close()
-        try:
+        if result:
-            self.s = socket(AF_INET, SOCK_DGRAM)
-        except Exception, e:
-            print "Error: %s" % e
-            self.print_result('error')
-            exit(-1)
-
-        TEST_STRING = 'Hello, world !!!'
-        self.s.sendto(TEST_STRING, (self.ECHO_SERVER_ADDRESS, self.ECHO_PORT))
-
-        data = self.s.recv(len(TEST_STRING))
-        received_str = repr(data)[1:-1]
-
-        if TEST_STRING == received_str: # We need to cut not needed single quotes from the string
-            print 'Received data: ' + received_str
             self.print_result('success')
         else:
             self.print_result('failure')
-        self.s.close()
 
         # Receiving
         try:

workspace_tools/host_tests/wait_us_auto.py

@@ -50,6 +50,10 @@ class WaitusTest(DefaultTest):
             if i > 2: # we will ignore first few measurements
                 delta = time() - start
                 deviation = abs(delta - 1)
+                # Round values
+                delta = round(delta, 2)
+                deviation = round(deviation, 2)
+                # Check if time measurements are in given range
                 deviation_ok = True if delta > 0 and deviation <= 0.10 else False # +/-10%
                 test_result = test_result and deviation_ok
                 msg = "OK" if deviation_ok else "FAIL"

workspace_tools/singletest.py

@@ -88,7 +88,7 @@ def get_version():
     """ Returns test script version
     """
     single_test_version_major = 1
-    single_test_version_minor = 2
+    single_test_version_minor = 3
     return (single_test_version_major, single_test_version_minor)
 
 

workspace_tools/tests.py

@@ -339,7 +339,7 @@ TESTS = [
         "source_dir": join(TEST_DIR, "mbed", "sleep"),
         "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
         "duration": 30,
-        "mcu": ["LPC1768", "LPC11U24", "LPC4088","NRF51822"]
+        "mcu": ["LPC1768", "LPC11U24", "LPC4088", "NRF51822"]
     },
     {
         "id": "MBED_5", "description": "PWM",
@@ -445,7 +445,7 @@ TESTS = [
         "source_dir": join(TEST_DIR, "mbed", "semihost"),
         "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
         "automated": True,
-        "mcu": ["LPC1768", "LPC2368", "LPC11U24", "KL05Z", "KL25Z", "KL46Z"]
+        "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
     },
     {
         "id": "MBED_23", "description": "Ticker Int us",
@@ -664,7 +664,7 @@ TESTS = [
     {
         "id": "NET_4", "description": "TCP echo client",
         "source_dir": join(TEST_DIR, "net", "echo", "tcp_client"),
-        "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
+        "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
         "automated": True,
         "host_test": "tcpecho_client_auto",
         "peripherals": ["ethernet"]
@@ -680,7 +680,7 @@ TESTS = [
     {
         "id": "NET_6", "description": "UDP echo client",
         "source_dir": join(TEST_DIR, "net", "echo", "udp_client"),
-        "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
+        "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
         "automated": True,
         "host_test" : "udpecho_client_auto",
         "peripherals": ["ethernet"],
@@ -738,8 +738,8 @@ TESTS = [
         "source_dir": join(TEST_DIR, "net", "echo", "udp_link_layer"),
         "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
         "automated": False,
-        "duration": 15,
+        "duration": 20,
-        "host_test": "udp_link_layer_auto.py",
+        "host_test": "udp_link_layer_auto",
         "peripherals": ["ethernet"],
     },