initial

SOFTWARE-FreeRTOS/Source/DTH11.cpp

@@ -0,0 +1,70 @@
+#include "DTH11.hpp"
+
+typedef struct {
+    float humidity;
+    float temp_celsius;
+} dht_reading;
+
+void read_from_dht(dht_reading * result, int DHT_PIN)
+{
+    int data[5] = { 0, 0, 0, 0, 0 };
+    uint last = 1;
+    uint j = 0;
+
+    gpio_set_dir(DHT_PIN, GPIO_OUT);
+    gpio_put(DHT_PIN, 0);
+    sleep_ms(20);
+    gpio_set_dir(DHT_PIN, GPIO_IN);
+
+    for (uint i = 0; i < MAX_TIMINGS; i++) {
+        uint count = 0;
+        while (gpio_get(DHT_PIN) == last) {
+            count++;
+            sleep_us(1);
+            if (count == 255)
+                break;
+        }
+
+        last = gpio_get(DHT_PIN);
+        if (count == 255)
+            break;
+
+        if ((i >= 4) && (i % 2 == 0)) {
+            data[j / 8] <<= 1;
+            if (count > 16)
+                data[j / 8] |= 1;
+            j++;
+        }
+    }
+
+    if ((j >= 40) && (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF))) {
+        result->humidity = (float)((data[0] << 8) + data[1]) / 10;
+        if (result->humidity > 100) {
+            result->humidity = data[0];
+        }
+        result->temp_celsius = (float)(((data[2] & 0x7F) << 8) + data[3]) / 10;
+        if (result->temp_celsius > 125) {
+            result->temp_celsius = data[2];
+        }
+        if (data[2] & 0x80) {
+            result->temp_celsius = -result->temp_celsius;
+        }
+    } else {
+        printf("Bad data\n");
+    }
+}
+
+int DTH11_(int DHT_PIN)
+{
+    stdio_init_all();
+    gpio_init(DHT_PIN);
+
+    dht_reading reading;
+    read_from_dht(&reading, DHT_PIN);
+    float fahrenheit = (reading.temp_celsius * 9 / 5) + 32;
+    printf("Humidity = %.1f%%, Temperature = %.1fC (%.1fF)\n", reading.humidity, reading.temp_celsius, fahrenheit);
+
+    sleep_ms(2000);
+
+    return 0;
+}

SOFTWARE-FreeRTOS/Source/DTH11.hpp

@@ -0,0 +1,11 @@
+#ifndef DTH11_H
+#define DTH11_H
+
+#include <stdio.h>
+#include <math.h>
+#include "pico/stdlib.h"
+#include "hardware/gpio.h"
+
+const uint MAX_TIMINGS = 85;
+
+#endif

SOFTWARE-FreeRTOS/Source/FreeRTOSConfig.h

