Coder-hong

FreeRTOS学习笔记-队列

关键函数说明
- 头文件
- 创建队列
- 向队列写入数据
- 从队列接收数据
- snprintf()函数
- 队列集合
- 队列邮箱
课程示例
- 通过队列发送与接收int型数据
- 通过队列发送与接收结构体
- 通过队列发送与接收指针
- 队列多进单出( Multiple In Single Out )
- 先入后出函数测试
- 队列集合(Queue Set)
- 队列邮箱

关键函数说明

头文件

#include "freertos/queue.h"

创建队列

QueueHandle_t xQueueCreate( 
			UBaseType_t uxQueueLength,//队列长度，相当于buff深度
			UBaseType_t uxItemSize //元素大小（Byte），相当于buff宽度 例如：用 sizeof(int)获取；
			);

向队列写入数据

//向队列最前端写入，等同于先入后出
BaseType_t xQueueSendToFront( 
			QueueHandle_t xQueue, //队列句柄
			const void * pvItemToQueue, //待复制的数据指针，复制的数据大小由创建队列时指定的宽度确定
			TickType_t xTicksToWait //等待时间
			);
//向队列后面写入，等同于先入先出
BaseType_t xQueueSendToBack( 
			QueueHandle_t xQueue,
			const void * pvItemToQueue,
			TickType_t xTicksToWait 
			);
//返回值：	
//		pdPASS：成功写入  
// 		errQUEUE_FULL：队列满

等待时间为：

0 ： 若队列满立即返回
portMAX_DELAY： 若 INCLUDE_vTaskSuspend == 1 ，且队列满，将一直阻塞，直到队列非满
其他值： 如队列满，将等待该时间后返回，单位为Ticks系统默认为10ms

从队列接收数据

BaseType_t xQueueReceive( 
		QueueHandle_t xQueue,//队列句柄
		void *pvBuffer,//接收数据存放位置
		TickType_t xTicksToWait //等待时间，与发送类似
	);
//返回值：
//pdPASS： 接收成功
//errQUEUE_EMPTY：队列为空

等待时间为：

0 ： 若队列空立即返回
portMAX_DELAY： 若 INCLUDE_vTaskSuspend == 1 ，且队列空，将一直阻塞，直到队列非空
其他值： 如队列空，将等待该时间后返回，单位为Ticks系统默认为10ms

UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue//队列句柄
 );//返回值： 当前队列有效数据个数

snprintf()函数

将可变参数 (…) 按照 format 格式化成字符串，并将字符串复制到 str 中，实际上后半部分跟 printf() 函数用法相同。

int snprintf(char *str,//目标字符串
			 size_t size, //拷贝字节数(Bytes) format长度大于该值将被截断,并在(size-1)位置添加“\0”
			 const char *format, //格式化成字符串
			 ...   //可变参数
 ) ;//返回值： 写入的字符串长度

队列集合

//创建队列集
QueueSetHandle_t xQueueCreateSet( 
		const UBaseType_t uxEventQueueLength //队列集长度 = 包含的每个队列的长度之和
		);//返回：队列集句柄
		
//添加队列到队列集
BaseType_t xQueueAddToSet( 
		QueueSetMemberHandle_t xQueueOrSemaphore,//要添加到队列集的队列或信号量，被强制转换成 QueueSetMemberHandle_t 类型
		QueueSetHandle_t xQueueSet //队列集
		);//返回值： pdPASS：成功；  pdFAIL：无法将队列或信号量添加到队列集中，因为它已经是另一个集的成员
//从队列集移除队列
BaseType_t xQueueRemoveFromSet( 
		QueueSetMemberHandle_t xQueueOrSemaphore,
		QueueSetHandle_t xQueueSet 
		);
		
//从队列集的成员中选择包含数据的队列 或 可用于获取的信号量
QueueSetMemberHandle_t xQueueSelectFromSet( 
		QueueSetHandle_t xQueueSet, //队列集
		const TickType_t xTicksToWait //等待超时  设为 portMAX_DELAY时, 若 INCLUDE_vTaskSuspend == 1 ，且一直未收到数据将一直阻塞
		);//返回值 NULL：在xTicksToWait参数指定的阻止时间过期之前，该集中包含的队列或信号量不可用。其他值：QueueSetMemberHandle_t 句柄

队列邮箱

