STM32F103_RGB_Controller/Src/RGB_Controller.c

#include "RGB_Controller.h"
extern Default_SX1276_t Default_SX1276;
extern SX1276_t SX1276;
extern SX1276_hw_t SX1276_hw;

void RGB_Response_Func(uint8_t* data);
uint8_t RGB_BufCal(uint8_t srcid);
void RGB_Alarm_Operate(void);
void RGB_Data_Stack(uint8_t* rgb_buf);
uint16_t RGB_Location_Address_Check(uint8_t id);

uint8_t SensorID_Cnt = 0;
uint8_t SensorID_buf[8] = {0,};
uint16_t RGB_SensorRedLimit_Buf[9]={0,};
uint16_t RGB_SensorGreenLimit_Buf[9]={0,};
uint16_t RGB_SensorBlueLimit_Buf[9]={0,};
uint8_t LED_Alarm[9] = {0,};
uint8_t RGB_Location_Buf[9][50] = {0};


void RGB_Data_Init(void){
    MyControllerID = M24C32_Data_Read(&hi2c2,MY_ID_ADDRESS);
  
    for(uint8_t i = 0; i < 8; i++){
        RGB_SensorRedLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_RED_H_ADDRESS + (6 * i)) << 8);
        RGB_SensorRedLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_RED_L_ADDRESS + (6 * i));
    }
    for(uint8_t i = 0; i < 8; i++){
        RGB_SensorGreenLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_GREEN_H_ADDRESS + (6 * i)) << 8);
        RGB_SensorGreenLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_GREEN_L_ADDRESS + (6 * i));
    }
    for(uint8_t i = 0; i < 8; i++){
        RGB_SensorBlueLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_BLUE_H_ADDRESS + (6 * i)) << 8);
        RGB_SensorBlueLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_BLUE_L_ADDRESS + (6 * i));
    }
    for(uint8_t i = 0; i < 8; i++){
        for(uint8_t aa= 0; aa < 50; aa++)
            RGB_Location_Buf[i + 1][aa] = M24C32_Data_Read(&hi2c2,RGB_Location_Address_Check(i + 1) + aa);
    }
    printf("MY id is %d \n",MyControllerID);
    for(uint8_t i = 1; i <= 8; i++){
        printf("RGB_SensorRedLimit_Buf[%d]    :  %04x\n",i,RGB_SensorRedLimit_Buf[i]);
        printf("RGB_SensorGreenLimit_Buf[%d]  :  %04x\n",i,RGB_SensorGreenLimit_Buf[i]);
        printf("RGB_SensorBlueLimit_Buf[%d]   :  %04x\n",i,RGB_SensorBlueLimit_Buf[i]);    
    }
    if(M24C32_Data_Read(&hi2c2,RGB_LORA_FREQ_ADDRESS) == 0xFF){
        /*NOP*/
    }else{
        Default_SX1276.frequency = M24C32_Data_Read(&hi2c2,RGB_LORA_FREQ_ADDRESS);
        Default_SX1276.power     = M24C32_Data_Read(&hi2c2,RGB_LORA_PABOOST_ADDRESS);
        Default_SX1276.LoRa_Rate = M24C32_Data_Read(&hi2c2,RGB_LORA_SF_ADDRESS);
        Default_SX1276.LoRa_BW   = M24C32_Data_Read(&hi2c2,RGB_LORA_BANDWIDTH_ADDRESS);
        Default_SX1276.LoRa_Lna  = M24C32_Data_Read(&hi2c2,RGB_LORA_LNA_ADDRESS);
    }

}
uint16_t RGB_Limit_Address_Check(uint8_t id){
    uint16_t ret = 0;
    switch(id){
        case 1: ret = RGB1_LIMIT_RED_H_ADDRESS;break;
        case 2: ret = RGB2_LIMIT_RED_H_ADDRESS;break;
        case 3: ret = RGB3_LIMIT_RED_H_ADDRESS;break;
        case 4: ret = RGB4_LIMIT_RED_H_ADDRESS;break;
        case 5: ret = RGB5_LIMIT_RED_H_ADDRESS;break;
        case 6: ret = RGB6_LIMIT_RED_H_ADDRESS;break;
        case 7: ret = RGB7_LIMIT_RED_H_ADDRESS;break;
        case 8: ret = RGB8_LIMIT_RED_H_ADDRESS;break;        
    }
    return ret;
}
uint16_t RGB_Location_Address_Check(uint8_t id){
    uint16_t ret = 0;
    switch(id){
        case 1: ret = RGB1_LOCATION_ADDRESS;break;
        case 2: ret = RGB2_LOCATION_ADDRESS;break;
        case 3: ret = RGB3_LOCATION_ADDRESS;break;
        case 4: ret = RGB4_LOCATION_ADDRESS;break;
        case 5: ret = RGB5_LOCATION_ADDRESS;break;
        case 6: ret = RGB6_LOCATION_ADDRESS;break;
        case 7: ret = RGB7_LOCATION_ADDRESS;break;
        case 8: ret = RGB8_LOCATION_ADDRESS;break;        
    }
    return ret;
}