@@ -0,0 +1,137 @@
+/*
+ * FreeRTOS V202212.00
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+/*-----------------------------------------------------------
+ * Application specific definitions.
+ *
+ * These definitions should be adjusted for your particular hardware and
+ * application requirements.
+ *
+ * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
+ * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
+ *
+ * See http://www.freertos.org/a00110.html
+ *----------------------------------------------------------*/
+
+/* Scheduler Related */
+#define configUSE_PREEMPTION                    1
+#define configUSE_TICKLESS_IDLE                 0
+#define configUSE_IDLE_HOOK                     0
+#define configUSE_TICK_HOOK                     1
+#define configTICK_RATE_HZ                      ( ( TickType_t ) 1000 )
+#define configMAX_PRIORITIES                    32
+#define configMINIMAL_STACK_SIZE                ( configSTACK_DEPTH_TYPE ) 256
+#define configUSE_16_BIT_TICKS                  0
+
+#define configIDLE_SHOULD_YIELD                 1
+
+/* Synchronization Related */
+#define configUSE_MUTEXES                       1
+#define configUSE_RECURSIVE_MUTEXES             1
+#define configUSE_APPLICATION_TASK_TAG          0
+#define configUSE_COUNTING_SEMAPHORES           1
+#define configQUEUE_REGISTRY_SIZE               8
+#define configUSE_QUEUE_SETS                    1
+#define configUSE_TIME_SLICING                  1
+#define configUSE_NEWLIB_REENTRANT              0
+#define configENABLE_BACKWARD_COMPATIBILITY     0
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5
+
+/* System */
+#define configSTACK_DEPTH_TYPE                  uint32_t
+#define configMESSAGE_BUFFER_LENGTH_TYPE        size_t
+
+/* Memory allocation related definitions. */
+#define configSUPPORT_STATIC_ALLOCATION         0
+#define configSUPPORT_DYNAMIC_ALLOCATION        1
+#define configTOTAL_HEAP_SIZE                   (128*1024)
+#define configAPPLICATION_ALLOCATED_HEAP        0
+
+/* Hook function related definitions. */
+#define configCHECK_FOR_STACK_OVERFLOW          2
+#define configUSE_MALLOC_FAILED_HOOK            1
+#define configUSE_DAEMON_TASK_STARTUP_HOOK      0
+
+/* Run time and task stats gathering related definitions. */
+#define configGENERATE_RUN_TIME_STATS           0
+#define configUSE_TRACE_FACILITY                1
+#define configUSE_STATS_FORMATTING_FUNCTIONS    0
+
+/* Co-routine related definitions. */
+#define configUSE_CO_ROUTINES                   0
+#define configMAX_CO_ROUTINE_PRIORITIES         1
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS                        1
+#define configTIMER_TASK_PRIORITY               ( configMAX_PRIORITIES - 1 )
+#define configTIMER_QUEUE_LENGTH                10
+#define configTIMER_TASK_STACK_DEPTH            1024
+
+/* Interrupt nesting behaviour configuration. */
+/*
+#define configKERNEL_INTERRUPT_PRIORITY         [dependent of processor]
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY    [dependent on processor and application]
+#define configMAX_API_CALL_INTERRUPT_PRIORITY   [dependent on processor and application]
+*/
+
+/* SMP port only */
+#define configNUMBER_OF_CORES                   1
+#define configTICK_CORE                         0
+#define configRUN_MULTIPLE_PRIORITIES           0
+
+/* RP2040 specific */
+#define configSUPPORT_PICO_SYNC_INTEROP         1
+#define configSUPPORT_PICO_TIME_INTEROP         1
+
+#include <assert.h>
+/* Define to trap errors during development. */
+#define configASSERT(x)                         assert(x)
+
+/* Set the following definitions to 1 to include the API function, or zero
+to exclude the API function. */
+#define INCLUDE_vTaskPrioritySet                1
+#define INCLUDE_uxTaskPriorityGet               1
+#define INCLUDE_vTaskDelete                     1
+#define INCLUDE_vTaskSuspend                    1
+#define INCLUDE_vTaskDelayUntil                 1
+#define INCLUDE_vTaskDelay                      1
+#define INCLUDE_xTaskGetSchedulerState          1
+#define INCLUDE_xTaskGetCurrentTaskHandle       1
+#define INCLUDE_uxTaskGetStackHighWaterMark     1
+#define INCLUDE_xTaskGetIdleTaskHandle          1
+#define INCLUDE_eTaskGetState                   1
+#define INCLUDE_xTimerPendFunctionCall          1
+#define INCLUDE_xTaskAbortDelay                 1
+#define INCLUDE_xTaskGetHandle                  1
+#define INCLUDE_xTaskResumeFromISR              1
+#define INCLUDE_xQueueGetMutexHolder            1
+
+/* A header file that defines trace macro can be included here. */
+
+#endif /* FREERTOS_CONFIG_H */

SOFTWARE-FreeRTOS/Source/HC-12.cpp

@@ -0,0 +1,20 @@
+#include "HC-12.hpp"
+
+void _HC_12_INIT()
+{
+    uint tx_offset = pio_add_program(pio1, &uart_tx_program);
+    uart_tx_program_init(HC_12_PIO, HC_12_PIO_SM_TX, tx_offset, HC_12_PIO_TX_PIN, HC_12_PIO_SERIAL_BAUD);
+
+    uint rx_offset = pio_add_program(pio1, &uart_rx_program);
+    uart_rx_program_init(HC_12_PIO, HC_12_PIO_SM_RX, rx_offset, HC_12_PIO_RX_PIN, HC_12_PIO_SERIAL_BAUD);
+
+    return;
+}
+
+void _HC_12(const char *string)
+{
+    uart_tx_program_puts(HC_12_PIO, HC_12_PIO_SM_TX, string);
+    sleep_ms(100);
+
+    return;
+}

