Merge pull request #35 from maejima-fumika/fix-bugs

Fix bugs and add other changes.

Author: chibash

docker-compose.yml

@@ -8,7 +8,7 @@ services:
     volumes:
       - ./server:/bluescript/server
       - /bluescript/server/node_modules
-      - /bluescript/server/temp-files
+      # - /bluescript/server/temp-files
       - ./modules:/bluescript/modules
       - ./microcontroller:/bluescript/microcontroller
     working_dir: /bluescript/server

microcontroller/ports/esp32/CMakeLists.txt

@@ -4,7 +4,14 @@
 # CMakeLists in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.16)
 
-set(EXTRA_COMPONENT_DIRS  "../../core" "../../../modules/std" "../../../modules/gpio" "../../../modules/timer")
+set(EXTRA_COMPONENT_DIRS  
+        "../../core" 
+        "../../../modules/std" 
+        "../../../modules/gpio" 
+        "../../../modules/timer" 
+        "../../../modules/display"
+        "../../../modules/button"
+    )
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(bluescript)

microcontroller/ports/esp32/main/CMakeLists.txt

@@ -1,4 +1,4 @@
-idf_component_register(SRCS "main.c" "ble.c" "shell.c" "logger.c" "event.c" 
+idf_component_register(SRCS "main.c" "ble.c" "shell.c" "logger.c"
                     INCLUDE_DIRS "include"
                     LDFRAGMENTS linker.lf
                     WHOLE_ARCHIVE)

microcontroller/ports/esp32/main/include/cmd.h

@@ -16,6 +16,8 @@ typedef enum {
     BS_CMD_RESULT_EXECTIME,
     BS_CMD_RESULT_PROFILE,
 
+    BS_CMD_CALL_EVENT,
+
     // Sentinel
     BS_CMD_END
 } bs_cmd_t;

microcontroller/ports/esp32/main/include/shell.h

@@ -5,6 +5,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define PORT_TEXT_SECTION __attribute__((section(".port_text")))
+
 /**
  * Set data.
  */
@@ -17,6 +19,20 @@ void bs_shell_receptionist(uint8_t *task_data, int data_len);
 void bs_shell_register_sender(void (* sender)(uint8_t*, uint32_t));
 
 
+
+
+/**
+ * Push a callback function event to the event queue.
+ */
+void PORT_TEXT_SECTION bs_event_push(void *callback);
+
+
+/**
+ * Push a callback function event to the event queue from isr.
+ */
+void PORT_TEXT_SECTION bs_event_push_from_isr(void *callback);
+
+
 /**
  * A task for execute code.
  * It pops an entry-point from the execution queue and jupts to it.

microcontroller/ports/esp32/main/logger.c

@@ -2,6 +2,8 @@
 #include "esp_log.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
+#include "freertos/semphr.h"
+#include "esp_timer.h"
 
 #include "include/logger.h"
 #include "include/cmd.h"

microcontroller/ports/esp32/main/main.c

@@ -15,7 +15,7 @@ void app_main(void) {
     bs_logger_register_sender(bs_ble_send_notification);
     bs_shell_register_sender(bs_ble_send_notification);
 
-    xTaskCreatePinnedToCore(bs_shell_task, "bs_shell_task", 4096 * 16, NULL, 1, NULL, 0);
+    xTaskCreatePinnedToCore(bs_shell_task, "bs_shell_task", 4096 * 16, NULL, 5, NULL, 0);
     xTaskCreatePinnedToCore(bs_logger_task, "bs_logger_task", 4096, NULL, 1, NULL, 0);
-    xTaskCreatePinnedToCore(bs_event_handler_task, "bs_event_handler_task", 4096, NULL, 1, NULL, 0);
+    // xTaskCreatePinnedToCore(bs_event_handler_task, "bs_event_handler_task", 4096, NULL, 5, NULL, 0);
 }

microcontroller/ports/esp32/main/shell.c

@@ -21,8 +21,14 @@ typedef union {
 
     struct task_jump {
         bs_cmd_t cmd;
+        int32_t id;
         uint32_t to;
     } jump;
+
+    struct task_event_call {
+        bs_cmd_t cmd;
+        value_t fn;
+    } event_call;
 } task_item_u;
 
 static QueueHandle_t task_queue;
@@ -37,21 +43,25 @@ uint32_t *dram;
 size_t    dram_size;
 
 // variables for flash partition
-#define TEXT_PARTITION_LABEL "text"
-static esp_partition_t *text_partition = NULL;
-static uint8_t *virtual_flash_ptr = NULL;
-static esp_partition_mmap_handle_t virtual_flash_hdlr;
+#define IFLASH_PARTITION_LABEL "iflash"
+#define DFLASH_PARTITION_LABEL "dflash"
+static esp_partition_t *iflash_partition = NULL;
+static esp_partition_t *dflash_partition = NULL;
+static uint8_t *virtual_iflash_ptr = NULL;
+static uint8_t *virtual_dflash_ptr = NULL;
+static esp_partition_mmap_handle_t virtual_iflash_hdlr;
+static esp_partition_mmap_handle_t virtual_dflash_hdlr;
 
 
 // RAM
 
 static void ram_init() {
     iram_size = heap_caps_get_largest_free_block(MALLOC_CAP_EXEC | MALLOC_CAP_32BIT) - 4;
     iram = heap_caps_malloc(iram_size, MALLOC_CAP_EXEC | MALLOC_CAP_32BIT);
-    dram_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
+    dram_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT) / 2;
     dram = heap_caps_malloc(dram_size, MALLOC_CAP_8BIT);
-    ESP_LOGI(BS_SHELL_TAG, "IRAM Size: %d\n", iram_size);
-    ESP_LOGI(BS_SHELL_TAG, "DRAM Size: %d\n", dram_size);
+    ESP_LOGI(BS_SHELL_TAG, "IRAM Address: %p Size: %d\n", iram, (int)iram_size);
+    ESP_LOGI(BS_SHELL_TAG, "DRAM Address: %p Size: %d\n", dram, (int)dram_size);
 }
 
 static void ram_reset() {
@@ -65,33 +75,48 @@ static void ram_memcpy(uint8_t* ram_dest, uint8_t *src, size_t len) {
 
 
 // Flash
+static void dflash_memcpy(uint8_t* dest, uint8_t *src, size_t len);
 
 static void flash_init() {
-    text_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, TEXT_PARTITION_LABEL);
-    ESP_ERROR_CHECK(esp_partition_erase_range(text_partition, 0, text_partition->size));
-    esp_partition_mmap(text_partition, 0, text_partition->size, ESP_PARTITION_MMAP_INST, &virtual_flash_ptr, &virtual_flash_hdlr);
+    iflash_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, IFLASH_PARTITION_LABEL);
+    dflash_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, DFLASH_PARTITION_LABEL);
+    esp_partition_mmap(iflash_partition, 0, iflash_partition->size, ESP_PARTITION_MMAP_INST, &virtual_iflash_ptr, &virtual_iflash_hdlr);
+    esp_partition_mmap(dflash_partition, 0, dflash_partition->size, ESP_PARTITION_MMAP_DATA, &virtual_dflash_ptr, &virtual_dflash_hdlr);
+    ESP_LOGI(BS_SHELL_TAG, "IFlash Address: 0x%x VAddress: %p Size: %d\n", (int)iflash_partition->address, virtual_iflash_ptr, (int)iflash_partition->size);
+    ESP_LOGI(BS_SHELL_TAG, "DFlash Address: 0x%x VAddress: %p Size: %d\n", (int)dflash_partition->address, virtual_dflash_ptr, (int)dflash_partition->size);
+}
+
+static uint32_t iflash_read_address() {
+    return (uint32_t)virtual_iflash_ptr;
 }
 
-static void flash_reset() {
-    ESP_ERROR_CHECK(esp_partition_erase_range(text_partition, 0, text_partition->size));
+static uint32_t dflash_read_address() {
+    return (uint32_t)virtual_dflash_ptr;
 }
 
-static uint32_t flash_read_address() {
-    return (uint32_t)virtual_flash_ptr;
+static uint32_t iflash_read_size() {
+    return (uint32_t)iflash_partition->size;
 }
 
-static uint32_t flash_read_size() {
-    return (uint32_t)text_partition->size;
+static uint32_t dflash_read_size() {
+    return (uint32_t)dflash_partition->size;
 }
 
-static void flash_memcpy(uint8_t* flash_dest, uint8_t *src, size_t len) {
-    uint8_t* offset = flash_dest - virtual_flash_ptr;
-    ESP_ERROR_CHECK(esp_partition_write(text_partition, offset, src, len));
+static void iflash_memcpy(uint8_t* dest, uint8_t *src, size_t len) {
+    uint8_t* offset = dest - virtual_iflash_ptr;
+    ESP_ERROR_CHECK(esp_partition_write(iflash_partition, offset, src, len));
+}
+
+static void dflash_memcpy(uint8_t* dest, uint8_t *src, size_t len) {
+    uint8_t* offset = dest - virtual_dflash_ptr;
+    ESP_ERROR_CHECK(esp_partition_write(dflash_partition, offset, src, len));
 }
 
 static void bs_memcpy(uint8_t* dest, uint8_t *src, size_t len) {
-    if (virtual_flash_ptr <= dest && dest <= virtual_flash_ptr + flash_read_size()) {
-        flash_memcpy(dest, src, len);
+    if (virtual_iflash_ptr <= dest && dest <= virtual_iflash_ptr + iflash_read_size()) {
+        iflash_memcpy(dest, src, len);
+    } else if (virtual_dflash_ptr <= dest && dest <= virtual_dflash_ptr + dflash_read_size()) {
+        dflash_memcpy(dest, src, len);
     } else {
         ram_memcpy(dest, src, len);
     }
@@ -111,19 +136,20 @@ void bs_shell_receptionist(uint8_t *task_data, int data_len) {
         {
             uint32_t address = *(uint32_t*)(task_data + (idx+1));
             uint32_t size = *(uint32_t*)(task_data + (idx+5));
-            ESP_LOGI(BS_SHELL_TAG, "Load %d bytes to %x", (int)size, (int)address);
+            ESP_LOGI(BS_SHELL_TAG, "Load %d bytes to %x, time: %d", (int)size, (int)address, (int)esp_timer_get_time());
             bs_memcpy(address, task_data + (idx+9), size);
             idx += (9 + size);
             break;
         }
         case BS_CMD_JUMP:
-        // | cmd(1byte) | address(4byte) |
+        // | cmd(1byte) | id(4byte) | address(4byte) |
         {
             task_item_u task;
             task.jump.cmd = BS_CMD_JUMP;
-            task.jump.to = *(uint32_t*)(task_data + (idx+1));
+            task.jump.id = *(uint32_t*)(task_data + (idx+1));
+            task.jump.to = *(uint32_t*)(task_data + (idx+5));
             xQueueSend(task_queue, &task, portMAX_DELAY);
-            idx += 5;
+            idx += 9;
             break;
         }
         case BS_CMD_RESET:
@@ -163,36 +189,71 @@ static void send_result_meminfo() {
     *(uint32_t*)(result+ 5) = iram_size;
     *(uint32_t*)(result+ 9) = dram;
     *(uint32_t*)(result+13) = dram_size;
-    *(uint32_t*)(result+17) = flash_read_address();
-    *(uint32_t*)(result+21) = flash_read_size();
-    result_sender(result, 25);
+    *(uint32_t*)(result+17) = iflash_read_address();
+    *(uint32_t*)(result+21) = iflash_read_size();
+    *(uint32_t*)(result+25) = dflash_read_address();
+    *(uint32_t*)(result+29) = dflash_read_size();
+    result_sender(result, 33);
 }
 
-static void send_result_exectime(float exectime) {
-    uint8_t result[5];
+static void send_result_exectime(int32_t id, float exectime) {
+    uint8_t result[9];
     result[0] = BS_CMD_RESULT_EXECTIME;
-    *(float*)(result+1) = exectime;
-    result_sender(result, 5);
+    *(int32_t*)(result+1) = id;
+    *(float*)(result+5) = exectime;
+    result_sender(result, 9);
+}
+
+void execute_installed_code() {
+    if (virtual_dflash_ptr[0] != 1) {
+        ESP_ERROR_CHECK(esp_partition_erase_range(iflash_partition, 0, iflash_partition->size));
+        ESP_ERROR_CHECK(esp_partition_erase_range(dflash_partition, 0, dflash_partition->size));
+    } else {
+        puts("I am execute_installed_code");
+        uint32_t length = *(uint32_t*)(virtual_dflash_ptr + 1);
+        bs_shell_receptionist(virtual_dflash_ptr + 5, length);
+    }
+}
+
+// Event
+void bs_event_push(void* event_fn) {
+    task_item_u task;
+    task.event_call.cmd = BS_CMD_CALL_EVENT;
+    task.event_call.fn = event_fn;
+    xQueueSend(task_queue, &task, portMAX_DELAY);
 }
 
 
+void bs_event_push_from_isr(void* event_fn) {
+    portBASE_TYPE yield = pdFALSE;
+    task_item_u task;
+    task.event_call.cmd = BS_CMD_CALL_EVENT;
+    task.event_call.fn = event_fn;
+    xQueueSendFromISR(task_queue, &task, &yield);
+}
+
 void bs_shell_task(void *arg) {
     task_item_u task_item;
     task_queue = xQueueCreate(TASK_QUEUE_LENGTH, sizeof(task_item_u));
     shell_init();
-    shell_reset();
+    // shell_reset();
+    execute_installed_code();
 
     while (true) {
         xQueueReceive(task_queue, &task_item, portMAX_DELAY);
 
         switch (task_item.cmd) {
             case BS_CMD_JUMP:
-                ESP_LOGI(BS_SHELL_TAG, "Jump to %x", (int)task_item.jump.to);
+                ESP_LOGI(BS_SHELL_TAG, "Jump to %x, id: %d", (int)task_item.jump.to, (int)task_item.jump.id);
                 uint32_t start_us = esp_timer_get_time();
                 try_and_catch((void *)task_item.jump.to);
                 uint32_t end_us = esp_timer_get_time();
                 float exectime = (float)(end_us - start_us) / 1000.0;
-                send_result_exectime(exectime);
+                send_result_exectime(task_item.jump.id, exectime);
+                break;
+            case BS_CMD_CALL_EVENT:
+                ESP_LOGI(BS_SHELL_TAG, "CALL_EVENT");
+                ((void (*)(value_t))gc_function_object_ptr(task_item.event_call.fn, 0))(get_obj_property(task_item.event_call.fn, 2));
                 break;
             case BS_CMD_RESET:
                 ESP_LOGI(BS_SHELL_TAG, "Soft reset");

microcontroller/ports/esp32/partitions.csv

@@ -1,4 +1,5 @@
 nvs,        data, nvs,      0x9000,  0x6000,
 phy_init,   data, phy,      0xf000,  0x1000,
 factory,    app,  factory,  0x10000, 1M,
-text,       data, ,         ,        1M,
+iflash,     data, ,         ,        500K,
+dflash,     data, ,         ,        500K,

modules/button/CMakeLists.txt

@@ -0,0 +1,7 @@
+idf_component_register(SRCS "button.c"
+                    INCLUDE_DIRS "."
+                    REQUIRES core driver main
+                    # WHOLE_ARCHIVE
+                    )
+
+target_compile_options(${COMPONENT_LIB} PRIVATE -mtext-section-literals)