void RGB_Response_Func(uint8_t* data){
	RGB_CMD_T type = data[bluecell_type];
    uint16_t temp  = 0;
    LoraDataRequest_t Lora_Tempdata;
#if 0
for(uint8_t i = 0; i < 10; i++){
            printf("%02x ",data[i]);
        }
#endif
    switch(type){
        case RGB_Status_Data_Request: 
            Uart2_Data_Send(data,RGB_SensorDataRequest_Length);
            break;
        case RGB_ControllerID_SET: 
            Uart1_Data_Send(data,RGB_ControllerID_SET_Length);
            M24C32_Data_Write(&hi2c2,&MyControllerID,MY_ID_ADDRESS,1); // EEPROM Controller ID Save 
            break;
        case RGB_SensorID_SET:  
            Uart2_Data_Send(data,RGB_SensorIDAutoSetRequest_Length);
            break;        
        case RGB_Status_Data_Response:
            Uart1_Data_Send(data,data[bluecell_length] + 3);
            break;
        case RGB_ControllerLimitSet:
            Uart1_Data_Send(data,data[bluecell_length] + 3);
            M24C32_Data_Write(&hi2c2,&data[bluecell_red_H],RGB_Limit_Address_Check(data[bluecell_dstid]),6); // EEPROM Controller ID Save 
            break;
        case RGB_Sensor_Start:    
        case RGB_Sensor_Check:
            Uart2_Data_Send(data,RGB_SensorIDAutoSetRequest_Length);
            break;
        case RGB_Sensor_Ack:
            Uart2_Data_Send(data,data[bluecell_length] + 3);
            break;
        case RGB_Reset:
        case RGB_SensorID_SET_Success:
        case RGB_ID_Allocate_Request:
        case RGB_Lora_ControllerIDAmount_Report:
            break;
        case RGB_Location_Report:
            M24C32_Data_Write(&hi2c2,&data[Location_stx],RGB_Location_Address_Check(data[bluecell_srcid]),data[bluecell_length] + 3); // EEPROM Controller ID Save 
            break;
        case RGB_Location_Response:
            data[bluecell_length] = M24C32_Data_Read(&hi2c2,RGB_Location_Address_Check(data[bluecell_dstid]) + 2); // EEPROM Controller ID Save 
            temp = RGB_Location_Address_Check(data[bluecell_srcid]);
            for(uint8_t i = 0; i < (data[bluecell_length] + 3); i++){
                data[i] = M24C32_Data_Read(&hi2c2,(temp + i)); // EEPROM Controller ID Save 
            }
            data[bluecell_type] = RGB_Location_Response;
            data[data[bluecell_length] + 1] = STH30_CreateCrc(&data[bluecell_type],data[bluecell_length]);
            Uart1_Data_Send(data,data[bluecell_length] + 3);    
            break;
         case RGB_ControllerID_GET:
             Uart1_Data_Send(data,data[bluecell_length] + 3);
             break;
         case RGB_ControllerLimitGet:
             Uart1_Data_Send(data,data[bluecell_length] + 3);
             break;
         case RGB_Lora_DataResponse:
             memcpy(&Lora_Tempdata.Request_stx,&data[bluecell_stx],data[bluecell_length] + 3);
             if(Lora_Tempdata.Request_dstid == MyControllerID)
                 LoraDataSendSet(1);
             else
                 return;
             break;
        case RGB_Lora_ConfigSet:
            data[bluecell_type] = RGB_Lora_ConfigGet;
            Default_SX1276.frequency     = data[3];
            Default_SX1276.LoRa_Pa_boost = data[4];
            Default_SX1276.LoRa_Rate     = data[5];
            Default_SX1276.LoRa_BW       = data[6];    
            Default_SX1276.LoRa_Lna      = data[7];        
            Lora_Initialize();
            M24C32_Data_Write(&hi2c2,&data[bluecell_srcid],RGB_LORA_FREQ_ADDRESS,data[bluecell_length] - 2); // EEPROM Controller ID Save 
        case RGB_Lora_ConfigGet:
            Uart1_Data_Send(data,data[bluecell_length] + 3);
            break;             
         default:break;
    }
}