SOFTWARE-FreeRTOS/Source/HC-12.hpp

@@ -0,0 +1,19 @@
+#ifndef HC_12_H
+#define HC_12_H
+
+#include "pico/stdlib.h"
+#include "hardware/pio.h"
+#include "uart_tx.pio.h"
+#include "uart_rx.pio.h"
+
+#define HC_12_PIO pio1
+#define HC_12_PIO_TX_PIN 16 	// 接 HC-12 RX
+#define HC_12_PIO_RX_PIN 15		// 接 HC-12 TX
+#define HC_12_PIO_SM_TX 0
+#define HC_12_PIO_SM_RX 1
+#define HC_12_PIO_SERIAL_BAUD 9600
+
+extern void _HC_12_INIT();
+extern void _HC_12(const char *string);
+
+#endif

SOFTWARE-FreeRTOS/Source/ZC13.cpp

@@ -0,0 +1,171 @@
+#include "ZC13.hpp"
+#include "common.h"
+
+int ZC13_INIT()
+{
+    uint tx_offset = pio_add_program(ZC13_PIO, &uart_tx_program);
+    uart_tx_program_init(ZC13_PIO, ZC13_PIO_SM_TX, tx_offset, ZC13_PIO_TX_PIN, ZC13_PIO_SERIAL_BAUD);
+
+    uint rx_offset = pio_add_program(ZC13_PIO, &uart_rx_program);
+    uart_rx_program_init(ZC13_PIO, ZC13_PIO_SM_RX, rx_offset, ZC13_PIO_RX_PIN, ZC13_PIO_SERIAL_BAUD);
+
+    return 0;
+}
+
+int ZC13_PIO_UART_TX_DATA(PIO pio, uint sm, uint8_t *DATA, int DATA_LEN) {
+	
+	for (int i = 0; i < DATA_LEN; i++) {
+        uart_tx_program_putc(pio, sm, DATA[i]);
+        sleep_ms(3);
+    }
+	
+	return 0;
+}
+
+int ZC13_PIO_UART_RX_DATA(PIO pio, uint sm, uint8_t *DATA, int DATA_LEN) {
+    char c = '\0';
+    int received_count = 0;
+    int timeout_ms = 100;  // 设置较长的超时时间
+
+    while (received_count < DATA_LEN && timeout_ms > 0) {
+        if (uart_rx_program_available(pio, sm)) {
+            c = uart_rx_program_getc(pio, sm);
+            DATA[received_count++] = c;
+			printf("0x%X ", c);
+            if (c == '\n') {
+                // 接收到换行符，停止接收数据
+                break;
+            }
+        } else {
+            // 没有接收到数据，继续等待
+            sleep_ms(1);
+            timeout_ms--;
+        }
+    }
+
+    if (received_count == 0) {
+        // 没有接收到有效数据，可以进行相应的处理
+        return -1;
+    }
+
+    return received_count;
+}
+
+int ZC13(const char *model)
+{
+    uint8_t CH4_DATA[270] = { 0 };
+    int CH4_DATA_LEN = 0;
+
+    // 发送指令
+    uint8_t CH4_CMD[9] = { 0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79 };
+	ZC13_PIO_UART_TX_DATA(ZC13_PIO, ZC13_PIO_SM_TX, CH4_CMD, sizeof(CH4_CMD));
+    sleep_ms(200);
+	
+	// 接收指令
+	CH4_DATA_LEN = ZC13_PIO_UART_RX_DATA(ZC13_PIO, ZC13_PIO_SM_RX, CH4_DATA, 9);
+
+
+    printf("\n");
+	printf("%d\n", CH4_DATA_LEN);
+
+    uint8_t highByte = CH4_DATA[2]; // 假设这是气体浓度高位字节
+    uint8_t lowByte = CH4_DATA[3]; // 假设这是气体浓度高位字节
+
+    // 判断最高位是否为 1
+    if (highByte & 0x80) {
+        // 最高位是 1，表示传感器故障
+        printf("CH4 sensor malfunction!\n");
+    } else {
+        if (CH4_DATA[1] == 0X86) {
+			if ( 0 == strcasecmp(model, "ZC05")) {
+				// 计算气体浓度值
+				uint16_t gasConcentration = (highByte & 0x3F) * 256 + lowByte;
+				// 输出气体浓度值
+				printf("CH4 Concentration: %uppm\n", gasConcentration);
+			
+				return gasConcentration;
+			}
+			
+			if ( 0 == strcasecmp(model, "ZC13")) {
+				// 计算气体浓度值
+				uint16_t gasConcentration = (highByte & 0x1F) * 256 + lowByte;
+				// 输出气体浓度值
+				printf("CH4 Concentration: %uppm\n", gasConcentration);
+			
+				return gasConcentration;
+			}
+        }
+    }
+	
+    return -1;
+}
+
+/*
+int ZC13(const char *model)
+{
+    char CH4_DATA[9] = { 0 };
+    int CH4_DATA_index = 0;
+
+    // 发送指令
+    char CH4_CMD[9] = { 0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79 };
+    for (int i = 0; i < 9; i++) {
+        uart_tx_program_putc(ZC13_PIO, ZC13_PIO_SM_TX, CH4_CMD[i]);
+        sleep_ms(1);
+    }
+    sleep_ms(200);
+
+    // 接收数据，直到收到换行符或达到缓冲区大小限制
+    char c = '\0';
+    int timeout_ms = 100;       // 设置超时时间为100ms
+    int received_count = 0;
+
+    while (received_count < 9 && timeout_ms > 0) {
+        if (uart_rx_program_available(ZC13_PIO, ZC13_PIO_SM_RX)) {
+            c = uart_rx_program_getc(ZC13_PIO, ZC13_PIO_SM_RX);
+            CH4_DATA[CH4_DATA_index++] = c;
+            received_count++;
+            timeout_ms = 100;   // 重置超时时间
+        } else {
+            sleep_ms(1);
+            timeout_ms--;       // 减少超时时间
+        }
+    }
+
+    // 处理接收到的数据
+    for (int i = 0; i < 9; i++) {
+        printf("0x%X ", CH4_DATA[i]);
+    }
+    printf("\n");
+
+    uint8_t highByte = CH4_DATA[2]; // 假设这是气体浓度高位字节
+    uint8_t lowByte = CH4_DATA[3]; // 假设这是气体浓度高位字节
+
+    // 判断最高位是否为 1
+    if (highByte & 0x80) {
+        // 最高位是 1，表示传感器故障
+        printf("CH4 sensor malfunction!\n");
+    } else {
+        if (CH4_DATA[1] == 0X86) {
+			if ( 0 == strcasecmp(model, "ZC05")) {
+				// 计算气体浓度值
+				uint16_t gasConcentration = (highByte & 0x3F) * 256 + lowByte;
+				// 输出气体浓度值
+				printf("CH4 Concentration: %uppm\n", gasConcentration);
+			
+				return gasConcentration;
+			}
+			
+			if ( 0 == strcasecmp(model, "ZC13")) {
+				// 计算气体浓度值
+				uint16_t gasConcentration = (highByte & 0x1F) * 256 + lowByte;
+				// 输出气体浓度值
+				printf("CH4 Concentration: %uppm\n", gasConcentration);
+			
+				return gasConcentration;
+			}
+        }
+    }
+	
+    return -1;
+}
+*/