//写队列邮箱
BaseType_t xQueueOverwrite( 
			QueueHandle_t xQueue, //队列邮箱句柄
			const void *pvItemToQueue //要写入的数据指针
			);//返回值：只能是 pdPASS
			
//清空队列邮箱
BaseType_t xQueueReset( QueueHandle_t xQueue );

//读队列邮箱,读取后不会从队列中移除该数据
BaseType_t xQueuePeek( 
			QueueHandle_t xQueue,//队列邮箱句柄
			void *pvBuffer, //读出的数据指针
			TickType_t xTicksToWait //超时，功能与队列读取函数相同
			);//返回值：pdPASS：成功；errQUEUE_EMPTY：队列邮箱为空。

课程示例

通过队列发送与接收int型数据

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)//发送任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 5;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)//接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL)//队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);//注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 7 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 9 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 4
mytask1: send ok
mytask1: send error
mytask2: t2= 11 cnt= 4
mytask1: send ok
mytask1: send error
mytask2: t2= 12 cnt= 4
mytask1: send ok
mytask1: send error

队列总长度为5，发送快，接收慢，队列满时，发送出错。

修改接收任务检测时间为200ms：

void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);//修改接收检测时间
    }
}

效果

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask2: t2= 7 cnt= 0
mytask1: send ok
mytask2: t2= 8 cnt= 0
mytask1: send ok
mytask2: t2= 9 cnt= 0
mytask1: send ok
mytask2: t2= 10 cnt= 0
mytask1: send ok
mytask2: t2= 11 cnt= 0
mytask1: send ok
mytask2: t2= 12 cnt= 0
mytask1: send ok
mytask2: t2= 13 cnt= 0
mytask1: send ok
mytask2: t2= 14 cnt= 0
mytask1: send ok
mytask2: t2= 15 cnt= 0
mytask1: send ok

接收快，发送慢，每次发送都正常。
因为在接收任务中添加了uxQueueMessagesWaiting函数，用于统计队列有效元素个数，没有数据时不会去接收，因此未报错。

通过队列发送与接收结构体

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

typedef struct a_struct
{
    int id;
    int data;
} xStruct;

void mytask1(void *pvParameter)
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    xStruct t1;
    t1.id = 0;
    t1.data = 999;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1.id++;
        t1.data--;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    xStruct t2;
    t2.id = 0;
    t2.data = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= { %d , %d }cnt= %d\n", t2.id, t2.data, cnt - 1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(xStruct));
    if (que1 != NULL)
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok
mytask2: t2= { 0 , 999 }cnt= 0
mytask1: send ok
mytask2: t2= { 1 , 998 }cnt= 0
mytask1: send ok
mytask2: t2= { 2 , 997 }cnt= 0
mytask1: send ok
mytask2: t2= { 3 , 996 }cnt= 0
mytask1: send ok
mytask2: t2= { 4 , 995 }cnt= 0
mytask1: send ok
mytask2: t2= { 5 , 994 }cnt= 0
mytask1: send ok
mytask2: t2= { 6 , 993 }cnt= 0
mytask1: send ok
mytask2: t2= { 7 , 992 }cnt= 0
mytask1: send ok
mytask2: t2= { 8 , 991 }cnt= 0

通过队列发送与接收指针

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char *pt1;
    
    int i = 0;
    while (1)
    {
        pt1 = (char *)malloc(50); //每次循环都分配新的地址
        snprintf(pt1, 50, "hello world %d", i);
        if (xQueueSendToBack(p, &pt1, 0) == pdPASS)
        {
            printf("mytask1: send ok pt1_addr= %p \n", pt1);
        }
        else
        {
            printf("mytask1: send error \n");
        }
        i++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char *pt2;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &pt2, 0);//在队列中接收的实际只是一个char指针，即发送任务中分配的地址
            printf("mytask2: pt2_addr= %p  pt2= %s | cnt= %d\n", pt2, pt2, cnt - 1);
            free(pt2); //释放发送函数分配的内存
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(char *));
    if (que1 != NULL)
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok pt1_addr= 0x3ffb94d0
mytask2: pt2_addr= 0x3ffb94d0 pt2= hello world 0 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 1 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 2 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 3 | cnt= 0