void RGB_Sensor_LED_Alarm_ON(uint8_t id ){
    switch(id){
        case 0:// 모든 LED의 전원을 ON
            HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_RESET);
            HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_RESET);            
            HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_RESET);            
            HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_RESET);
            HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_RESET);
            HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_RESET);
            HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_RESET);
            HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_RESET);               
            break;
        case 1:
            HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_RESET);
            break;
        case 2:
            HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_RESET);
            break;
        case 3:
            HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_RESET);
            break;
        case 4:
            HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_RESET);
            break;
        case 5:
            HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_RESET);
            break;
        case 6:
            HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_RESET);
            break;
        case 7:
            HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_RESET);
            break;
        case 8:
            HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_RESET);
            break;
    }
}
void RGB_Sensor_LED_Alarm_OFF(uint8_t id ){
    switch(id){
        case 0:// 모든 LED의 전원을 OFF
            HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_SET);
            HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_SET);            
            HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_SET);            
            HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_SET);
            HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_SET);
            HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_SET);
            HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_SET);
            HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_SET);               
            break;
        case 1:
            HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_SET);
            break;
        case 2:
            HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_SET);
            break;
        case 3:
            HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_SET);
            break;
        case 4:
            HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_SET);
            break;
        case 5:
            HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_SET);
            break;
        case 6:
            HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_SET);
            break;
        case 7:
            HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_SET);
            break;
        case 8:
            HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_SET);
            break;
    }
}