SOFTWARE-FreeRTOS/Source/ZC13.hpp

@@ -0,0 +1,21 @@
+#ifndef ZC13_HPP
+#define ZC13_HPP
+
+#include <stdio.h>
+#include <strings.h>
+#include "pico/stdlib.h"
+#include "hardware/pio.h"
+#include "uart_tx.pio.h"
+#include "uart_rx.pio.h"		
+
+#define ZC13_PIO pio0
+#define ZC13_PIO_TX_PIN 19			// 接ZC13 4 TX PIN
+#define ZC13_PIO_RX_PIN 20			// 接ZC13 5 RX PIN
+#define ZC13_PIO_SM_TX 0
+#define ZC13_PIO_SM_RX 1
+#define ZC13_PIO_SERIAL_BAUD 9600
+
+extern int ZC13_INIT();
+extern int ZC13(const char *model);
+
+#endif

SOFTWARE-FreeRTOS/Source/common.c

@@ -0,0 +1,81 @@
+#include "common.h"
+
+void vApplicationMallocFailedHook(void)
+{
+    /* Called if a call to pvPortMalloc() fails because there is insufficient
+       free memory available in the FreeRTOS heap.  pvPortMalloc() is called
+       internally by FreeRTOS API functions that create tasks, queues, software
+       timers, and semaphores.  The size of the FreeRTOS heap is set by the
+       configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
+
+    /* Force an assert. */
+    configASSERT((volatile void *)NULL);
+}
+
+/*-----------------------------------------------------------*/
+
+void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName)
+{
+    (void)pcTaskName;
+    (void)pxTask;
+
+    /* Run time stack overflow checking is performed if
+       configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
+       function is called if a stack overflow is detected. */
+
+    /* Force an assert. */
+    configASSERT((volatile void *)NULL);
+}
+
+void vApplicationTickHook(void)
+{
+#if mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 0
+    {
+        /* The full demo includes a software timer demo/test that requires
+           prodding periodically from the tick interrupt. */
+        /*完整的演示包括软件定时器演示/测试，需要
+            从滴答声中断中周期性地发出提示*/
+#if (mainENABLE_TIMER_DEMO == 1)
+        vTimerPeriodicISRTests();
+#endif
+
+        /* Call the periodic queue overwrite from ISR demo. */
+        /*调用ISR演示中的周期性队列覆盖*/
+#if (mainENABLE_QUEUE_OVERWRITE == 1)
+        vQueueOverwritePeriodicISRDemo();
+#endif
+
+        /* Call the periodic event group from ISR demo. */
+        /*从ISR演示中调用定期事件组*/
+#if (mainENABLE_EVENT_GROUP == 1)
+        vPeriodicEventGroupsProcessing();
+#endif
+
+        /* Call the code that uses a mutex from an ISR. */
+        /*从ISR调用使用互斥的代码*/
+#if (mainENABLE_INTERRUPT_SEMAPHORE == 1)
+        vInterruptSemaphorePeriodicTest();
+#endif
+
+        /* Call the code that 'gives' a task notification from an ISR. */
+        /*调用从ISR“发出”任务通知的代码*/
+#if (mainENABLE_TASK_NOTIFY == 1)
+        xNotifyTaskFromISR();
+#endif
+    }
+#endif
+}
+
+
+void _printTaskStackHighWaterMark(void)
+{
+    TaskHandle_t currentTask = xTaskGetCurrentTaskHandle();
+    if (currentTask != NULL)
+    {
+        printf("TASK STACK HIGH WATER MARK: %ld\n", uxTaskGetStackHighWaterMark(currentTask));
+    }
+    else
+    {
+        printf("FAILED TO GET CURRENT TASK HANDLE.\n");
+    }
+}