demo中故意把指针地址打印出来，是为了说明队列里面传递的只是一个地址，并非真正的数据拷贝；
因为任务2中对任务1分配的char指针进行了free()操作，因此后面分配的地址可能重复。

屏蔽free()函数效果如下，这样会占用不必要的内存，需谨慎使用。

mytask1: send ok pt1_addr= 0x3ffb94d0
mytask2: pt2_addr= 0x3ffb94d0 pt2= hello world 0 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 1 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a80
mytask2: pt2_addr= 0x3ffb4a80 pt2= hello world 2 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4ab8
mytask2: pt2_addr= 0x3ffb4ab8 pt2= hello world 3 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4af0
mytask2: pt2_addr= 0x3ffb4af0 pt2= hello world 4 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4b28
mytask2: pt2_addr= 0x3ffb4b28 pt2= hello world 5 | cnt= 0

队列多进单出( Multiple In Single Out )

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 111;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter) //发送任务2
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 222;
    while (1)
    {
        if (xQueueSendToBack(p, &t2, 0) == pdPASS)
        {
            printf("mytask2: send ok \n");
        }
        else
        {
            printf("mytask2: send error \n");
        }
        t2++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask3(void *pvParameter) //接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t3 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t3, 0);
            printf("mytask3: t3= %d cnt= %d\n", t3, cnt - 1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL) //队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL); //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask3, "mytask3", 1024 * 5, (void *)que1, 2, NULL);
    }
}

效果
任务1和2往同一个队列里面写数据，任务3接收。

mytask1: send ok
mytask3: t3= 111 cnt= 0
mytask2: send ok
mytask3: t3= 222 cnt= 0
mytask1: send ok
mytask2: send ok
mytask3: t3= 112 cnt= 1
mytask3: t3= 223 cnt= 0
mytask1: send ok
mytask2: send ok
mytask3: t3= 113 cnt= 1
mytask3: t3= 224 cnt= 0
mytask1: send ok
mytask2: send ok

先入后出函数测试

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)//发送任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 5;
    while (1)
    {
        //if (xQueueSendToBack(p, &t1, 0) == pdPASS)//先入先出
        if (xQueueSendToFront(p, &t1, 0) == pdPASS)//先入后出
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)//接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL)//队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);//注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果
先进入队列的数据反而没有按顺序打印，反而先接收了最新写入队列的数据。

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 12 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 14 cnt= 4
mytask1: send ok
mytask1: send error

先入先出效果对比：
队列溢出前，按先入先出的顺序，依次接收。

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 7 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 9 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 4
mytask1: send ok
mytask1: send error

队列集合(Queue Set)