void RGB_Alarm_Operate(void){
    uint8_t temp_warning = 0;
    for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
        if(LED_Alarm[SensorID_buf[i]] == 1){
            HAL_GPIO_WritePin(LED_ALARM_GPIO_Port, LED_ALARM_Pin, GPIO_PIN_SET); //표지 LED
            RGB_Sensor_LED_Alarm_ON(SensorID_buf[i]);
            temp_warning = 1; 
        }else{
            RGB_Sensor_LED_Alarm_OFF(SensorID_buf[i]);
        }
    }
    if(temp_warning == 0){          // 8개의 Sensor가 전부 정상일 때 만 동작
        HAL_GPIO_WritePin(LED_ALARM_GPIO_Port, LED_ALARM_Pin, GPIO_PIN_RESET); //표지 LED
        RGB_Sensor_LED_Alarm_OFF(0); //모든 Sensor가 정상일 때는 LED 가 켜지지 않는다.
    }
}
void RGB_Alarm_Check(uint8_t* data){
    static uint16_t Sensor_red[9] = {0,};
    static uint16_t Sensor_green[9] = {0,};
    static uint16_t Sensor_blue[9] = {0,};    
    static uint8_t Prev_Alarm_occur;
    uint8_t Alarm_occur = 0;
    Sensor_red[data[bluecell_srcid]] = ((data[bluecell_red_H + 2] << 8)| data[bluecell_red_L + 2]);
    Sensor_green[data[bluecell_srcid]] = ((data[bluecell_green_H + 2] << 8)| data[bluecell_green_L + 2]);
    Sensor_blue[data[bluecell_srcid]] = ((data[bluecell_blue_H + 2] << 8)| data[bluecell_blue_L + 2]);  

    for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
        if(RGB_SensorRedLimit_Buf[SensorID_buf[i]]  >= Sensor_red[SensorID_buf[i]]
            || RGB_SensorGreenLimit_Buf[SensorID_buf[i]]  >= Sensor_green[SensorID_buf[i]]
            || RGB_SensorBlueLimit_Buf[SensorID_buf[i]]  >= Sensor_blue[SensorID_buf[i]]) {
            LED_Alarm[SensorID_buf[i]] = 1;
            Alarm_occur = 1;
        }else{
            LED_Alarm[SensorID_buf[i]] = 0;
        }
    }
    RGB_Data_Stack(&LED_Alarm[1]);
    if(Prev_Alarm_occur != Alarm_occur){
//         LoraDataSendSet(LoraTx_mode);//경고 발생 시 바로 Data 전송 하는 Option
         Prev_Alarm_occur = Alarm_occur;
    }
}

uint8_t RGB_DeviceStatusCheck(void){
    uint8_t ret = 0;
    for(uint8_t i = 1; i <= SensorID_Cnt; i++){
        if(SensorID_buf[i] > 0){
            ret += 0x01 << (SensorID_buf[i] - 1); 
        }
    }
    return ret;
}
uint8_t Lora_Buf[100] = {0,};

#if 0 // PYJ.2019.04.14_BEGIN --  //Uart Value Data 
void RGB_Data_Stack(uint8_t* rgb_buf){
    uint8_t mynumcnt = RGB_BufCal(rgb_buf[bluecell_srcid]);
    Lora_Buf[bluecell_stx]         = 0xbe;
    Lora_Buf[bluecell_type]        = RGB_Lora_Data_Report;
    Lora_Buf[bluecell_length]      = Lora_Max_Amount + 2; //length 1byte + type 1byte + RGB Data 60byte
    Lora_Buf[bluecell_srcid]       = MyControllerID;
    Lora_Buf[mynumcnt]             = rgb_buf[bluecell_srcid];
    Lora_Buf[mynumcnt + 1]         = rgb_buf[bluecell_red_H + 2];
    Lora_Buf[mynumcnt + 2]         = rgb_buf[bluecell_red_L + 2];
    Lora_Buf[mynumcnt + 3]         = rgb_buf[bluecell_green_H + 2];
    Lora_Buf[mynumcnt + 4]         = rgb_buf[bluecell_green_L + 2];
    Lora_Buf[mynumcnt + 5]         = rgb_buf[bluecell_blue_H + 2];
    Lora_Buf[mynumcnt + 6]         = rgb_buf[bluecell_blue_L + 2];
    LoraDataSendSet(1);
}