SOFTWARE-FreeRTOS/Source/common.h

@@ -0,0 +1,22 @@
+#ifndef COMMOM_H
+#define COMMOM_H
+
+/* Scheduler include files. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+
+#include <stdio.h>
+#include "hardware/pio.h"
+
+
+#define BUILD(fmt...)  do { fprintf(stderr,"%s %s ",__DATE__,__TIME__); fprintf(stderr, ##fmt); } while(0)
+
+static inline bool uart_rx_program_available(PIO pio, uint sm)
+{
+    return !pio_sm_is_rx_fifo_empty(pio, sm);
+}
+
+extern void _printTaskStackHighWaterMark(void);
+
+#endif

SOFTWARE-FreeRTOS/Source/lwipopts.h

@@ -0,0 +1,10 @@
+#ifndef _LWIPOPTS_H
+#define _LWIPOPTS_H
+
+// Generally you would define your own explicit list of lwIP options
+// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html)
+//
+// This example uses a common include to avoid repetition
+#include "lwipopts_examples_common.h"
+
+#endif

SOFTWARE-FreeRTOS/Source/lwipopts_examples_common.h

@@ -0,0 +1,89 @@
+#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
+#define _LWIPOPTS_EXAMPLE_COMMONH_H
+
+// Common settings used in most of the pico_w examples
+// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
+
+// allow override in some examples
+#ifndef NO_SYS
+#define NO_SYS                      1
+#endif
+// allow override in some examples
+#ifndef LWIP_SOCKET
+#define LWIP_SOCKET                 0
+#endif
+#if PICO_CYW43_ARCH_POLL
+#define MEM_LIBC_MALLOC             1
+#else
+// MEM_LIBC_MALLOC is incompatible with non polling versions
+#define MEM_LIBC_MALLOC             0
+#endif
+#define MEM_ALIGNMENT               4
+#define MEM_SIZE                    4000
+#define MEMP_NUM_TCP_SEG            32
+#define MEMP_NUM_ARP_QUEUE          10
+#define PBUF_POOL_SIZE              24
+#define LWIP_ARP                    1
+#define LWIP_ETHERNET               1
+#define LWIP_ICMP                   1
+#define LWIP_RAW                    1
+#define TCP_WND                     (8 * TCP_MSS)
+#define TCP_MSS                     1460
+#define TCP_SND_BUF                 (8 * TCP_MSS)
+#define TCP_SND_QUEUELEN            ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
+#define LWIP_NETIF_STATUS_CALLBACK  1
+#define LWIP_NETIF_LINK_CALLBACK    1
+#define LWIP_NETIF_HOSTNAME         1
+#define LWIP_NETCONN                0
+#define MEM_STATS                   0
+#define SYS_STATS                   0
+#define MEMP_STATS                  0
+#define LINK_STATS                  0
+// #define ETH_PAD_SIZE                2
+#define LWIP_CHKSUM_ALGORITHM       3
+#define LWIP_DHCP                   1
+#define LWIP_IPV4                   1
+#define LWIP_TCP                    1
+#define LWIP_UDP                    1
+#define LWIP_DNS                    1
+#define LWIP_TCP_KEEPALIVE          1
+#define LWIP_NETIF_TX_SINGLE_PBUF   1
+#define DHCP_DOES_ARP_CHECK         0
+#define LWIP_DHCP_DOES_ACD_CHECK    0
+
+#ifndef NDEBUG
+#define LWIP_DEBUG                  1
+#define LWIP_STATS                  1
+#define LWIP_STATS_DISPLAY          1
+#endif
+
+#define ETHARP_DEBUG                LWIP_DBG_OFF
+#define NETIF_DEBUG                 LWIP_DBG_OFF
+#define PBUF_DEBUG                  LWIP_DBG_OFF
+#define API_LIB_DEBUG               LWIP_DBG_OFF
+#define API_MSG_DEBUG               LWIP_DBG_OFF
+#define SOCKETS_DEBUG               LWIP_DBG_OFF
+#define ICMP_DEBUG                  LWIP_DBG_OFF
+#define INET_DEBUG                  LWIP_DBG_OFF
+#define IP_DEBUG                    LWIP_DBG_OFF
+#define IP_REASS_DEBUG              LWIP_DBG_OFF
+#define RAW_DEBUG                   LWIP_DBG_OFF
+#define MEM_DEBUG                   LWIP_DBG_OFF
+#define MEMP_DEBUG                  LWIP_DBG_OFF
+#define SYS_DEBUG                   LWIP_DBG_OFF
+#define TCP_DEBUG                   LWIP_DBG_OFF
+#define TCP_INPUT_DEBUG             LWIP_DBG_OFF
+#define TCP_OUTPUT_DEBUG            LWIP_DBG_OFF
+#define TCP_RTO_DEBUG               LWIP_DBG_OFF
+#define TCP_CWND_DEBUG              LWIP_DBG_OFF
+#define TCP_WND_DEBUG               LWIP_DBG_OFF
+#define TCP_FR_DEBUG                LWIP_DBG_OFF
+#define TCP_QLEN_DEBUG              LWIP_DBG_OFF
+#define TCP_RST_DEBUG               LWIP_DBG_OFF
+#define UDP_DEBUG                   LWIP_DBG_OFF
+#define TCPIP_DEBUG                 LWIP_DBG_OFF
+#define PPP_DEBUG                   LWIP_DBG_OFF
+#define SLIP_DEBUG                  LWIP_DBG_OFF
+#define DHCP_DEBUG                  LWIP_DBG_OFF
+
+#endif /* __LWIPOPTS_H__ */

