revert b3c6b4cde9

revert 修复红外的兼容性问题

Dorm-Air-Conditioner-Smart-Controller.ino

@@ -190,11 +190,8 @@ void sendStoredIRSignal(String buttonName) {
 // 从字符串解析红外信号
 IRSignal parseIRSignalFromString(String dataStr) {
   IRSignal signal;
-  signal.markTimes = nullptr;
+  signal.data = nullptr;
-  signal.spaceTimes = nullptr;
+  signal.length = 0;
-  signal.markCount = 0;
-  signal.spaceCount = 0;
-  signal.carrierFreq = IR_CARRIER_FREQ;
   signal.isValid = false;
   
   if (dataStr.length() == 0) {
@@ -206,11 +203,11 @@ IRSignal parseIRSignalFromString(String dataStr) {
   for (int i = 0; i < dataStr.length(); i++) {
     if (dataStr[i] == ',') commaCount++;
   }
-  int totalLength = commaCount + 1;
+  signal.length = commaCount + 1;
   
-  // 分配临时内存存储原始数据
+  // 分配内存
-  unsigned int* tempData = (unsigned int*)malloc(totalLength * sizeof(unsigned int));
+  signal.data = (unsigned int*)malloc(signal.length * sizeof(unsigned int));
-  if (tempData == nullptr) {
+  if (signal.data == nullptr) {
     return signal;
   }
   
@@ -220,78 +217,27 @@ IRSignal parseIRSignalFromString(String dataStr) {
   for (int i = 0; i <= dataStr.length(); i++) {
     if (i == dataStr.length() || dataStr[i] == ',') {
       String valueStr = dataStr.substring(startPos, i);
-      tempData[index] = valueStr.toInt();
+      signal.data[index] = valueStr.toInt();
       index++;
       startPos = i + 1;
     }
   }
   
-  // 分离mark和space数据
-  signal.markCount = (totalLength + 1) / 2;
-  signal.spaceCount = totalLength / 2;
-  
-  // 分配mark时间数组
-  if (signal.markCount > 0) {
-    signal.markTimes = (unsigned int*)malloc(signal.markCount * sizeof(unsigned int));
-    if (signal.markTimes == nullptr) {
-      free(tempData);
-      return signal;
-    }
-    
-    for (int i = 0; i < signal.markCount; i++) {
-      signal.markTimes[i] = tempData[i * 2];
-    }
-  }
-  
-  // 分配space时间数组
-  if (signal.spaceCount > 0) {
-    signal.spaceTimes = (unsigned int*)malloc(signal.spaceCount * sizeof(unsigned int));
-    if (signal.spaceTimes == nullptr) {
-      if (signal.markTimes != nullptr) {
-        free(signal.markTimes);
-        signal.markTimes = nullptr;
-        signal.markCount = 0;
-      }
-      free(tempData);
-      return signal;
-    }
-    
-    for (int i = 0; i < signal.spaceCount; i++) {
-      signal.spaceTimes[i] = tempData[i * 2 + 1];
-    }
-  }
-  
-  free(tempData);
   signal.isValid = true;
   return signal;
 }
 
 // 将红外信号转换为字符串
 String irSignalToString(const IRSignal& signal) {
-  if (!signal.isValid || 
+  if (!signal.isValid || signal.data == nullptr || signal.length == 0) {
-      (signal.markTimes == nullptr && signal.spaceTimes == nullptr) || 
-      (signal.markCount == 0 && signal.spaceCount == 0)) {
     return "";
   }
   
   String result = "";
-  int maxCount = max(signal.markCount, signal.spaceCount);
+  for (int i = 0; i < signal.length; i++) {
-  
+    if (i > 0) result += ",";
-  // 重建原始时序数据：交替输出mark和space
+    result += String(signal.data[i]);
-  for (int i = 0; i < maxCount; i++) {
-    // 添加mark时间
-    if (i < signal.markCount) {
-      if (result.length() > 0) result += ",";
-      result += String(signal.markTimes[i]);
-    }
-    
-    // 添加space时间
-    if (i < signal.spaceCount) {
-      if (result.length() > 0) result += ",";
-      result += String(signal.spaceTimes[i]);
-    }
   }
-  
   return result;
 }
 
@@ -805,7 +751,7 @@ void handleStartRecord() {
     prefs.putString(("ir_" + buttonName).c_str(), irDataStr);
     
     Serial.println("红外信号录入成功: " + buttonName);
-    Serial.println("mark数量: " + String(signal.markCount) + ", space数量: " + String(signal.spaceCount));
+    Serial.println("信号长度: " + String(signal.length));
     
     freeIRSignal(signal);
     server.send(200, "application/json", "{\"success\":true}");
@@ -822,7 +768,7 @@ void handleSendIR() {
     return;
   }
   
-  DynamicJsonDocument doc(26700);
+  DynamicJsonDocument doc(200);
   deserializeJson(doc, server.arg("plain"));
   
   String buttonName = doc["button"];

ir_control.cpp

@@ -1,323 +1,169 @@
 #include "ir_control.h"
 
 void initIRControl() {
-    // 配置RMT发送通道
+    pinMode(IR_RECEIVE_PIN, INPUT);
-    rmt_config_t rmt_tx_config = RMT_DEFAULT_CONFIG_TX((gpio_num_t)IR_SEND_PIN, RMT_TX_CHANNEL);
+    pinMode(IR_SEND_PIN, OUTPUT);
-    rmt_tx_config.clk_div = RMT_CLK_DIV;
+    digitalWrite(IR_SEND_PIN, LOW);
-    rmt_tx_config.mem_block_num = RMT_MEM_BLOCK_NUM;
-    rmt_tx_config.tx_config.carrier_en = RMT_TX_CARRIER_EN;
-    rmt_tx_config.tx_config.carrier_freq_hz = RMT_TX_CARRIER_FREQ_HZ;
-    rmt_tx_config.tx_config.carrier_duty_percent = RMT_TX_CARRIER_DUTY_PERCENT;
-    rmt_tx_config.tx_config.carrier_level = RMT_TX_CARRIER_LEVEL;
-    rmt_tx_config.tx_config.idle_level = RMT_IDLE_LEVEL;
-    rmt_tx_config.tx_config.idle_output_en = true;
     
-    esp_err_t err = rmt_config(&rmt_tx_config);
+    Serial.println("红外控制模块初始化完成");
-    if (err != ESP_OK) {
+    Serial.print("接收引脚: ");
-        Serial.printf("RMT发送通道配置失败: %s\n", esp_err_to_name(err));
+    Serial.println(IR_RECEIVE_PIN);
-        return;
+    Serial.print("发送引脚: ");
-    }
+    Serial.println(IR_SEND_PIN);
-    
-    err = rmt_driver_install(RMT_TX_CHANNEL, 0, 0);
-    if (err != ESP_OK) {
-        Serial.printf("RMT发送驱动安装失败: %s\n", esp_err_to_name(err));
-        return;
-    }
-    
-    // 配置RMT接收通道
-    rmt_config_t rmt_rx_config = RMT_DEFAULT_CONFIG_RX((gpio_num_t)IR_RECEIVE_PIN, RMT_RX_CHANNEL);
-    rmt_rx_config.clk_div = RMT_CLK_DIV;
-    rmt_rx_config.mem_block_num = RMT_MEM_BLOCK_NUM;
-    rmt_rx_config.rx_config.filter_en = RMT_RX_FILTER_EN;
-    rmt_rx_config.rx_config.filter_ticks_thresh = RMT_RX_FILTER_THRESH_US;
-    rmt_rx_config.rx_config.idle_threshold = RMT_RX_IDLE_THRESH_US;
-    
-    err = rmt_config(&rmt_rx_config);
-    if (err != ESP_OK) {
-        Serial.printf("RMT接收通道配置失败: %s\n", esp_err_to_name(err));
-        return;
-    }
-    
-    err = rmt_driver_install(RMT_RX_CHANNEL, 1000, 0);
-    if (err != ESP_OK) {
-        Serial.printf("RMT接收驱动安装失败: %s\n", esp_err_to_name(err));
-        return;
-    }
-    
-    Serial.println("红外控制模块初始化完成 (使用RMT)");
-    Serial.printf("发送引脚: %d (RMT通道: %d)\n", IR_SEND_PIN, RMT_TX_CHANNEL);
-    Serial.printf("接收引脚: %d (RMT通道: %d)\n", IR_RECEIVE_PIN, RMT_RX_CHANNEL);
-    Serial.printf("载波频率: %d Hz\n", RMT_TX_CARRIER_FREQ_HZ);
-    Serial.printf("时钟分辨率: %d us\n", RMT_CLK_DIV);
 }
 
 bool checkIRSignalStart() {
-    // 使用RMT检查是否有信号开始
+    return (digitalRead(IR_RECEIVE_PIN) == LOW);
-    // 启动接收并检查是否立即有数据
-    rmt_rx_start(RMT_RX_CHANNEL, true);
-    
-    // 等待短时间检查是否有信号
-    vTaskDelay(pdMS_TO_TICKS(1));
-    
-    // 获取RMT环形缓冲区句柄
-    RingbufHandle_t rb = NULL;
-    esp_err_t err = rmt_get_ringbuf_handle(RMT_RX_CHANNEL, &rb);
-    if (err != ESP_OK) {
-        rmt_rx_stop(RMT_RX_CHANNEL);
-        return false;
-    }
-    
-    // 检查RMT接收缓冲区是否有数据
-    size_t rx_size = 0;
-    rmt_item32_t* items = (rmt_item32_t*)xRingbufferReceive(rb, &rx_size, 0);
-    
-    bool hasSignal = (items != nullptr && rx_size > 0);
-    
-    if (items) {
-        vRingbufferReturnItem(rb, (void*)items);
-    }
-    
-    rmt_rx_stop(RMT_RX_CHANNEL);
-    
-    return hasSignal;
 }
 
 IRSignal receiveIRSignal() {
     IRSignal signal;
-    signal.markTimes = nullptr;
+    signal.data = nullptr;
-    signal.spaceTimes = nullptr;
+    signal.length = 0;
-    signal.markCount = 0;
-    signal.spaceCount = 0;
-    signal.carrierFreq = IR_CARRIER_FREQ;
     signal.isValid = false;
     
-    Serial.println("开始接收红外信号 (使用RMT)...");
+    Serial.println("开始接收红外信号...");
     
-    // 启动RMT接收
+    // 分配内存存储信号数据
-    rmt_rx_start(RMT_RX_CHANNEL, true);
+    signal.data = (unsigned int*)malloc(MAX_SIGNAL_LENGTH * sizeof(unsigned int));
-    
+    if (signal.data == nullptr) {
-    // 获取RMT环形缓冲区句柄
+        Serial.println("内存分配失败");
-    RingbufHandle_t rb = NULL;
-    esp_err_t err = rmt_get_ringbuf_handle(RMT_RX_CHANNEL, &rb);
-    if (err != ESP_OK) {
-        Serial.printf("获取RMT缓冲区句柄失败: %s\n", esp_err_to_name(err));
-        rmt_rx_stop(RMT_RX_CHANNEL);
         return signal;
     }
     
-    // 等待接收数据
+    unsigned long startTime = micros();
-    size_t rx_size = 0;
+    unsigned long lastChange = startTime;
-    rmt_item32_t* items = (rmt_item32_t*)xRingbufferReceive(rb, &rx_size, pdMS_TO_TICKS(RECEIVE_TIMEOUT_US / 1000));
+    bool currentState = HIGH;
+    bool lastState = HIGH;
     
-    if (items == nullptr || rx_size == 0) {
+    // 等待信号开始（第一个低电平）
-        Serial.println("RMT接收超时或无数据");
+    while (digitalRead(IR_RECEIVE_PIN) == HIGH && (micros() - startTime) < RECEIVE_TIMEOUT_US) {
-        rmt_rx_stop(RMT_RX_CHANNEL);
+        delayMicroseconds(10);
+    }
+    
+    if ((micros() - startTime) >= RECEIVE_TIMEOUT_US) {
+        Serial.println("等待信号超时");
+        free(signal.data);
+        signal.data = nullptr;
         return signal;
     }
     
-    // 计算接收到的项目数量
+    Serial.println("检测到信号开始");
-    size_t item_count = rx_size / sizeof(rmt_item32_t);
+    lastChange = micros();
-    Serial.printf("接收到 %d 个RMT项目\n", item_count);
+    lastState = LOW;
+    signal.length = 0;
     
-    if (item_count == 0) {
+    // 接收信号数据
-        Serial.println("接收到的数据为空");
+    while (signal.length < MAX_SIGNAL_LENGTH) {
-        vRingbufferReturnItem(rb, (void*)items);
+        currentState = digitalRead(IR_RECEIVE_PIN);
-        rmt_rx_stop(RMT_RX_CHANNEL);
-        return signal;
-    }
-    
-    // 分配临时数组存储时序数据
-    unsigned int* tempData = (unsigned int*)malloc(item_count * 2 * sizeof(unsigned int));
-    if (tempData == nullptr) {
-        Serial.println("临时数据内存分配失败");
-        vRingbufferReturnItem(rb, (void*)items);
-        rmt_rx_stop(RMT_RX_CHANNEL);
-        return signal;
-    }
-    
-    int tempLength = 0;
-    
-    // 解析RMT数据项
-    for (size_t i = 0; i < item_count; i++) {
-        // 每个RMT项目包含两个时间段：level0的持续时间和level1的持续时间
-        if (items[i].duration0 > 0 && tempLength < item_count * 2) {
-            tempData[tempLength++] = items[i].duration0;
-        }
-        if (items[i].duration1 > 0 && tempLength < item_count * 2) {
-            tempData[tempLength++] = items[i].duration1;
-        }
-    }
-    
-    // 释放RMT缓冲区
-    vRingbufferReturnItem(rb, (void*)items);
-    rmt_rx_stop(RMT_RX_CHANNEL);
-    
-    if (tempLength > 0) {
-        // 分离mark和space时间
-        signal.markCount = (tempLength + 1) / 2;  // 奇数索引是mark
-        signal.spaceCount = tempLength / 2;       // 偶数索引是space
         
-        // 分配mark时间数组
+        if (currentState != lastState) {
-        if (signal.markCount > 0) {
+            // 状态改变，记录持续时间
-            signal.markTimes = (unsigned int*)malloc(signal.markCount * sizeof(unsigned int));
+            unsigned long duration = micros() - lastChange;
-            if (signal.markTimes == nullptr) {
+            signal.data[signal.length] = duration;
-                Serial.println("mark时间数组内存分配失败");
+            signal.length++;
-                free(tempData);
-                return signal;
-            }
             
-            // 复制mark时间（从索引0开始，每隔2个取一个）
+            lastState = currentState;
-            for (int i = 0; i < signal.markCount; i++) {
+            lastChange = micros();
-                signal.markTimes[i] = tempData[i * 2];
-            }
         }
         
-        // 分配space时间数组
+        // 检查是否信号结束（高电平持续时间过长）
-        if (signal.spaceCount > 0) {
+        if (currentState == HIGH && (micros() - lastChange) > SIGNAL_END_TIMEOUT_US) {
-            signal.spaceTimes = (unsigned int*)malloc(signal.spaceCount * sizeof(unsigned int));
+            Serial.println("检测到信号结束");
-            if (signal.spaceTimes == nullptr) {
+            break;
-                Serial.println("space时间数组内存分配失败");
-                if (signal.markTimes != nullptr) {
-                    free(signal.markTimes);
-                    signal.markTimes = nullptr;
-                }
-                free(tempData);
-                return signal;
-            }
-            
-            // 复制space时间（从索引1开始，每隔2个取一个）
-            for (int i = 0; i < signal.spaceCount; i++) {
-                signal.spaceTimes[i] = tempData[i * 2 + 1];
-            }
         }
         
+        // 总体超时检查
+        if ((micros() - startTime) > RECEIVE_TIMEOUT_US) {
+            Serial.println("接收总体超时");
+            break;
+        }
+    }
+    
+    if (signal.length > 0) {
         signal.isValid = true;
-        Serial.printf("RMT信号接收成功，mark数量: %d, space数量: %d\n", signal.markCount, signal.spaceCount);
+        Serial.print("信号接收成功，长度: ");
+        Serial.println(signal.length);
+        
+        // 重新分配内存以节省空间
+        signal.data = (unsigned int*)realloc(signal.data, signal.length * sizeof(unsigned int));
+        if (signal.data == nullptr) {
+            Serial.println("内存重新分配失败");
+            signal.isValid = false;
+            signal.length = 0;
+        }
     } else {
-        Serial.println("未接收到有效的RMT信号数据");
+        Serial.println("未接收到有效信号");
+        free(signal.data);
+        signal.data = nullptr;
     }
     
-    free(tempData);
     return signal;
 }
 
-// generateCarrier函数已被RMT模块替代，不再需要
-
 bool sendIRSignal(const IRSignal& signal) {
     if (!isValidIRSignal(signal)) {
         Serial.println("信号无效，无法发送");
         return false;
     }
     
-    Serial.println("开始发送红外信号 (使用RMT)...");
+    Serial.println("开始发送红外信号...");
-    Serial.printf("载波频率: %d Hz\n", signal.carrierFreq);
+    Serial.print("信号长度: ");
-    Serial.printf("mark数量: %d, space数量: %d\n", signal.markCount, signal.spaceCount);
+    Serial.println(signal.length);
     
-    // 计算需要的RMT项目数量
+    // 禁用中断以确保精确的时序
-    int maxCount = max(signal.markCount, signal.spaceCount);
+    noInterrupts();
-    size_t item_count = maxCount;
     
-    // 分配RMT项目数组
+    bool state = LOW; // 红外信号通常以低电平开始
-    rmt_item32_t* items = (rmt_item32_t*)malloc(item_count * sizeof(rmt_item32_t));
+    
-    if (items == nullptr) {
+    for (int i = 0; i < signal.length; i++) {
-        Serial.println("RMT项目内存分配失败");
+        digitalWrite(IR_SEND_PIN, state);
-        return false;
+        delayMicroseconds(signal.data[i]);
+        state = !state; // 切换状态
     }
     
-    // 构建RMT数据项
+    // 确保最后是低电平
-    for (int i = 0; i < maxCount; i++) {
+    digitalWrite(IR_SEND_PIN, LOW);
-        items[i].level0 = 1;  // mark期间为高电平（载波调制）
-        items[i].duration0 = (i < signal.markCount) ? signal.markTimes[i] : 0;
-        
-        items[i].level1 = 0;  // space期间为低电平（无载波）
-        items[i].duration1 = (i < signal.spaceCount) ? signal.spaceTimes[i] : 0;
-    }
     
-    // 发送RMT数据
+    // 重新启用中断
-    esp_err_t err = rmt_write_items(RMT_TX_CHANNEL, items, item_count, true);
+    interrupts();
     
-    if (err != ESP_OK) {
+    Serial.println("信号发送完成");
-        Serial.printf("RMT发送失败: %s\n", esp_err_to_name(err));
-        free(items);
-        return false;
-    }
-    
-    // 等待发送完成
-    err = rmt_wait_tx_done(RMT_TX_CHANNEL, pdMS_TO_TICKS(1000));
-    
-    if (err != ESP_OK) {
-        Serial.printf("RMT发送等待超时: %s\n", esp_err_to_name(err));
-        free(items);
-        return false;
-    }
-    
-    free(items);
-    Serial.println("RMT信号发送完成");
     return true;
 }
 
 void freeIRSignal(IRSignal& signal) {
-    if (signal.markTimes != nullptr) {
+    if (signal.data != nullptr) {
-        free(signal.markTimes);
+        free(signal.data);
-        signal.markTimes = nullptr;
+        signal.data = nullptr;
     }
-    if (signal.spaceTimes != nullptr) {
+    signal.length = 0;
-        free(signal.spaceTimes);
-        signal.spaceTimes = nullptr;
-    }
-    signal.markCount = 0;
-    signal.spaceCount = 0;
-    signal.carrierFreq = 0;
     signal.isValid = false;
 }
 
 IRSignal copyIRSignal(const IRSignal& source) {
     IRSignal copy;
-    copy.markTimes = nullptr;
+    copy.data = nullptr;
-    copy.spaceTimes = nullptr;
+    copy.length = 0;
-    copy.markCount = 0;
-    copy.spaceCount = 0;
-    copy.carrierFreq = 0;
     copy.isValid = false;
     
     if (!isValidIRSignal(source)) {
         return copy;
     }
     
-    // 复制mark时间数组
+    // 分配内存
-    if (source.markCount > 0 && source.markTimes != nullptr) {
+    copy.data = (unsigned int*)malloc(source.length * sizeof(unsigned int));
-        copy.markTimes = (unsigned int*)malloc(source.markCount * sizeof(unsigned int));
+    if (copy.data == nullptr) {
-        if (copy.markTimes == nullptr) {
+        Serial.println("复制信号时内存分配失败");
-            Serial.println("复制mark时间数组时内存分配失败");
+        return copy;
-            return copy;
-        }
-        
-        for (int i = 0; i < source.markCount; i++) {
-            copy.markTimes[i] = source.markTimes[i];
-        }
-        copy.markCount = source.markCount;
     }
     
-    // 复制space时间数组
+    // 复制数据
-    if (source.spaceCount > 0 && source.spaceTimes != nullptr) {
+    for (int i = 0; i < source.length; i++) {
-        copy.spaceTimes = (unsigned int*)malloc(source.spaceCount * sizeof(unsigned int));
+        copy.data[i] = source.data[i];
-        if (copy.spaceTimes == nullptr) {
-            Serial.println("复制space时间数组时内存分配失败");
-            if (copy.markTimes != nullptr) {
-                free(copy.markTimes);
-                copy.markTimes = nullptr;
-                copy.markCount = 0;
-            }
-            return copy;
-        }
-        
-        for (int i = 0; i < source.spaceCount; i++) {
-            copy.spaceTimes[i] = source.spaceTimes[i];
-        }
-        copy.spaceCount = source.spaceCount;
     }
     
-    copy.carrierFreq = source.carrierFreq;
+    copy.length = source.length;
     copy.isValid = true;
     
     return copy;
@@ -330,56 +176,33 @@ void printIRSignal(const IRSignal& signal, int maxPrint) {
     }
     
     Serial.println("=== 红外信号数据 ===");
-    Serial.print("载波频率: ");
+    Serial.print("信号长度: ");
-    Serial.print(signal.carrierFreq);
+    Serial.println(signal.length);
-    Serial.println(" Hz");
-    Serial.print("mark数量: ");
-    Serial.println(signal.markCount);
-    Serial.print("space数量: ");
-    Serial.println(signal.spaceCount);
     Serial.print("信号有效: ");
     Serial.println(signal.isValid ? "是" : "否");
     
-    // 打印mark时间
+    int printCount = (maxPrint == 0) ? signal.length : min(maxPrint, signal.length);
-    int markPrintCount = (maxPrint == 0) ? signal.markCount : min(maxPrint, signal.markCount);
+    
-    Serial.println("Mark时间 (微秒):");
+    Serial.println("原始数据 (微秒):");
-    for (int i = 0; i < markPrintCount; i++) {
+    for (int i = 0; i < printCount; i++) {
-        Serial.print("Mark ");
+        Serial.print("Index ");
         Serial.print(i);
         Serial.print(": ");
-        Serial.print(signal.markTimes[i]);
+        Serial.print(signal.data[i]);
-        Serial.println(" us");
+        Serial.print(" us (");
+        Serial.print((i % 2 == 0) ? "LOW" : "HIGH");
+        Serial.println(")");
     }
     
-    if (markPrintCount < signal.markCount) {
+    if (printCount < signal.length) {
         Serial.print("... 还有 ");
-        Serial.print(signal.markCount - markPrintCount);
+        Serial.print(signal.length - printCount);
-        Serial.println(" 个mark数据点未显示");
+        Serial.println(" 个数据点未显示");
-    }
-    
-    // 打印space时间
-    int spacePrintCount = (maxPrint == 0) ? signal.spaceCount : min(maxPrint, signal.spaceCount);
-    Serial.println("Space时间 (微秒):");
-    for (int i = 0; i < spacePrintCount; i++) {
-        Serial.print("Space ");
-        Serial.print(i);
-        Serial.print(": ");
-        Serial.print(signal.spaceTimes[i]);
-        Serial.println(" us");
-    }
-    
-    if (spacePrintCount < signal.spaceCount) {
-        Serial.print("... 还有 ");
-        Serial.print(signal.spaceCount - spacePrintCount);
-        Serial.println(" 个space数据点未显示");
     }
     
     Serial.println("==================");
 }
 
 bool isValidIRSignal(const IRSignal& signal) {
-    return (signal.isValid && 
+    return (signal.data != nullptr && signal.length > 0 && signal.isValid);
-            ((signal.markTimes != nullptr && signal.markCount > 0) || 
-             (signal.spaceTimes != nullptr && signal.spaceCount > 0)) &&
-            signal.carrierFreq > 0);
 }

ir_control.h

@@ -2,17 +2,12 @@
 #define IR_CONTROL_H
 
 #include <Arduino.h>
-#include "driver/rmt.h"
-#include "driver/gpio.h"
 
 // 红外信号结构体
 struct IRSignal {
-    unsigned int* markTimes;    // mark时间数组（微秒）
+    unsigned int* data;     // 原始信号数据数组（微秒）
-    unsigned int* spaceTimes;   // space时间数组（微秒）
+    int length;            // 信号长度
-    int markCount;             // mark数量
+    bool isValid;          // 信号是否有效
-    int spaceCount;            // space数量
-    unsigned int carrierFreq;   // 载波频率（Hz）
-    bool isValid;              // 信号是否有效
 };
 
 // 配置参数
@@ -21,22 +16,6 @@ struct IRSignal {
 #define MAX_SIGNAL_LENGTH 1000
 #define RECEIVE_TIMEOUT_US 1000000  // 1秒接收超时
 #define SIGNAL_END_TIMEOUT_US 50000 // 50ms信号结束判断
-#define IR_CARRIER_FREQ 38000       // 38kHz载波频率
-#define CARRIER_PERIOD_US 26        // 38kHz载波周期（微秒）
-
-// RMT配置参数
-#define RMT_TX_CHANNEL RMT_CHANNEL_0    // RMT发送通道
-#define RMT_RX_CHANNEL RMT_CHANNEL_1    // RMT接收通道
-#define RMT_CLK_DIV 80                  // RMT时钟分频器 (80MHz / 80 = 1MHz, 1us分辨率)
-#define RMT_MEM_BLOCK_NUM 1             // RMT内存块数量
-#define RMT_TX_CARRIER_EN true          // 启用发送载波
-#define RMT_TX_CARRIER_FREQ_HZ 38000    // 发送载波频率
-#define RMT_TX_CARRIER_DUTY_PERCENT 33  // 载波占空比
-#define RMT_TX_CARRIER_LEVEL RMT_CARRIER_LEVEL_HIGH  // 载波电平
-#define RMT_IDLE_LEVEL RMT_IDLE_LEVEL_LOW            // 空闲电平
-#define RMT_RX_FILTER_EN true           // 启用接收滤波器
-#define RMT_RX_FILTER_THRESH_US 100     // 接收滤波器阈值(微秒)
-#define RMT_RX_IDLE_THRESH_US 10000     // 接收空闲阈值(微秒)
 
 /**
  * 初始化红外控制模块
@@ -54,12 +33,9 @@ bool checkIRSignalStart();
 
 /**
  * 接收红外信号
- * @return IRSignal 包含红外信号mark/space时序和载波频率的结构体
+ * @return IRSignal 包含原始红外信号数据的结构体
- *         - markTimes: 指向mark时间数组的指针
+ *         - data: 指向信号数据数组的指针
- *         - spaceTimes: 指向space时间数组的指针
+ *         - length: 信号数据长度
- *         - markCount: mark数量
- *         - spaceCount: space数量
- *         - carrierFreq: 载波频率
  *         - isValid: 是否成功接收到有效信号
  * 
  * 注意：调用者需要在使用完毕后调用 freeIRSignal() 释放内存