每个发送任务具有自己独立的队列，而接收任务从多个队列，即“Queue Set”中选择有数据的队列，并接收队列中的数据。

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 111;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter) //发送任务2
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char t2 = 222;
    while (1)
    {
        if (xQueueSendToBack(p, &t2, 0) == pdPASS)
        {
            printf("mytask2: send ok \n");
        }
        else
        {
            printf("mytask2: send error \n");
        }
        t2++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask3(void *pvParameter) //接收任务
{
    QueueSetHandle_t pset;
    pset = (QueueSetHandle_t)pvParameter;
    QueueHandle_t p;
    int t3;
    while (1)
    {
        p = (QueueHandle_t)xQueueSelectFromSet(pset, portMAX_DELAY);
        xQueueReceive(p, &t3, 0);
        printf("mytask3: t3= %d \n", t3);
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{
    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    QueueHandle_t que2 = xQueueCreate(8, sizeof(char));
    QueueSetHandle_t que_set1 = xQueueCreateSet(13); //队列集长度 = 包含的每个队列的长度之和
    if ((que1 != NULL) && (que1 != NULL))            //队列创建成功时再创建收发任务
    {

        xQueueAddToSet(que1, que_set1);
        xQueueAddToSet(que2, que_set1);

        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL); //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que2, 1, NULL);
        xTaskCreate(mytask3, "mytask3", 1024 * 5, (void *)que_set1, 2, NULL);
    }
}

效果

mytask1: send ok
mytask3: t3= 111
mytask2: send ok
mytask3: t3= 222
mytask3: t3= 112
mytask1: send ok
mytask2: send ok
mytask3: t3= 223
mytask3: t3= 113
mytask1: send ok
mytask2: send ok
mytask3: t3= 224

从队列集中接收数据正常，但有个遗留问题还不知如何解决，就是从程序中怎么确定当前接收的队列是que1还是que2。

队列邮箱

队列是用于数据传递，从一个或多个任务发送数据到另一个任务；
队列邮箱（Mailbox）用于控制程序执行流程，写任务向Mailbox写入控制命令，各个读任务从Mailbox拿到指令并执行不同到操作。

邮箱基于队列创建，与队列主要差异如下：

邮箱是只有一个元素长度的队列
邮箱读写方式与队列不同
邮箱写函数 xQueueOverwrite();
邮箱读函数 xQueuePeek() 执行后不会从队列删除已经读取的数据
要清空邮箱，需采用：xQueueReset() 函数

#include 
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void send_task(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1;
    while (1)
    {
        t1 = 1; // mode A
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        t1 = 5; // mode B
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        t1 = 8; // mode C
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        xQueueReset(p); //清空队列内容
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }
}
void receive_task(void *pvParameter) //接收任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char t2 = 222;
    char *task_name;
    task_name = pcTaskGetName(NULL); //获取当前任务名

    while (1)
    {
        if (xQueuePeek(p, &t2, 0) == pdPASS) // portMAX_DELAY
        {
            switch (t2)
            {
            case 1:
                printf("%s: mode A \n", task_name);
                break;
            case 5:
                printf("%s: mode B \n", task_name);
                break;
            case 8:
                printf("%s: mode C \n", task_name);
                break;
            default:
                printf("%s: error \n", task_name);
                break;
            }
        }
        else
        {
            printf("%s: Mailbox empty \n", task_name);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{
    QueueHandle_t Mailbox1 = xQueueCreate(1, sizeof(int));

    if (Mailbox1 != NULL) //邮箱创建成功时再创建收发任务
    {
        xTaskCreate(send_task, "send_task", 1024 * 5, (void *)Mailbox1, 1, NULL);        //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(receive_task, "receive_task1", 1024 * 5, (void *)Mailbox1, 2, NULL); //接收优先级高
        xTaskCreate(receive_task, "receive_task2", 1024 * 5, (void *)Mailbox1, 2, NULL); //接收任务2和3与任务1共用1个函数体，功能相同
        xTaskCreate(receive_task, "receive_task3", 1024 * 5, (void *)Mailbox1, 2, NULL);
    }
}

效果

receive_task2: mode A
receive_task1: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode B
receive_task1: mode B
receive_task2: mode B
receive_task3: mode B
receive_task1: mode B
receive_task2: mode B
receive_task3: mode C
receive_task1: mode C
receive_task2: mode C
receive_task3: mode C
receive_task1: mode C
receive_task2: mode C
receive_task3: Mailbox empty
receive_task1: Mailbox empty
receive_task2: Mailbox empty
receive_task3: Mailbox empty
receive_task1: Mailbox empty
receive_task2: Mailbox empty
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode B

1个发送任务进行系统控制，每隔2s切换模式A、B、C，并在最后2s清除邮箱，3个接收任务公用1个函数体，执行相同的函数，通过打印任务名可做区分。

esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
ESP32-C3入门教程网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能小康师兄 ESP32-C3入门教程 https 服务器 esp32 OTA MQTT
文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
STM32 HAL freertos零基础（九）任务通知啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、任务通知任务通知用于任务之间同步和通信。任务通知允许一个任务向另一个任务发送一个32位的值，并可以选择是否唤醒正在等待通知的任务。这使得任务之间的同步更加简单和灵活。任务通知功能：发送通知：一个任务可以向另一个任务发送一个32位的值。接收通知：接收任务可以根据接收到的通知来决定何时执行某些操作。通知状态：可以检查任务的当前通知状态。2、相关APIxTaskNotify()//发送通知，带有通知
FreeRTOS操作系统（详细速通篇）——— 第十五章（完结）给生活加糖！快速通关FreeRTOS stm32 FreeRTOS 单片机嵌入式嵌入式软件 c语言操作系统
本专栏将对FreeRTOS进行快速讲解，带你了解并使用FreeRTOS的各部分内容。适用于快速了解FreeRTOS并进行开发、突击面试、对新手小白非常友好。期待您的后续关注和订阅！目录软件定时器和低功耗模式1软件定时器1.1什么是定时器？1.2软件定时器的优缺点1.3FreeRTOS软件定时器特点1.4软件定时器的状态及转换1.4.1定时器状态1.4.2定时器周期1.5结构体及API函数1.5.1
物联网之ESP32配网方式、蓝牙、WiFi 智码帮MJ682517 Web前端嵌入式硬件物联网嵌入式硬件物联网 web前端
MENU前言SmartConfig(智能配网)AP模式(AccessPoint模式)蓝牙配网WebServer模式WPS配网(Wi-FiProtectedSetup)Provisioning(配网服务)静态配置(硬编码)总结前言ESP32配网(Wi-Fi配置)的方式有多种，每种方式都有各自的优缺点。根据具体项目需求，可以选择适合的配网方式。SmartConfig(智能配网)原理ESP32通过监听周
【ESP32 WiFi篇（四）】ESP32 UDP服务端、客户端 Eiker_3169 ESP32 ESP32 http
文章目录UDP客户端UDP服务端UDP客户端/*BSDSocketAPIExampleThisexamplecodeisinthePublicDomain(orCC0licensed,atyouroption.)Unlessrequiredbyapplicablelaworagreedtoinwriting,thissoftwareisdistributedonan"ASIS"BASIS,WITH
ESP32 UDP 05 zq4132 udp ESP32 嵌入式硬件
1.在上一文章基础上修改，文章网址ESP32-Ethernet-04-CSDN博客2.基本代码/*EthernetBasicExampleThisexamplecodeisinthePublicDomain(orCC0licensed,atyouroption.)Unlessrequiredbyapplicablelaworagreedtoinwriting,thissoftwareisdistr
FreeRTOS学习笔记＞内存管理 HKElec FreeRTOS学习笔记学习笔记
1.内存的概念与分类在计算系统中，内存用于存储变量和中间数据。系统的内存可以分为两种：内部存储空间（RAM）：通常指随机存储器，数据存取速度快，可以随机访问，但掉电后数据会丢失。外部存储空间：例如硬盘或闪存，数据即使在掉电后也能保存。在嵌入式系统中，我们主要关注内部存储空间（RAM）的管理，这就是内存管理的核心内容。2.FreeRTOS内存管理的设计理念FreeRTOS操作系统将内核与内存管理功能
STM32 HAL freertos零基础（六）计数型信号量啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、计数型信号量计数型信号量（CountingSemaphore）是另一种类型的信号量，它可以保持一个大于等于0的整数值，这个值表示可用资源的数量。本质上相当于队列长度大于1得队列。经典问题就是剩余车辆统计，出入车辆，车辆数据可以实时更新。2、相关API函数xSemaphoreCreateCounting()//使用动态方法创建计数型信号量。xSemaphoreCreateCountingStat
STM32 HAL freertos零基础（七）互斥量啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、互斥量互斥量主要用于保护共享资源的访问，确保在同一时刻只有一个任务可以访问该资源。互斥性：当一个任务获取了一个互斥量后，其他任务将无法再获取同一个互斥量，直到原始任务释放该互斥量。优先级继承：为了防止优先级反转问题，FreeRTOS的互斥量支持优先级继承机制。当一个高优先级任务被低优先级任务阻塞时，低优先级任务会暂时提升自己的优先级，以尽快释放互斥量，让高优先级任务继续执行。递归锁定：互斥量支
ESP32 将String 字符依次存到数组 qq_42949957 前端
Stringpayload="";intbyteCount=0;for(inti=0;i128){intN=(byteCount/128)+1;//计算需要的字符串数量，向上取整Stringstrings[N];//创建一个String数组//将输入数据分割成128字节的字符串for(inti=0;i0){//有数据可读取，退出循环StringreceivedData=MySerial.readS
ESP32鉴权讯飞科技 qq_42949957 科技运维
#include#include#include#include#include#includeconstchar*ssid="464564";constchar*password="546456.";WebSocketsClientwebSocket;voidwebSocketEvent(WStype_ttype,uint8_t*payload,size_tlength){switch(type
micropython串口通信_MicroPython-ESP32串口通信-1Z实验室 weixin_39896839 micropython串口通信
出品：1Z实验室(1ZLAB：MakeThingsEasy)概要在本节课程阿凯为大家讲解了串口通信的接线方式，ESP32中的串口UART资源与相关API，并给出了一个UART的小应用实例。目录串口通信UART执行标准UART/USART双工串行通信协议，关于串口通信你需要的预备知识有码元，波特率，奇偶校验等概念。可以在B站上观看串口通信科普视频.TODO英文的，1Z实验室后面有精力也会考虑做一些科
龙芯+FreeRTOS+LVGL实战笔记（新）——05部署主按钮南耿先生嵌入式开发龙芯 FreeRTOS LVGL
本专栏是笔者另一个专栏《龙芯+RT-Thread+LVGL实战笔记》的姊妹篇，主要的区别在于实时操作系统的不同，章节的安排和任务的推进保持一致，并对源码做了改进和优化，各位可以先到本人主页下去浏览另一专栏的博客列表（目前已撰写36篇，图1所示），再决定是否订阅。此外，也可以前往本人在B站的视频合集（图2所示）观看所有演示视频，合集首个视频链接为：借助RT-Thread和LVGL，在龙芯板上搞定两个
龙芯+FreeRTOS+LVGL实战笔记（新）——02准备工程和驱动文件南耿先生嵌入式开发龙芯 FreeRTOS LVGL
本专栏是笔者另一个专栏《龙芯+RT-Thread+LVGL实战笔记》的姊妹篇，主要的区别在于实时操作系统的不同，章节的安排和任务的推进保持一致，并对源码做了完善与优化，各位可以先到本人主页下去浏览另一专栏的博客列表（目前已撰写36篇，图1所示），再决定是否订阅。此外，也可以前往本人在B站的视频合集（图2所示）观看所有演示视频，合集首个视频链接为：借助RT-Thread和LVGL，在龙芯板上搞定两个
龙芯+FreeRTOS+LVGL实战笔记（新）——04开启主任务南耿先生笔记
本专栏是笔者另一个专栏《龙芯+RT-Thread+LVGL实战笔记》的姊妹篇，主要的区别在于实时操作系统的不同，章节的安排和任务的推进保持一致，并对源码做了改进和优化，各位可以先到本人主页下去浏览另一专栏的博客列表（目前已撰写36篇，图1所示），再决定是否订阅。此外，也可以前往本人在B站的视频合集（图2所示）观看所有演示视频，合集首个视频链接为：图1《龙芯+RT-Thread+LVGL实战笔记》专
RTOS笔记--任务状态与调度 HUOHUAAARSGJKD 笔记
任务状态freertos中的任务分为四个状态：就绪状态（ready）、运行状态（running）、阻塞状态（blocked）、暂停状态（suspended）完整的任务状态转换图：在使用vTaskDelay函数后任务就会转换为阻塞态，阻塞态下需要等待某个时间或某个事件才可以进入准备态随时被调用。任务在除了暂停状态以外的任何状态都可以通过调用vTaskSuspend函数使得任务进入暂停状态，任务在运行
深入理解FreeRTOS_学习笔记(5 2401_84009773 程序员学习笔记
#if(configSUPPORT\_DYNAMIC\_ALLOCATION==1)#definexSemaphoreCreateMutex()xQueueCreateMutex(queueQUEUE\_TYPE\_MUTEX)#endif#if((configUSE\_MUTEXES==1)&&(configSUPPORT\_DYNAMIC\_ALLOCATION==1))QueueHandle
JSON入门（基于ESP-IDF）弱冠少年嵌入式软件 json 服务器运维
主要参考资料：ESP32学习笔记（12）——JSON接口使用:https://blog.csdn.net/qq_36347513/article/details/116481167目录1.JSON简介1.1JSON语法规则1.2JSON键/值对2.添加cJSON4.解析JSON数据4.1判断是否为JSON4.2解析数据4.2.1解析字符串类型数据4.2.2解析整型数组数据4.3释放内存1.JSON
使用PHP和MQTT构建高效的物联网数据转发服务器流程极客小张 php 物联网服务器单片机运维 MQTT 数据库
一、项目概述项目目标和用途本项目旨在搭建一个基于PHP的物联网服务器，能够接收来自各种传感器的数据，并通过MQTT协议将数据转发到其他设备或服务。该系统适用于智能家居、环境监测等场景，能够实现实时数据监控和远程控制。技术栈关键词PHPMQTTMySQLESP8266/ESP32（单片机）DHT11（温湿度传感器）Linux服务器Apache/Nginx二、系统架构系统架构设计本项目的系统架构主要由
freertos的动态内存分配之heap_1.c解析 jarvif
一、freertos的动态内存分配原理首先，freertos的动态内存分配是一种“假”动态内存分配策略。所谓“假”，是指实质并不是做到真正意义上的动态分配，而是事先分配了一个足够大的静态数组，然后freertos的内存管理策略会对这一块大的静态数组进行内存管理。所以，freertos中用到的它自身的动态内存分配时候，都只是使用的这一个静态数组，即这一段内存保存数据。二、分析环境为了方便，笔者都是使
STM32CubeMX和HAL库三十度角阳光的问候 stm32 嵌入式硬件单片机
目录STM32CubeMX和HAL库介绍STM32Cube主要包括两部分安装MCU固件包软件功能与基本使用STM32CubeMX和HAL库介绍STM32CubeMX软件是ST有限公司为STM32系列微控制器快速建立工程，并快速初始化使用到的外设、GPIO等而设计的，大大缩短了开发时间。同时，该软件不仅能配置STM32外设，还能进行第三方软件系统的配置，例如FreeRTOS、FAT32、LWIP等；
FreeRTOS学习笔记（二）任务基础篇云雨歇学习笔记
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、任务的基本内容1.1任务的基本特点1.2任务的状态1.3任务控制块——任务的“身份证”二、任务的实现2.1定义任务函数2.2创建任务2.3启动任务调度器2.4任务的运行与切换2.4.1利用延时函数2.4.2利用中断2.5任务的通信与同步2.6任务的删除2.7任务的通知2.8任务挂起和恢复三、相关辅助API函数前言在
esp32通过NBIoT模块连入MQTT服务器发愤图强想做全栈的小陈服务器数据库 sqlite
title:esp32通过NBIoT模块连入MQTT服务器keywords:nbiot,esp32,c++,python,mqtttags:[esp32,c++,python,mqtt,nbiot]categories:[嵌入式,前后端]esp32通过NBIoT模块连入MQTT服务器先简单介绍一下MQTT（MessageQueuingTelemetryTransport），是一种轻量级、开放的发布
Arduino ESP32 FreeRTOS 逢生博客 c语言单片机 mcu 51单片机物联网
文章目录基本多线程Arduino示例配置创建任务消息队列信号量定时器互拆量（Mutex）事件组（EventGroup）基本多线程Arduino示例配置#ifCONFIG_FREERTOS_UNICORE#defineARDUINO_RUNNING_CORE0#else#defineARDUINO_RUNNING_CORE1#endif当FreeRTOS配置为单核模式时，ARDUINO_RUNNIN
ARDUINO IDE 安装ESP32开发环境望得见终南山 c语言单片机嵌入式硬件
1.在IDE的文件->首选项里边的附加开发板管理网址输入https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json2.安装ESP32Tools>Board>BoardsManager…3.Enjoyit
XTensa架构的处理器上--汇编实现一个1秒定时器小蘑菇二号单片机 stm32 嵌入式硬件
要在XTensa架构的处理器上实现一个1秒定时器，你可以使用定时器中断来实现。XTensa架构的处理器通常用于嵌入式系统，例如ESP32等。下面是一个基于XTensa架构的1秒定时器实现的例子。XTensa架构定时器实现假设你的XTensa处理器的时钟频率为1GHz（即每秒10亿个时钟周期），那么你需要配置一个定时器中断，使其每10亿个时钟周期触发一次中断。步骤1:初始化定时器选择定时器：XTen
基于 AT 固件测试 ESP32 设备作为 WiFi AP 模式创建 TCP Server 开启 UART-to-WiFi 透传模式的指令序列 Rainbow.Cai AT tcp/ip 服务器网络协议
AT指令序列如下AT+RESTOREAT+CWMODE=2//SettheWi-FimodetoSoftAP.AT+CWSAP="ESP32_softAP","1234567890",5,3//SetsoftAPAT+CIPMUX=1//EnablemultipleconnectionsforTCPServerAT+CIPSERVERMAXCONN=1//Setthemaximumnumberof
freertos学习笔记——任务切换天分天涯学习笔记
目录第一种情况分析（第二种情况遇到了可自行标记一下）xPortSysTickHandler中断服务函数：下面是PendSV的中断服务函数xPortPendSVHandler函数：vTaskSwitchContext函数分析：（获取最高优先级的TCB并赋值给pxCurrentTCB）任务之间的切换实际上是将不同的任务栈中保存的寄存器赋值到CPU的寄存器中的一个过程。前提：1.任务切换是在第一个任务启
FreeRTOS学习笔记—任务基础知识二土电子 FreeRTOS学习笔记 stm32 笔记学习
文章作者：二土电子关注文末公众号获取其他资料和工程文件！期待大家一起学习交流！文章目录一、FreeRTOS任务特性二、FreeRTOS任务状态三、FreeRTOS任务优先级四、FreeRTOS任务实现五、任务控制块六、任务堆栈一、FreeRTOS任务特性简单没有使用限制（任务数量没有限制，一个优先级下可以有多个任务）支持抢占（高优先级任务可以抢占低优先级任务的CPU使用权）支持优先级每个任务都拥有
辗转相处求最大公约数沐刃青蛟 C++漏洞
无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！为此，总结一下以方便日后忘了好查找。 1.输入要比较的两个数a,b 忽略：2.比较大小（因为后面要的是大的数对小的数做%操作） 3.辗转相除（用循环不停的取余，如a%b,直至b=0） 4.最后的a为两数的最大公约数 &
F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5 负载均衡
一.什么是会话保持？在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
Object.equals方法：重载还是覆盖 Cwind java generics override overload
本文译自StackOverflow上对此问题的讨论。原问题链接在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
初始线程 15700786134
暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
Linux的tcpdump 被触发 tcpdump
用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。实用命令实例默认启动 tcpdump 普通情况下，直
安卓程序listview优化后还是卡顿肆无忌惮_ ListView
最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
扩展easyUI tab控件，添加加载遮罩效果知了ing jquery
(function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
gradle上传jar到nexus 矮蛋蛋 gradle
原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations { deployerJars } dependencies { deployerJars "org.apache.maven.wagon
千万条数据外网导入数据库的解决方案。 alleni123 sql mysql
从某网上爬了数千万的数据，存在文本中。然后要导入mysql数据库。悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作字符流
这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励我会更加的去学加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流字节流和字符的难点：a,怎么将读到的数据
MO、MT解读 bijian1013 GSM
MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息；上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
五个JavaScript基础问题 bijian1013 JavaScript call apply this Hoisting
下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。问题1：Scope作用范围考虑下面的代码： (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？回答：上面的代码会打印 5。 &nbs
【Thrift二】Thrift Hello World bit1129 Hello world
本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程 1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
【Avro一】Avro入门 bit1129 入门
本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。 1. 添加Maven依赖 <?xml version="1.0" encoding="UTF-8"?> <proj
安装nginx+ngx_lua支持WAF防护功能 ronin47
需要的软件:LuaJIT-2.0.0.tar.gz nginx-1.4.4.tar.gz &nb
java-5.查找最小的K个元素-使用最大堆 bylijinnan java
import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
TCP的TIME-WAIT bylijinnan socket
原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记说明：主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值 <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
Apache集群乱码和最高并发控制 cuisuqiang apache tomcat 并发集群乱码
都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
websocket dalan_123 websocket
一、低延迟的客户端-服务器和服务器-客户端的连接很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
菜鸟分析网络执法官 dcj3sjt126com 网络
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包.
Android相对布局属性全集 dcj3sjt126com android
RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
Tomcat内存设置详解 eksliang jvm tomcat tomcat内存设置
Java内存溢出详解一、常见的Java内存溢出有以下三种： 1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。可以利用JVM提
Java6 JVM参数选项 greatwqs java HotSpot jvm jvm参数 JVM Options
Java 6 JVM参数选项大全（中文版）作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
weblogic创建JMC i5land weblogic jms
进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。系统包括几个独立的部分：使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；使用 PHP CI 框架开发的简易网站；搜索引擎目前直接使用的 MySQL，将来可以考虑使
sql添加、删除表中的列 macroli sql
添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
PHP中二维数组的排序方法 abc123456789cba 排序二维数组 PHP
<?php/*** @package BugFree* @version $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hive hive优化
一、控制hive任务中的map数: 1. 通常情况下，作业会通过input的目录产生一个或者多个map任务。主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2.
Spring Boot 1.2.4 发布 wiselyman spring boot
Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。 Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多

FreeRTOS学习笔记-队列