SOFTWARE-FreeRTOS/Source/main.c

@@ -0,0 +1,86 @@
+/* Scheduler include files. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+
+/* Standard demo includes. */
+#include "TimerDemo.h"
+#include "QueueOverwrite.h"
+#include "EventGroupsDemo.h"
+#include "IntSemTest.h"
+#include "TaskNotify.h"
+
+#include "MAIN.h"
+#include "lwipopts.h"
+#include "common.h"
+
+#ifndef PICO_DEFAULT_LED_PIN
+    #warning pio/hello_pio example requires a board with a regular LED
+    #define PICO_DEFAULT_LED_PIN 25
+#endif
+
+void Led_Blinky(void *pvParameters)
+{
+    (void)pvParameters;
+
+    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
+    gpio_init(LED_PIN);
+    gpio_set_dir(LED_PIN, GPIO_OUT);
+    
+    _printTaskStackHighWaterMark();
+
+    while (1) {
+        vTaskDelay(pdMS_TO_TICKS(500));
+        gpio_put(LED_PIN, 1);
+        
+        vTaskDelay(pdMS_TO_TICKS(500));
+        gpio_put(LED_PIN, 0);
+        
+        _printTaskStackHighWaterMark();
+    }
+}
+
+void Read_Onboard_Temperature(void *pvParameters)
+{
+    (void)pvParameters;
+
+    adc_init();
+    adc_set_temp_sensor_enabled(true);
+    adc_select_input(4);        // Input 4 is the onboard temperature sensor.
+    
+    //_printTaskStackHighWaterMark();
+
+    while (1) {
+        const float conversionFactor = 3.3f / (1 << 12);
+
+        float adc = (float)adc_read() * conversionFactor;
+        float tempC = 27.0f - (adc - 0.706f) / 0.001721f;
+
+        printf("Onboard temperature %.02f°C %.02f°F\n", tempC, (tempC * 9 / 5 + 32));
+        
+        //_printTaskStackHighWaterMark();
+        
+        vTaskDelay(pdMS_TO_TICKS(3000)); // 非阻塞延时
+    }
+}
+
+int main(void)
+{
+    stdio_init_all();
+    sleep_ms(1000);
+    //set_sys_clock_khz(250000, true);
+
+    BaseType_t xReturned;
+    TaskHandle_t Led_Blinky_xHandle = NULL;
+
+    // 板载LED闪烁
+    xReturned = xTaskCreate(Led_Blinky, "Blinky task", 512, NULL, tskIDLE_PRIORITY, &Led_Blinky_xHandle);
+    if (xReturned == errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY)
+    {
+        printf("Blinky Task Error!");
+    }
+
+    vTaskStartScheduler();
+
+    return 0;
+}

