保证counter_cache在更新时也有效

最新推荐文章于 2025-09-28 17:16:08 发布
原创 最新推荐文章于 2025-09-28 17:16:08 发布 · 430 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

C++如何设计和实现缓存（cache）来减少对后端存储的访问压力
大模型大数据攻城狮的专栏
05-01 1234
缓存，简单来说，是一种临时存储机制，用于保存频繁访问的数据或计算结果，以便在后续请求中快速获取，而无需重复访问较慢的后端存储或重新计算。其核心思想是“以空间换时间”，即通过占用一定的存储空间（通常是速度更快的存储介质），来换取更低的访问延迟和更高的系统吞吐量。在计算机系统中，缓存无处不在，从硬件层面的CPU缓存，到软件层面的数据库查询缓存，再到分布式系统中的分布式缓存，均体现了这一设计理念。缓存的基本工作流程可以概括为：当系统接收到一个请求时，首先检查缓存中是否存在所需的数据；
Ceph 之RGW Cache
终极冥帝
02-01 1924
Overview峡谷小说网 m.xiagu.org 缓存是为达到系统快速响应的一项关键技术，Ceph 作为一个复杂的分布式存储系统，有多种、多级缓存存在。缓存按照位置分为： 客户端缓存 服务端缓存 网络中缓存 按照部署方式分为： 单体缓存 缓存集群 分布式缓存 而Rados 网关缓存，也即RGW Cache 按照位置：作为Ceph client 可以归为客户端缓存，作为上层应用的服务端可...
【llm对话系统】基于llm的实时多轮对话如何做kv cache
kakaZhui的博客
01-25 1614
随着用户输入新的信息，context会动态增长。为了提高LLM的响应速度和效率，我们通常会使用KV Cache来存储context的向量表示，以便快速检索相关信息。因为用户的输入不是一次性获取的，而是逐字逐句地到来，直接进行实时计算可能会导致频繁更新KV Cache，影响效率。
Cache在干嘛
Harbour_的博客
12-06 1419
logisim搭Cache的理解
RGW caceh
b779789251的博客
04-04 533
缓存是为达到系统快速响应的一项关键技术，Ceph 作为一个复杂的分布式存储系统，有多种、多级缓存存在。缓存按照位置分为： 客户端缓存 服务端缓存 网络中缓存 按照部署方式分为： 单体缓存 缓存集群 分布式缓存 而Rados 网关缓存，也即RGW Cache 按照位置：作为Ceph client 可以归为客户端缓存，作为上层应用的服务端可以归为服务端缓存。而按照部署方式则为分布式缓存，因...
C6000系列的C64x+ Cache优化--配置，Cache miss和Cache一致性
lcydhr的专栏
11-17 1999
本文主要介绍TI C6000系列的C64x+的DSP Cache配置，常见的Cache miss模式以及如何在多核或者多外设DMA系统下维护Cache一致性，当然还有Cache优化的专题，针对指令L1P和数据L1D cache的优化。 C64x+与C64x CACHE的区别 Write Buffer(WB)： 1. C64x+的 write buffe(WB)宽度为128-bit
GuavaCache
最新发布
qq_44884569的博客
09-28 889
guavaCache是Goole guava库中一个组件，支持多种配置：设置缓存大小、过期策略、且是线程安全的,无需额外同步控制；load方法和reload方法都是懒加载的，只有在请求到达时，才可能执行；load方法和reload方法都是线程安全的，同一时刻只能有一个线程执行；reload方法的执行时机是要保证访问的缓存还在有效期内，才能执行reload方法；若访问的缓存已经过了有效期，那只会执行load方法。
CPU Cache与缓存行
热门推荐
Mlib
09-14 1万+
引言 先看下面这两个循环遍历哪个快？ int[][] array = new int[64 * 1024][1024]; // 横向遍历 for(int i = 0; i < 64 * 1024; i ++) for(int j = 0; j < 1024; j ++) array[i][j] ++; // 纵向遍历 for(int i = ...
JetCache源码解析——API实现
qq_16500963的博客
03-03 1468
*** 抽象缓存类，提供了缓存的基本实现，支持键值对的存取操作。该类是线程安全的。* @param 键的类型* @param 值的类型*//*** 通知缓存事件监听器。* @param e 缓存事件。*//*** 获取缓存中指定键的值。* @param key 键。* @return CacheGetResult 获取结果，包含值和操作状态。*/@Override// 对于null键，直接返回错误结果。} else {
#ifndef __SOFT_I2C_H #define __SOFT_I2C_H #include "stm32g0xx_hal.h" // I2C引脚定义 #define I2C_SCL_PIN GPIO_PIN_6 #define I2C_SDA_PIN GPIO_PIN_7 #define I2C_GPIO_PORT GPIOB // I2C地址 #define I2C_SLAVE_ADDR 0x48 // 通信缓冲区配置 #define DATA_OFFSET 3 // 数据起始位置 #define I2C_TIMEOUT 10000 // 超时计数(基于系统频率调整) #define FRAME_LENGTH 20 // 帧长度定义 // 外部变量声明 extern uint8_t i2c_rx_buf[FRAME_LENGTH]; extern uint8_t i2c_tx_buf[FRAME_LENGTH]; extern uint8_t i2c_receive_complete; // 函数声明 void I2C_Init(void); void I2C_Send_ACK(void); void I2C_Send_NACK(void); uint8_t I2C_Read_SCL(void); uint8_t I2C_Read_SDA(void); void I2C_Write_SDA(uint8_t state); uint8_t Calculate_XOR_Checksum(uint8_t *data, uint8_t length); void Prepare_TX_Frame(uint8_t data_type); void I2C_Reset_Communication(void); #endif #include "soft_i2c.h" #include "delay.h" #include <stdio.h> // 全局变量定义 uint8_t i2c_rx_buf[FRAME_LENGTH] = {0}; uint8_t i2c_tx_buf[FRAME_LENGTH] = {0}; uint8_t i2c_rx_index = 0; uint8_t i2c_tx_index = 0; uint8_t i2c_receive_complete = 0; uint8_t current_function_code = 0x00; // 传感器数据缓存结构 typedef struct { uint16_t reg_11; // 寄存器11的数据 uint8_t updated; // 数据更新标志(1:新数据,0:未更新) uint32_t timestamp; // 数据时间戳 uint8_t valid; // 数据有效标志 } SensorDataCache; // 外部变量声明 extern uint16_t adc_ch4_avg; extern uint16_t adc_ch5_avg; extern uint16_t adc_ch6_avg; extern uint16_t adc_ch7_avg; extern SensorDataCache sensor2_cache; extern SensorDataCache sensor3_cache; extern SensorDataCache sensor4_cache; // I2C状态机枚举 typedef enum { I2C_STATE_IDLE, // 空闲状态 I2C_STATE_ADDR_RECEIVING, // 接收地址状态 I2C_STATE_RX_DATA, // 接收数据状态 I2C_STATE_TX_DATA, // 发送数据状态 I2C_STATE_ERROR // 错误状态 } I2C_State; // 全局状态变量 static volatile I2C_State i2c_state = I2C_STATE_IDLE; static volatile uint8_t i2c_addr_match = 0; // 地址匹配标志 static volatile uint8_t i2c_read_mode = 0; // 读模式标志(1:读,0:写) static volatile uint8_t last_sda_level = 1; // 上一次SDA电平 static volatile uint8_t last_scl_level = 0; // 上一次SCL电平 static volatile uint8_t bit_counter = 0; // 位计数器 static volatile uint8_t current_byte = 0; // 当前字节缓存 static volatile uint32_t comm_timeout = 0; // 通信超时计数器 static const uint32_t COMM_TIMEOUT_THRESHOLD = 50000; // 通信超时阈值 // 读取SCL引脚电平 uint8_t I2C_Read_SCL(void) { return HAL_GPIO_ReadPin(I2C_GPIO_PORT, I2C_SCL_PIN); } // 读取SDA引脚电平 uint8_t I2C_Read_SDA(void) { return HAL_GPIO_ReadPin(I2C_GPIO_PORT, I2C_SDA_PIN); } // 设置SDA引脚电平 static void I2C_Write_SDA(uint8_t state) { HAL_GPIO_WritePin(I2C_GPIO_PORT, I2C_SDA_PIN, state ? GPIO_PIN_SET : GPIO_PIN_RESET); } // 设置SDA引脚为输入模式 static void I2C_Set_SDA_Input(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = I2C_SDA_PIN; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(I2C_GPIO_PORT, &GPIO_InitStruct); } // 设置SDA引脚为开漏输出模式 static void I2C_Set_SDA_Output(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = I2C_SDA_PIN; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(I2C_GPIO_PORT, &GPIO_InitStruct); } // 发送ACK信号 void I2C_Send_ACK(void) { I2C_Set_SDA_Output(); I2C_Write_SDA(0); // 拉低SDA表示ACK } // 发送NACK信号 void I2C_Send_NACK(void) { I2C_Set_SDA_Output(); I2C_Write_SDA(1); // 保持SDA高表示NACK } // 计算异或校验和 uint8_t Calculate_XOR_Checksum(uint8_t *data, uint8_t length) { uint8_t checksum = 0; for(uint8_t i = 0; i < length; i++) { checksum ^= data[i]; } return checksum; } // 发送帧准备函数 void Prepare_TX_Frame(uint8_t data_type) { // 帧头 i2c_tx_buf[0] = 0x01; i2c_tx_buf[1] = 0xBB; i2c_tx_buf[2] = data_type; // 根据功能码准备不同数据 switch(data_type) { case 0x01: // ADC数据 i2c_tx_buf[3] = (adc_ch4_avg >> 8) & 0xFF; i2c_tx_buf[4] = adc_ch4_avg & 0xFF; i2c_tx_buf[5] = (adc_ch5_avg >> 8) & 0xFF; i2c_tx_buf[6] = adc_ch5_avg & 0xFF; i2c_tx_buf[7] = (adc_ch6_avg >> 8) & 0xFF; i2c_tx_buf[8] = adc_ch6_avg & 0xFF; i2c_tx_buf[9] = (adc_ch7_avg >> 8) & 0xFF; i2c_tx_buf[10] = adc_ch7_avg & 0xFF; break; case 0x02: // 传感器数据 // 传感器2数据 - 从缓存读取 if (sensor2_cache.valid) { i2c_tx_buf[3] = (sensor2_cache.reg_11 >> 8) & 0xFF; i2c_tx_buf[4] = sensor2_cache.reg_11 & 0xFF; } else { i2c_tx_buf[3] = 0xFF; // 无效数据标志 i2c_tx_buf[4] = 0xFF; } // 传感器3数据 - 从缓存读取 if (sensor3_cache.valid) { i2c_tx_buf[5] = (sensor3_cache.reg_11 >> 8) & 0xFF; i2c_tx_buf[6] = sensor3_cache.reg_11 & 0xFF; } else { i2c_tx_buf[5] = 0xFF; i2c_tx_buf[6] = 0xFF; } // 传感器4数据 - 从缓存读取 if (sensor4_cache.valid) { i2c_tx_buf[7] = (sensor4_cache.reg_11 >> 8) & 0xFF; i2c_tx_buf[8] = sensor4_cache.reg_11 & 0xFF; } else { i2c_tx_buf[7] = 0xFF; i2c_tx_buf[8] = 0xFF; } i2c_tx_buf[9] = 0x00; // 预留 i2c_tx_buf[10] = 0x00; // 预留 break; default: // 未知功能码 i2c_tx_buf[2] = 0xFF; // 错误标识 break; } // 填充剩余字节并计算校验和 for(uint8_t i = 11; i < 19; i++) { i2c_tx_buf[i] = 0x00; } i2c_tx_buf[FRAME_LENGTH-1] = Calculate_XOR_Checksum(i2c_tx_buf, FRAME_LENGTH-1); } // 重置通信状态 void I2C_Reset_Communication(void) { i2c_state = I2C_STATE_IDLE; i2c_rx_index = 0; i2c_tx_index = 0; i2c_addr_match = 0; i2c_read_mode = 0; bit_counter = 0; current_byte = 0; i2c_receive_complete = 0; I2C_Set_SDA_Input(); } // 处理接收位 static void I2C_Process_Receive_Bit(uint8_t scl_rising) { if (scl_rising) { // 在SCL上升沿采样数据 current_byte = (current_byte << 1) | I2C_Read_SDA(); bit_counter++; // 完成一个字节接收 if (bit_counter >= 8) { if (i2c_state == I2C_STATE_ADDR_RECEIVING) { // 处理地址字节 uint8_t addr = current_byte; i2c_read_mode = addr & 0x01; uint8_t slave_addr = (addr >> 1) & 0x7F; if (slave_addr == I2C_SLAVE_ADDR) { i2c_addr_match = 1; I2C_Send_ACK(); // 发送ACK if (i2c_read_mode) { Prepare_TX_Frame(current_function_code); i2c_state = I2C_STATE_TX_DATA; bit_counter = 0; current_byte = i2c_tx_buf[i2c_tx_index]; I2C_Set_SDA_Output(); } else { i2c_state = I2C_STATE_RX_DATA; } } else { i2c_addr_match = 0; I2C_Send_NACK(); // 发送NACK i2c_state = I2C_STATE_IDLE; } } else if (i2c_state == I2C_STATE_RX_DATA && i2c_addr_match) { // 处理数据字节 if (i2c_rx_index < FRAME_LENGTH) { i2c_rx_buf[i2c_rx_index] = current_byte; // 验证帧头 if (i2c_rx_index == 1) { if (i2c_rx_buf[0] != 0x01 || i2c_rx_buf[1] != 0xAA) { I2C_Send_NACK(); I2C_Reset_Communication(); return; } } i2c_rx_index++; I2C_Send_ACK(); // 发送ACK // 检查是否接收完成 if (i2c_rx_index == FRAME_LENGTH) { if (i2c_rx_buf[FRAME_LENGTH-1] == Calculate_XOR_Checksum(i2c_rx_buf, FRAME_LENGTH-1)) { current_function_code = i2c_rx_buf[2]; Prepare_TX_Frame(current_function_code); i2c_receive_complete = 1; } I2C_Reset_Communication(); return; } } else { I2C_Send_NACK(); I2C_Reset_Communication(); return; } } // 准备接收下一个字节 bit_counter = 0; current_byte = 0; } } } // 处理发送位 static void I2C_Process_Transmit_Bit(uint8_t scl_falling, uint8_t scl_rising) { if (i2c_state == I2C_STATE_TX_DATA && i2c_addr_match) { if (scl_falling) { // SCL下降沿，设置下一位数据 if (bit_counter < 8) { // 发送数据位 I2C_Write_SDA((current_byte & 0x80) ? 1 : 0); current_byte <<= 1; bit_counter++; } else if (bit_counter == 8) { // 释放SDA线，准备接收ACK I2C_Set_SDA_Input(); bit_counter++; } } else if (scl_rising) { if (bit_counter == 9) { // 读取ACK位 uint8_t ack = !I2C_Read_SDA(); bit_counter = 0; i2c_tx_index++; // 如果主机发送NACK或数据发送完成，结束传输 if (!ack || i2c_tx_index >= FRAME_LENGTH) { I2C_Reset_Communication(); return; } // 准备发送下一个字节 I2C_Set_SDA_Output(); current_byte = i2c_tx_buf[i2c_tx_index]; } } } } // 中断处理核心函数：处理起始/停止位并驱动状态机 static void I2C_Process_Edge(void) { uint8_t current_scl = I2C_Read_SCL(); uint8_t current_sda = I2C_Read_SDA(); uint8_t scl_rising = (current_scl && !last_scl_level); // SCL上升沿 uint8_t scl_falling = (!current_scl && last_scl_level); // SCL下降沿 uint8_t sda_changed = (current_sda != last_sda_level); // SDA电平变化 // 检测起始信号：SCL高电平时，SDA出现下降沿 if (last_scl_level && current_scl && sda_changed && !current_sda) { if (last_sda_level) { // 确保是从高到低变化 // 检测到起始信号 I2C_Reset_Communication(); i2c_state = I2C_STATE_ADDR_RECEIVING; } } // 检测停止信号：SCL高电平时，SDA出现上升沿 else if (last_scl_level && current_scl && sda_changed && current_sda) { if (!last_sda_level) { // 确保是从低到高变化 // 检测到停止信号 I2C_Reset_Communication(); } } // 处理当前状态 else { switch(i2c_state) { case I2C_STATE_ADDR_RECEIVING: case I2C_STATE_RX_DATA: I2C_Process_Receive_Bit(scl_rising); break; case I2C_STATE_TX_DATA: I2C_Process_Transmit_Bit(scl_falling, scl_rising); break; default: break; } } // 更新历史电平 last_scl_level = current_scl; last_sda_level = current_sda; // 重置超时计数器 comm_timeout = 0; } // I2C初始化函数 void I2C_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; // 配置SCL引脚为输入，双边沿中断 GPIO_InitStruct.Pin = I2C_SCL_PIN; GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(I2C_GPIO_PORT, &GPIO_InitStruct); // 配置SDA引脚为输入，双边沿中断 GPIO_InitStruct.Pin = I2C_SDA_PIN; GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(I2C_GPIO_PORT, &GPIO_InitStruct); // 使能并设置中断优先级 HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0); HAL_NVIC_EnableIRQ(EXTI4_15_IRQn); // 初始化状态 I2C_Reset_Communication(); } // 超时处理函数，应在定时器中断中周期性调用 void I2C_Timeout_Handler(void) { if (i2c_state != I2C_STATE_IDLE) { comm_timeout++; if (comm_timeout >= COMM_TIMEOUT_THRESHOLD) { I2C_Reset_Communication(); } } } // 添加中断锁防止重入 static volatile uint8_t in_interrupt = 0; // 中断回调函数(处理SCL和SDA引脚中断) void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { if (in_interrupt) return; in_interrupt = 1; if (GPIO_Pin == I2C_SCL_PIN || GPIO_Pin == I2C_SDA_PIN) { __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin); I2C_Process_Edge(); // 在中断中处理边沿和状态机 } in_interrupt = 0; } 目前需要更改功能，主机会发送01 AA 功能码01或者02 16个00 校验位。从机需要根据功能码将01或者02的数据传给主机。
09-19
我们在停止条件时也会重置通信（在检测到停止信号时调用I2C_Reset_Communication），所以状态机被重置，可以接收下一次传输。 所以，代码逻辑基本正确。 但是，我们还需要注意：在接收过程中，当接收完地址字节...
缓存决定性能上限：L1_L2 Cache在ESP32AI图像卷积运算中的5种优化模式
[缓存决定性能上限：L1_L2 Cache在ESP32AI图像卷积运算中的5种优化模式](https://www.escapelife.site/images/python-lru-cache-deep.jpg) # 1. 缓存决定性能上限：L1/L2 Cache与ESP32AI架构深度解析 在边缘AI计算...
#include "spi_slave_server.h" // SPI 库 #include <SPI.h> #include <ESP32SPISlave.h> #include "helper.h" #include <main.h> ESP32SPISlave slave; // 自定义引脚 #define MY_CS 12 #define MY_SCK 13 #define MY_MOSI 14 #define MY_MISO 11 // 启用 SPI Slave 功能 #define SPI_SLAVE_ENABLE 1 // 超时设置（微秒） #define SPI_READ_TIMEOUT 999999 #define SPI_TX_CACHE_BUF_LEN 1024 static volatile uint8_t spi_tx_cache_buf[SPI_TX_CACHE_BUF_LEN]; static volatile int spi_tx_cache_buf_cnt = 0; // 实现缺失的函数 int spi_slave_data_cache_add(uint8_t *data, uint16_t len) { if (len > SPI_TX_CACHE_BUF_LEN) len = SPI_TX_CACHE_BUF_LEN; for (int i = 0; i < len; ++i) spi_tx_cache_buf[i] = data[i]; spi_tx_cache_buf_cnt = len; return 0; } // 扩展缓冲区至 64 字节以容纳 33 字节的有效响应 static constexpr size_t SPI_BUFFER_SIZE = 64; static constexpr size_t QUEUE_SIZE = 1; // SPI 发送/接收缓冲区 static uint8_t spi_tx_buf[SPI_BUFFER_SIZE] = {0}; static uint8_t spi_rx_buf[SPI_BUFFER_SIZE] = {0}; // 用户命令定义 #define SPI_USER_CMD_NULL 0 #define SPI_USER_CMD_READ 1 #define SPI_USER_CMD_WRITE 2 // 当前命令状态 static volatile int spi_current_cmd = SPI_USER_CMD_NULL; static volatile int spi_current_cmd_len = 0; // 包序号或控制标志 // 发送忙标志（预留扩展） static uint8_t spi_send_busy = 0; static uint8_t spi_send_mode = 1; /** * 生成 16 个随机 16 位数据，并写入 buffer（32 字节） */ void generate_random_16bit_data(uint8_t *buffer, int count) { for (int i = 0; i < count; i++) { uint16_t val = random(0xFFFF); // 随机 16 位值 buffer[i * 2 + 0] = (val >> 8) & 0xFF; // 高字节 buffer[i * 2 + 1] = val & 0xFF; // 低字节 } } /** * SPI 事务完成后的回调函数（放在 IRAM 中保证中断快速响应） */ void IRAM_ATTR my_post_setup_cb(spi_slave_transaction_t *trans) { // 如果当前处于读取模式且尚未响应，则构造 0xAA + 32字节数据 if (spi_current_cmd == SPI_USER_CMD_READ && spi_current_cmd_len == 0) { memset(spi_tx_buf, 0, SPI_BUFFER_SIZE); // 清空缓冲区 spi_tx_buf[0] = 0xAA; // 回复标识 generate_random_16bit_data(spi_tx_buf + 1, 16); // 写入 16 个 16 位随机数（32字节） // 标记已响应，防止重复发送 spi_current_cmd_len = 1; } else { // 默认响应（可用于调试） memset(spi_tx_buf, 0, SPI_BUFFER_SIZE); spi_tx_buf[0] = 0xAB; spi_tx_buf[1] = spi_current_cmd_len; spi_tx_buf[2] = millis() >> 8; spi_tx_buf[3] = millis(); } } /** * SPI Slave 任务（FreeRTOS 任务） */ static void spi_slave_task(void *pvParameters) { size_t received_bytes; while (1) { int cs = digitalRead(MY_CS); #if SPI_SLAVE_ENABLE if (cs == 0) { // 片选拉低，表示主设备开始通信 memset(spi_rx_buf, 0, SPI_BUFFER_SIZE); // 执行一次 SPI 传输（阻塞直到完成或超时） received_bytes = slave.transfer(spi_tx_buf, spi_rx_buf, SPI_BUFFER_SIZE, SPI_READ_TIMEOUT); if (received_bytes > 0) { printf_log_hex("SPI RX", spi_rx_buf, received_bytes); // 检查是否收到 0xAA 命令（假设命令在第一个字节） if (spi_rx_buf[0] == 0xAA) { spi_current_cmd = SPI_USER_CMD_READ; spi_current_cmd_len = 0; // 准备下次回复 printf("SPI Slave: Received 0xAA command, will respond in next transaction.\n"); } // 调用回调函数准备下一次的响应数据 my_post_setup_cb(NULL); } } #endif vTaskDelay(5 / portTICK_PERIOD_MS); // 小延时避免 CPU 占满 } } /** * 初始化 SPI Slave */ void spi_slave_server_init(void) { #if SPI_SLAVE_ENABLE // 设置 SPI 模式（MODE3 示例） slave.setDataMode(SPI_MODE3); slave.setQueueSize(QUEUE_SIZE); // 初始化 SPI Slave（使用 HSPI，自定义引脚） slave.begin(HSPI, MY_SCK, MY_MISO, MY_MOSI, MY_CS); // 初始化随机种子（用于生成随机数） randomSeed(micros()); // 创建 SPI 从机任务 xTaskCreate(spi_slave_task, "spi_slave_task", 8192, NULL, 2, NULL); printf("SPI Slave initialized in MODE3, Buffer Size: %d\n", SPI_BUFFER_SIZE); #endif } 将发送的数据改为有规律的数
09-27
当主机读取响应时，会收到如下数据（前 33 字节）： ``` AA 00 00 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 08 00 09 00 0A 00 0B 00 0C 00 0D 00 0E 00 0F ``` 即代表： - 第一个数：`0x0000` - 第二个数...
ror(rails)中使用tinymce过程详解及问题解答_20090707更新
06-14 600
前几天在ror中学习使用tinymce，从安装到使用，过程中还有一些问题，查了网上的一些资料，自己也琢磨了一些，现在整理一下，做个总结。   1、下载plugin。 http://github.com/kete/tiny_mce/tree/master   2、安装 将下载的东东解压后，拷贝到rails工程的vendor/plugins文件夹下，注意，tinymce插件的文件夹名
rails 2.3.2 二级域名多级域名session问题
06-14 584
rails 2.3.2 下，为保证主域名与子域名session均有效，需要在environment.rb文件中加入下列声明。 config.action_controller.session = {:domain => '.hulian56.com'}
上传文件plugin：upload_column 比 file_column强得多！
06-14 516
优于file_column是显而易见的。 本人发现的几处： 1、验证出错时，upload_column提供了自定义错误消息接口。file_column的消息是固定英文的，虽说可以改其源文件，但直接改plugin总是别扭些，也影响update。 2、upload_column提供了更全面的图片处理接口。不仅可以选择处理器，而且对于图片的处理也提供了单独调用处理器的方式。 　　如：使用file
acts_as_list要单独安装，不是标配
06-14 502
http://github.com/rails/acts_as_list/tree/master
文章浏览次数如何做才好呢？
06-14 480
目前想到一个方法： 在表中增加一个字段，存一个最后来访者的ip，再cookie中存一个id（存最后10个id，是不是更保险？），这样就可以防止有人乱刷了。   不知道流行做法是什么。     参考老外写的一个简单的：http://socialect.com/topic/2009/3/22/page-view-counter-in-rails
Rails路由
06-14 476
由于总结的比较全，读起来很好用，在下转过来了，全当是方便自己看。 原文网址：http://hi.baidu.com/haifreeidea/blog/item/57b0f50e5ae133226159f37b.html   Rails路由（一） 此文原文在http://guides.rubyonrails.org/routing.html。这是我根据自己的理解作的一些笔记。 1 使
碰到一个保留字段？ hits
06-14 467
在mysql中定义了一个hits名的字段，结果没法用。。。。。 难道是rails的保留字段？太神奇了，在google也没查到。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值