release pika_hal

package/PikaStdDevice/pika_hal.c

@@ -26,6 +26,7 @@ static size_t _pika_hal_dev_config_size(PIKA_HAL_DEV_TYPE dev_type) {
 }
 
 pika_dev* pika_hal_open(PIKA_HAL_DEV_TYPE dev_type, char* name) {
+    pika_dev_impl* impl = NULL;
     if (NULL == name) {
         __platform_printf("Error: dev_open name is NULL.\r\n");
         return NULL;
@@ -36,7 +37,7 @@ pika_dev* pika_hal_open(PIKA_HAL_DEV_TYPE dev_type, char* name) {
         __platform_printf("Error: dev_type invalied.\r\n");
         goto __exit;
     }
-    pika_dev_impl* impl = _pika_dev_get_impl(dev_type);
+    impl = _pika_dev_get_impl(dev_type);
     dev = (pika_dev*)pikaMalloc(sizeof(pika_dev));
     if (dev == NULL) {
         goto __exit;
@@ -67,10 +68,11 @@ __exit:
 
 int pika_hal_close(pika_dev* dev) {
     int ret = -1;
+    pika_dev_impl* impl = NULL;
     if (dev == NULL) {
         goto __exit;
     }
-    pika_dev_impl* impl = _pika_dev_get_impl(dev->type);
+    impl = _pika_dev_get_impl(dev->type);
     if (impl->close == NULL) {
         goto __exit;
     }
@@ -378,3 +380,116 @@ int pika_hal_CAM_ioctl_merge_config(pika_hal_CAM_config* dst,
     _IOCTL_CONFIG_USE_DEFAULT(buff_len, 320 * 240 * 16);
     return 0;
 }
+
+pika_hal_CircularQueue* pika_hal_circularQueue_create(size_t capacity) {
+    pika_hal_CircularQueue* cb =
+        (pika_hal_CircularQueue*)pikaMalloc(sizeof(pika_hal_CircularQueue));
+    if (NULL == cb) {
+        return NULL;
+    }
+    cb->head = 0;
+    cb->tail = 0;
+    cb->count = 0;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_init(&cb->mutex);
+#endif
+    cb->capacity = capacity;
+    cb->buffer = (uint8_t*)pikaMalloc(capacity);
+    if (NULL == cb->buffer) {
+        pikaFree(cb, sizeof(pika_hal_CircularQueue));
+        return NULL;
+    }
+    return cb;
+}
+
+int pika_hal_circularQueue_enqueue(pika_hal_CircularQueue* cb, uint8_t ch) {
+    int ret = 0;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_lock(&cb->mutex);
+#endif
+    if (cb->count == cb->capacity) {
+        ret = -1;
+        goto __exit;
+    }
+
+    cb->buffer[cb->tail] = ch;
+    cb->tail = (cb->tail + 1) % cb->capacity;
+    cb->count++;
+__exit:
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_unlock(&cb->mutex);
+#endif
+    return ret;
+}
+
+int pika_hal_circularQueue_dequeue(pika_hal_CircularQueue* cb, uint8_t* value) {
+    int ret = 0;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_lock(&cb->mutex);
+#endif
+    if (cb->count == 0) {
+        ret = -1;
+        goto __exit;
+    }
+
+    *value = cb->buffer[cb->head];
+    cb->head = (cb->head + 1) % cb->capacity;
+    cb->count--;
+__exit:
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_unlock(&cb->mutex);
+#endif
+    return ret;
+}
+
+int pika_hal_circularQueue_deinit(pika_hal_CircularQueue* cb) {
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_lock(&cb->mutex);
+#endif
+    pikaFree(cb->buffer, cb->capacity);
+    cb->buffer = NULL;
+    cb->head = 0;
+    cb->tail = 0;
+    cb->count = 0;
+    cb->capacity = 0;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_destroy(&cb->mutex);
+#endif
+    pikaFree(cb, sizeof(pika_hal_CircularQueue));
+    return 0;
+}
+
+size_t pika_hal_circularQueue_getCount(pika_hal_CircularQueue* cb) {
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_lock(&cb->mutex);
+#endif
+    size_t count = cb->count;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_unlock(&cb->mutex);
+#endif
+    return count;
+}
+
+int pika_hal_circularQueue_isEmpty(pika_hal_CircularQueue* cb) {
+    return cb->count == 0;
+}
+
+int pika_hal_circularQueue_isFull(pika_hal_CircularQueue* cb) {
+    return cb->count == cb->capacity;
+}
+
+int pika_hal_circularQueue_peek(pika_hal_CircularQueue* cb, uint8_t* value) {
+    if (cb->count == 0) {
+        return -1;
+    }
+
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_lock(&cb->mutex);
+#endif
+    *value = cb->buffer[cb->head];
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_unlock(&cb->mutex);
+#endif
+
+    return 0;
+}

package/PikaStdDevice/pika_hal.h

@@ -10,6 +10,9 @@
  */
 
 #define PIKA_HAL
+#ifndef PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+#define PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE 0
+#endif
 
 #define PIKA_HAL_OBJ2DEV(_self) obj_getPtr((_self), "pika_dev")
 
@@ -630,4 +633,24 @@ typedef struct pika_dev_impl {
 #define PIKA_HAL_TABLE_IOCTL_MERGE_CONFIG_HEADER
 #include "pika_hal_table.h"
 
+typedef struct {
+    uint8_t* buffer;
+    size_t capacity;
+    size_t head;
+    size_t tail;
+    size_t count;
+#if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE
+    pika_platform_thread_mutex_t mutex;
+#endif
+} pika_hal_CircularQueue;
+
+pika_hal_CircularQueue* pika_hal_circularQueue_create(size_t capacity);
+int pika_hal_circularQueue_enqueue(pika_hal_CircularQueue* cb, uint8_t ch);
+int pika_hal_circularQueue_dequeue(pika_hal_CircularQueue* cb, uint8_t* value);
+int pika_hal_circularQueue_deinit(pika_hal_CircularQueue* cb);
+size_t pika_hal_circularQueue_getCount(pika_hal_CircularQueue* cb);
+int pika_hal_circularQueue_isEmpty(pika_hal_CircularQueue* cb);
+int pika_hal_circularQueue_isFull(pika_hal_CircularQueue* cb);
+int pika_hal_circularQueue_peek(pika_hal_CircularQueue* cb, uint8_t* value);
+
 #endif

package/PikaStdDevice/pika_hal_utils.h

@@ -59,4 +59,5 @@ int pika_hal_utils_WIFI_config(pika_dev* dev, pika_hal_WIFI_config* cfg);
 /* SG utils */
 int pika_hal_utils_SG_config(pika_dev* dev, pika_hal_SG_config* cfg);
 pika_float pika_hal_utils_SG_read(pika_dev* dev);
+
 #endif

port/linux/config/pika_config_default.h

@@ -9,4 +9,5 @@
 #define PIKA_GC_MARK_SWEEP_ENABLE 1
 #define PIKA_GC_MARK_SWEEP_THRESHOLD 1
 #define PIKA_KERNAL_DEBUG_ENABLE 1
-#define PIKA_UNBUFFERED_ENABLE 1
+#define PIKA_UNBUFFERED_ENABLE 1
+#define PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE 1

port/linux/package/pikascript/pikascript-lib/PikaStdDevice/pika_hal.c

@@ -480,7 +480,7 @@ int pika_hal_circularQueue_isFull(pika_hal_CircularQueue* cb) {
 
 int pika_hal_circularQueue_peek(pika_hal_CircularQueue* cb, uint8_t* value) {
     if (cb->count == 0) {
-        return -1;  // »º³åÇøΪ¿Õ
+        return -1;
     }
 
 #if PIKA_HAL_CIRCULAR_QUEUE_MUTEX_ENABLE

port/linux/test/hal-test.cpp

@@ -3,4 +3,80 @@
 TEST(hal, open) {
     pika_dev* io = pika_hal_open(PIKA_HAL_GPIO, "PA10");
     pika_hal_close(io);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_init) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_enqueue_dequeue) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    pika_hal_circularQueue_enqueue(cq, 1);
+    pika_hal_circularQueue_enqueue(cq, 2);
+    pika_hal_circularQueue_enqueue(cq, 3);
+    uint8_t recv = 0;
+    pika_hal_circularQueue_dequeue(cq, &recv);
+    EXPECT_EQ(recv, 1);
+    pika_hal_circularQueue_dequeue(cq, &recv);
+    EXPECT_EQ(recv, 2);
+    pika_hal_circularQueue_dequeue(cq, &recv);
+    EXPECT_EQ(recv, 3);
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_enqueue_overflow) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    for (int i = 0; i < 10; i++) {
+        pika_hal_circularQueue_enqueue(cq, i);
+    }
+    EXPECT_EQ(pika_hal_circularQueue_enqueue(cq, 10), -1);
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_dequeue_empty) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    uint8_t recv = 0;
+    EXPECT_EQ(pika_hal_circularQueue_dequeue(cq, &recv), -1);
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_enqueue_dequeue_wrap) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    for (int i = 0; i < 10; i++) {
+        pika_hal_circularQueue_enqueue(cq, i);
+    }
+    uint8_t recv = 0;
+    for (int i = 0; i < 10; i++) {
+        pika_hal_circularQueue_dequeue(cq, &recv);
+        EXPECT_EQ(recv, i);
+    }
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
+TEST(hal, cq_enqueue_dequeue_wrap2) {
+    pika_hal_CircularQueue* cq = pika_hal_circularQueue_create(10);
+    for (int i = 0; i < 10; i++) {
+        pika_hal_circularQueue_enqueue(cq, i);
+    }
+    uint8_t recv = 0;
+    for (int i = 0; i < 5; i++) {
+        pika_hal_circularQueue_dequeue(cq, &recv);
+        EXPECT_EQ(recv, i);
+    }
+    for (int i = 10; i < 15; i++) {
+        pika_hal_circularQueue_enqueue(cq, i);
+    }
+    for (int i = 5; i < 15; i++) {
+        pika_hal_circularQueue_dequeue(cq, &recv);
+        EXPECT_EQ(recv, i);
+    }
+    pika_hal_circularQueue_deinit(cq);
+    EXPECT_EQ(pikaMemNow(), 0);
 }

src/PikaVersion.h

@@ -2,4 +2,4 @@
 #define PIKA_VERSION_MINOR 13
 #define PIKA_VERSION_MICRO 1
 
-#define PIKA_EDIT_TIME "2023/12/17 20:24:48"
+#define PIKA_EDIT_TIME "2023/12/17 23:09:50"