SOFTWARE-FreeRTOS/Source/main.h

@@ -0,0 +1,17 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <stdio.h>
+#include <string.h>
+#include "pico/stdlib.h"
+#include "hardware/gpio.h"
+#include "hardware/clocks.h"
+#include "hardware/watchdog.h"
+#include "pico/multicore.h"
+#include "hardware/i2c.h"
+#include "pico/binary_info.h"
+#include "hardware/uart.h"
+#include "hardware/pwm.h"
+#include "hardware/adc.h"
+
+#endif

SOFTWARE-FreeRTOS/Source/uart_rx.pio

@@ -0,0 +1,94 @@
+;
+; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+;
+; SPDX-License-Identifier: BSD-3-Clause
+;
+
+.program uart_rx_mini
+
+; Minimum viable 8n1 UART receiver. Wait for the start bit, then sample 8 bits
+; with the correct timing.
+; IN pin 0 is mapped to the GPIO used as UART RX.
+; Autopush must be enabled, with a threshold of 8.
+
+    wait 0 pin 0        ; Wait for start bit
+    set x, 7 [10]       ; Preload bit counter, delay until eye of first data bit
+bitloop:                ; Loop 8 times
+    in pins, 1          ; Sample data
+    jmp x-- bitloop [6] ; Each iteration is 8 cycles
+
+% c-sdk {
+#include "hardware/clocks.h"
+#include "hardware/gpio.h"
+
+static inline void uart_rx_mini_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) {
+    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
+    pio_gpio_init(pio, pin);
+    gpio_pull_up(pin);
+
+    pio_sm_config c = uart_rx_mini_program_get_default_config(offset);
+    sm_config_set_in_pins(&c, pin); // for WAIT, IN
+    // Shift to right, autopush enabled
+    sm_config_set_in_shift(&c, true, true, 8);
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
+    // SM transmits 1 bit per 8 execution cycles.
+    float div = (float)clock_get_hz(clk_sys) / (8 * baud);
+    sm_config_set_clkdiv(&c, div);
+    
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_set_enabled(pio, sm, true);
+}
+%}
+
+.program uart_rx
+
+; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and
+; break conditions more gracefully.
+; IN pin 0 and JMP pin are both mapped to the GPIO used as UART RX.
+
+start:
+    wait 0 pin 0        ; Stall until start bit is asserted
+    set x, 7    [10]    ; Preload bit counter, then delay until halfway through
+bitloop:                ; the first data bit (12 cycles incl wait, set).
+    in pins, 1          ; Shift data bit into ISR
+    jmp x-- bitloop [6] ; Loop 8 times, each loop iteration is 8 cycles
+    jmp pin good_stop   ; Check stop bit (should be high)
+
+    irq 4 rel           ; Either a framing error or a break. Set a sticky flag,
+    wait 1 pin 0        ; and wait for line to return to idle state.
+    jmp start           ; Don't push data if we didn't see good framing.
+
+good_stop:              ; No delay before returning to start; a little slack is
+    push                ; important in case the TX clock is slightly too fast.
+
+
+% c-sdk {
+static inline void uart_rx_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) {
+    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
+    pio_gpio_init(pio, pin);
+    gpio_pull_up(pin);
+
+    pio_sm_config c = uart_rx_program_get_default_config(offset);
+    sm_config_set_in_pins(&c, pin); // for WAIT, IN
+    sm_config_set_jmp_pin(&c, pin); // for JMP
+    // Shift to right, autopush disabled
+    sm_config_set_in_shift(&c, true, false, 32);
+    // Deeper FIFO as we're not doing any TX
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
+    // SM transmits 1 bit per 8 execution cycles.
+    float div = (float)clock_get_hz(clk_sys) / (8 * baud);
+    sm_config_set_clkdiv(&c, div);
+    
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_set_enabled(pio, sm, true);
+}
+
+static inline char uart_rx_program_getc(PIO pio, uint sm) {
+    // 8-bit read from the uppermost byte of the FIFO, as data is left-justified
+    io_rw_8 *rxfifo_shift = (io_rw_8*)&pio->rxf[sm] + 3;
+    while (pio_sm_is_rx_fifo_empty(pio, sm))
+        tight_loop_contents();
+    return (char)*rxfifo_shift;
+}
+
+%}