uint8_t RGB_BufCal(uint8_t srcid){
    uint8_t ret = 0;
    switch(srcid){
        case 1:ret = 4;break;
        case 2:ret = 11;break;
        case 3:ret = 18;break;
        case 4:ret = 25;break;
        case 5:ret = 32;break;
        case 6:ret = 39;break;
        case 7:ret = 46;break;
        case 8:ret = 53;break;      
    }
    return ret;
}
#else //Uart Flag Data
/*
    현재 Controller 가지고 있는 RGB Sensor ID Check
    현재 비정상적인 동작을 하는 Sensor 에대한 Flag 정보
*/
void RGB_Data_Stack(uint8_t* rgb_buf){
    memset(&Lora_Buf[0],0x00,8);
    /*********************FIX DATA*************************************/
    Lora_Buf[bluecell_stx]         = 0xbe;
    Lora_Buf[bluecell_srcid + 4]   = 0xeb;
    Lora_Buf[bluecell_type]        = RGB_Lora_DataResponse;
    Lora_Buf[bluecell_length]      = Lora_Max_Amount;// RGB Data 5byte
    Lora_Buf[bluecell_srcid]       = MyControllerID;
    /*********************FIX DATA*************************************/
    if(RGB_BufCal(SensorID_buf[1]) == 0){//아무런 Device가 존재 하지않을 때
        printf("Not Exist Device \n");
        return;
    }
    for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
        Lora_Buf[bluecell_srcid + 1] |= 0x01  << (SensorID_buf[i] - 1);
    }
    for(uint8_t i = 0; i < 8; i++){
        Lora_Buf[bluecell_srcid + 2] |= rgb_buf[i] << i ;
    }
    Lora_Buf[bluecell_srcid + 3]= STH30_CreateCrc(&Lora_Buf[bluecell_type],Lora_Buf[bluecell_length]);
   
}
/*
    RGB_Data_Stack에 Lora에 Data를 보내기 위해 Buffer에 Data를 쌓을 때
    ID 마다 Location Cnt
*/
uint8_t RGB_BufCal(uint8_t srcid){
    uint8_t ret = 0;
    switch(srcid){
        case 1:ret = 4;break;
        case 2:ret = 7;break;
        case 3:ret = 10;break;
        case 4:ret = 13;break;
        case 5:ret = 16;break;
        case 6:ret = 29;break;
        case 7:ret = 32;break;
        case 8:ret = 35;break;      
    }
    return ret;
}
uint8_t RGB_LimitData_Get(uint8_t id){

    switch(id){


    }


}
#endif // PYJ.2019.04.14_END -- 
uint8_t datalosscnt[9] = {0,};