SOFTWARE-FreeRTOS/Source/uart_tx.pio

@@ -0,0 +1,61 @@
+;
+; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+;
+; SPDX-License-Identifier: BSD-3-Clause
+;
+
+.program uart_tx
+.side_set 1 opt
+
+; An 8n1 UART transmit program.
+; OUT pin 0 and side-set pin 0 are both mapped to UART TX pin.
+
+    pull       side 1 [7]  ; Assert stop bit, or stall with line in idle state
+    set x, 7   side 0 [7]  ; Preload bit counter, assert start bit for 8 clocks
+bitloop:                   ; This loop will run 8 times (8n1 UART)
+    out pins, 1            ; Shift 1 bit from OSR to the first OUT pin
+    jmp x-- bitloop   [6]  ; Each loop iteration is 8 cycles.
+
+
+% c-sdk {
+#include "hardware/clocks.h"
+
+static inline void uart_tx_program_init(PIO pio, uint sm, uint offset, uint pin_tx, uint baud) {
+    // Tell PIO to initially drive output-high on the selected pin, then map PIO
+    // onto that pin with the IO muxes.
+    pio_sm_set_pins_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_sm_set_pindirs_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_gpio_init(pio, pin_tx);
+
+    pio_sm_config c = uart_tx_program_get_default_config(offset);
+
+    // OUT shifts to right, no autopull
+    sm_config_set_out_shift(&c, true, false, 32);
+
+    // We are mapping both OUT and side-set to the same pin, because sometimes
+    // we need to assert user data onto the pin (with OUT) and sometimes
+    // assert constant values (start/stop bit)
+    sm_config_set_out_pins(&c, pin_tx, 1);
+    sm_config_set_sideset_pins(&c, pin_tx);
+
+    // We only need TX, so get an 8-deep FIFO!
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
+
+    // SM transmits 1 bit per 8 execution cycles.
+    float div = (float)clock_get_hz(clk_sys) / (8 * baud);
+    sm_config_set_clkdiv(&c, div);
+
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_set_enabled(pio, sm, true);
+}
+
+static inline void uart_tx_program_putc(PIO pio, uint sm, char c) {
+    pio_sm_put_blocking(pio, sm, (uint32_t)c);
+}
+
+static inline void uart_tx_program_puts(PIO pio, uint sm, const char *s) {
+    while (*s)
+        uart_tx_program_putc(pio, sm, *s++);
+}
+
+%}