static uint8_t temp_sensorid;
void RGB_Controller_Func(uint8_t* data){
	RGB_CMD_T type = data[bluecell_type];
   // static uint8_t temp_sensorid;
    uint8_t Result_buf[100] = {0,};
    uint8_t i = 0;
    switch(type){
        case RGB_Status_Data_Request:          
            data[bluecell_srcid + 1] = SensorID_buf[temp_sensorid++];
            if(temp_sensorid > (SensorID_Cnt)){
                temp_sensorid = 0;
            }    
            datalosscnt[data[bluecell_srcid + 1]]++;
            if(datalosscnt[data[bluecell_srcid + 1]] > 3 && data[bluecell_srcid + 1] != 0){
                RGB_SensorIDAutoSet(1);
                memset(&SensorID_buf[0],0x00,8);
            }
            data[5]   = STH30_CreateCrc(&data[bluecell_type],data[bluecell_length]);
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],RGB_SensorDataRequest_Length);
            break;
        case RGB_ControllerID_SET:        
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            MyControllerID = data[bluecell_srcid]; // �긽��諛⑹쓽 SRC ID�뒗 �굹�쓽 DST ID�씠�떎.
            break;
        case RGB_SensorID_SET:        
            RGB_SensorIDAutoSet(1);
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            Result_buf[5]  = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            break;
        case RGB_SensorID_SET_Success:
            printf("Recognize %d Sensor\n",data[bluecell_length + 1]);
            SensorID_Cnt++;
            SensorID_buf[SensorID_Cnt] = data[bluecell_length + 1];
            break;
        case RGB_Status_Data_Response:
            datalosscnt[data[bluecell_srcid]] = 0;
            data[bluecell_length] += 1;
            RGB_Alarm_Check(&data[bluecell_stx]);
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            Result_buf[Result_buf[bluecell_length] - 1]   = RGB_DeviceStatusCheck();// Device On OFF status  Send byte
            Result_buf[Result_buf[bluecell_length] + 0]   = Lora_Buf[bluecell_srcid + 2];
            Result_buf[Result_buf[bluecell_length] + 1]   = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            Result_buf[Result_buf[bluecell_length] + 2]   = 0xeb;
            break;
        case RGB_ControllerLimitSet:
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            RGB_SensorRedLimit_Buf[data[bluecell_dstid]]   = ((data[bluecell_red_H] << 8) |data[bluecell_red_L]);
            RGB_SensorGreenLimit_Buf[data[bluecell_dstid]] = ((data[bluecell_green_H] << 8) |data[bluecell_green_L]);
            RGB_SensorBlueLimit_Buf[data[bluecell_dstid]]  = ((data[bluecell_blue_H] << 8) |data[bluecell_blue_L]);        
            Result_buf[bluecell_crc]   = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            break;
        case RGB_Reset:
            NVIC_SystemReset();
            break;
        case RGB_ID_Allocate_Request:
            break;
        case RGB_Location_Report:
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            break;
        case RGB_Location_Response:
            Result_buf[bluecell_type] = RGB_Location_Response;
            Result_buf[bluecell_srcid] = data[bluecell_srcid];
            break;
        case RGB_ControllerID_GET:
            Result_buf[bluecell_stx]         = 0xbe;
            Result_buf[bluecell_type]        = RGB_ControllerID_GET;
            Result_buf[bluecell_length]      = 3;
            Result_buf[bluecell_srcid]       = MyControllerID;      
            Result_buf[bluecell_srcid + 1]   = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            Result_buf[bluecell_srcid + 2]   = 0xeb;
            break;
            
        case RGB_ControllerLimitGet:
            Result_buf[bluecell_stx]         = 0xbe;
            Result_buf[bluecell_type]        = RGB_ControllerLimitGet;
            Result_buf[bluecell_length]      = 8;
            Result_buf[bluecell_srcid + 0]   = (RGB_SensorRedLimit_Buf[data[bluecell_srcid]]   & 0xFF00) >> 8;      
            Result_buf[bluecell_srcid + 1]   = RGB_SensorRedLimit_Buf[data[bluecell_srcid]]   & 0x00FF;  
            Result_buf[bluecell_srcid + 2]   = (RGB_SensorGreenLimit_Buf[data[bluecell_srcid]] & 0xFF00) >> 8;      
            Result_buf[bluecell_srcid + 3]   = RGB_SensorGreenLimit_Buf[data[bluecell_srcid]] & 0x00FF;
            Result_buf[bluecell_srcid + 4]   = (RGB_SensorBlueLimit_Buf[data[bluecell_srcid]]  & 0xFF00) >> 8;      
            Result_buf[bluecell_srcid + 5]   = RGB_SensorBlueLimit_Buf[data[bluecell_srcid]]  & 0x00FF;
            Result_buf[bluecell_srcid + 6]   = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            Result_buf[bluecell_srcid + 7]   = 0xeb;
            break;
        case RGB_Lora_DataRequest:
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            Result_buf[bluecell_type] = RGB_Lora_DataResponse;
            break;
        case RGB_Lora_ConfigSet:
            SX1276_hw_Reset(&SX1276_hw);
            memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
            data[(data[bluecell_length] + 3)]=STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            break;
        case RGB_Lora_ConfigGet:
            Result_buf[bluecell_stx]         = 0xbe;
            Result_buf[bluecell_type]        = RGB_ControllerLimitGet;
            Result_buf[bluecell_length]      = 7;
            Result_buf[bluecell_srcid + 0]   = SX1276.frequency;
            Result_buf[bluecell_srcid + 1]   = SX1276.LoRa_Pa_boost;            
            Result_buf[bluecell_srcid + 2]   = SX1276.LoRa_BW;
            Result_buf[bluecell_srcid + 3]   = SX1276.LoRa_Rate;
            Result_buf[bluecell_srcid + 4]   = SX1276.LoRa_Lna;
            Result_buf[bluecell_srcid + 5]   = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
            Result_buf[bluecell_srcid + 6]   = 0xeb;
            break;
        default:
            break;
    }
    RGB_Response_Func(&Result_buf[bluecell_stx]);
    return;
}