RGB_Controller.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. #include "RGB_Controller.h"
  2. void RGB_Response_Func(uint8_t* data);
  3. uint8_t RGB_BufCal(uint8_t srcid);
  4. void RGB_Alarm_Operate(void);
  5. void RGB_Data_Stack(uint8_t* rgb_buf);
  6. uint16_t RGB_Location_Address_Check(uint8_t id);
  7. uint8_t SensorID_Cnt = 0;
  8. uint8_t SensorID_buf[8] = {0,};
  9. uint16_t RGB_SensorRedLimit_Buf[9]={0,};
  10. uint16_t RGB_SensorGreenLimit_Buf[9]={0,};
  11. uint16_t RGB_SensorBlueLimit_Buf[9]={0,};
  12. uint8_t LED_Alarm[9] = {0,};
  13. uint8_t RGB_Location_Buf[9][50] = {0};
  14. void RGB_Data_Init(void){
  15. MyControllerID = M24C32_Data_Read(&hi2c2,MY_ID_ADDRESS);
  16. for(uint8_t i = 0; i < 8; i++){
  17. RGB_SensorRedLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_RED_H_ADDRESS + (6 * i)) << 8);
  18. RGB_SensorRedLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_RED_L_ADDRESS + (6 * i));
  19. }
  20. for(uint8_t i = 0; i < 8; i++){
  21. RGB_SensorGreenLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_GREEN_H_ADDRESS + (6 * i)) << 8);
  22. RGB_SensorGreenLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_GREEN_L_ADDRESS + (6 * i));
  23. }
  24. for(uint8_t i = 0; i < 8; i++){
  25. RGB_SensorBlueLimit_Buf[i + 1] = (M24C32_Data_Read(&hi2c2,RGB1_LIMIT_BLUE_H_ADDRESS + (6 * i)) << 8);
  26. RGB_SensorBlueLimit_Buf[i + 1] |= M24C32_Data_Read(&hi2c2,RGB1_LIMIT_BLUE_L_ADDRESS + (6 * i));
  27. }
  28. for(uint8_t i = 0; i < 8; i++){
  29. for(uint8_t aa= 0; aa < 50; aa++)
  30. RGB_Location_Buf[i + 1][aa] = M24C32_Data_Read(&hi2c2,RGB_Location_Address_Check(i + 1) + aa);
  31. }
  32. printf("MY id is %d \n",MyControllerID);
  33. for(uint8_t i = 1; i <= 8; i++){
  34. printf("RGB_SensorRedLimit_Buf[%d] : %04x\n",i,RGB_SensorRedLimit_Buf[i]);
  35. printf("RGB_SensorGreenLimit_Buf[%d] : %04x\n",i,RGB_SensorGreenLimit_Buf[i]);
  36. printf("RGB_SensorBlueLimit_Buf[%d] : %04x\n",i,RGB_SensorBlueLimit_Buf[i]);
  37. }
  38. }
  39. uint16_t RGB_Limit_Address_Check(uint8_t id){
  40. uint16_t ret = 0;
  41. switch(id){
  42. case 1: ret = RGB1_LIMIT_RED_H_ADDRESS;break;
  43. case 2: ret = RGB2_LIMIT_RED_H_ADDRESS;break;
  44. case 3: ret = RGB3_LIMIT_RED_H_ADDRESS;break;
  45. case 4: ret = RGB4_LIMIT_RED_H_ADDRESS;break;
  46. case 5: ret = RGB5_LIMIT_RED_H_ADDRESS;break;
  47. case 6: ret = RGB6_LIMIT_RED_H_ADDRESS;break;
  48. case 7: ret = RGB7_LIMIT_RED_H_ADDRESS;break;
  49. case 8: ret = RGB8_LIMIT_RED_H_ADDRESS;break;
  50. }
  51. return ret;
  52. }
  53. uint16_t RGB_Location_Address_Check(uint8_t id){
  54. uint16_t ret = 0;
  55. switch(id){
  56. case 1: ret = RGB1_LOCATION_ADDRESS;break;
  57. case 2: ret = RGB2_LOCATION_ADDRESS;break;
  58. case 3: ret = RGB3_LOCATION_ADDRESS;break;
  59. case 4: ret = RGB4_LOCATION_ADDRESS;break;
  60. case 5: ret = RGB5_LOCATION_ADDRESS;break;
  61. case 6: ret = RGB6_LOCATION_ADDRESS;break;
  62. case 7: ret = RGB7_LOCATION_ADDRESS;break;
  63. case 8: ret = RGB8_LOCATION_ADDRESS;break;
  64. }
  65. return ret;
  66. }
  67. void RGB_Response_Func(uint8_t* data){
  68. RGB_CMD_T type = data[bluecell_type];
  69. #if 0
  70. for(uint8_t i = 0; i < 10; i++){
  71. printf("%02x ",data[i]);
  72. }
  73. #endif
  74. switch(type){
  75. case RGB_Status_Data_Request:
  76. Uart2_Data_Send(data,RGB_SensorDataRequest_Length);
  77. break;
  78. case RGB_ControllerID_SET:
  79. Uart1_Data_Send(data,RGB_ControllerID_SET_Length);
  80. M24C32_Data_Write(&hi2c2,&MyControllerID,MY_ID_ADDRESS,1); // EEPROM Controller ID Save
  81. break;
  82. case RGB_SensorID_SET:
  83. Uart2_Data_Send(data,RGB_SensorIDAutoSetRequest_Length);
  84. break;
  85. case RGB_Status_Data_Response:
  86. Uart1_Data_Send(data,RGB_SensorDataResponse_Length);
  87. break;
  88. case RGB_ControllerLimitSet:
  89. Uart1_Data_Send(data,data[bluecell_length] + 3);
  90. M24C32_Data_Write(&hi2c2,&data[bluecell_red_H],RGB_Limit_Address_Check(data[bluecell_dstid]),6); // EEPROM Controller ID Save
  91. break;
  92. case RGB_Sensor_Start:
  93. case RGB_Sensor_Check:
  94. Uart2_Data_Send(data,RGB_SensorIDAutoSetRequest_Length);
  95. break;
  96. case RGB_Sensor_Ack:
  97. Uart2_Data_Send(data,data[bluecell_length] + 3);
  98. break;
  99. case RGB_Reset:
  100. case RGB_SensorID_SET_Success:
  101. case RGB_ID_Allocate_Request:
  102. case RGB_Lora_Data_Report:
  103. break;
  104. case RGB_Location_Report:
  105. case RGB_Location_Response:
  106. M24C32_Data_Write(&hi2c2,&data[Location_Data],RGB_Location_Address_Check(data[bluecell_dstid]),data[bluecell_length] - 2); // EEPROM Controller ID Save
  107. break;
  108. case RGB_ControllerID_GET:
  109. Uart1_Data_Send(data,data[bluecell_length] + 3);
  110. break;
  111. }
  112. }
  113. void RGB_Sensor_LED_Alarm_ON(uint8_t id ){
  114. switch(id){
  115. case 0:// 모든 LED의 전원을 ON
  116. HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_RESET);
  117. HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_RESET);
  118. HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_RESET);
  119. HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_RESET);
  120. HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_RESET);
  121. HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_RESET);
  122. HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_RESET);
  123. HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_RESET);
  124. break;
  125. case 1:
  126. HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_RESET);
  127. break;
  128. case 2:
  129. HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_RESET);
  130. break;
  131. case 3:
  132. HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_RESET);
  133. break;
  134. case 4:
  135. HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_RESET);
  136. break;
  137. case 5:
  138. HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_RESET);
  139. break;
  140. case 6:
  141. HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_RESET);
  142. break;
  143. case 7:
  144. HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_RESET);
  145. break;
  146. case 8:
  147. HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_RESET);
  148. break;
  149. }
  150. }
  151. void RGB_Sensor_LED_Alarm_OFF(uint8_t id ){
  152. switch(id){
  153. case 0:// 모든 LED의 전원을 OFF
  154. HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_SET);
  155. HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_SET);
  156. HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_SET);
  157. HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_SET);
  158. HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_SET);
  159. HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_SET);
  160. HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_SET);
  161. HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_SET);
  162. break;
  163. case 1:
  164. HAL_GPIO_WritePin(LED_CH1_GPIO_Port,LED_CH1_Pin,GPIO_PIN_SET);
  165. break;
  166. case 2:
  167. HAL_GPIO_WritePin(LED_CH2_GPIO_Port,LED_CH2_Pin,GPIO_PIN_SET);
  168. break;
  169. case 3:
  170. HAL_GPIO_WritePin(LED_CH3_GPIO_Port,LED_CH3_Pin,GPIO_PIN_SET);
  171. break;
  172. case 4:
  173. HAL_GPIO_WritePin(LED_CH4_GPIO_Port,LED_CH4_Pin,GPIO_PIN_SET);
  174. break;
  175. case 5:
  176. HAL_GPIO_WritePin(LED_CH5_GPIO_Port,LED_CH5_Pin,GPIO_PIN_SET);
  177. break;
  178. case 6:
  179. HAL_GPIO_WritePin(LED_CH6_GPIO_Port,LED_CH6_Pin,GPIO_PIN_SET);
  180. break;
  181. case 7:
  182. HAL_GPIO_WritePin(LED_CH7_GPIO_Port,LED_CH7_Pin,GPIO_PIN_SET);
  183. break;
  184. case 8:
  185. HAL_GPIO_WritePin(LED_CH8_GPIO_Port,LED_CH8_Pin,GPIO_PIN_SET);
  186. break;
  187. }
  188. }
  189. void RGB_Alarm_Operate(void){
  190. uint8_t temp_warning = 0;
  191. for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
  192. if(LED_Alarm[SensorID_buf[i]] == 1){
  193. HAL_GPIO_WritePin(LED_ALARM_GPIO_Port, LED_ALARM_Pin, GPIO_PIN_SET); //표지 LED
  194. RGB_Sensor_LED_Alarm_ON(SensorID_buf[i]);
  195. temp_warning = 1;
  196. }else{
  197. RGB_Sensor_LED_Alarm_OFF(SensorID_buf[i]);
  198. }
  199. }
  200. if(temp_warning == 0){ // 8개의 Sensor가 전부 정상일 때 만 동작
  201. HAL_GPIO_WritePin(LED_ALARM_GPIO_Port, LED_ALARM_Pin, GPIO_PIN_RESET); //표지 LED
  202. RGB_Sensor_LED_Alarm_OFF(0); //모든 Sensor가 정상일 때는 LED 가 켜지지 않는다.
  203. }
  204. }
  205. void RGB_Alarm_Check(uint8_t* data){
  206. uint16_t Sensor_red[9] = {0,};
  207. uint16_t Sensor_green[9] = {0,};
  208. uint16_t Sensor_blue[9] = {0,};
  209. Sensor_red[data[bluecell_srcid]] = ((data[bluecell_red_H + 2] << 8)| data[bluecell_red_L + 2]);
  210. Sensor_green[data[bluecell_srcid]] = ((data[bluecell_green_H + 2] << 8)| data[bluecell_green_L + 2]);
  211. Sensor_blue[data[bluecell_srcid]] = ((data[bluecell_blue_H + 2] << 8)| data[bluecell_blue_L + 2]);
  212. for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
  213. if(RGB_SensorRedLimit_Buf[SensorID_buf[i]] >= Sensor_red[SensorID_buf[i]]
  214. || RGB_SensorGreenLimit_Buf[SensorID_buf[i]] >= Sensor_green[SensorID_buf[i]]
  215. || RGB_SensorBlueLimit_Buf[SensorID_buf[i]] >= Sensor_blue[SensorID_buf[i]]) {
  216. LED_Alarm[SensorID_buf[i]] = 1;
  217. }else{
  218. LED_Alarm[SensorID_buf[i]] = 0;
  219. }
  220. }
  221. RGB_Data_Stack(&LED_Alarm[1]);
  222. }
  223. uint8_t RGB_DeviceStatusCheck(void){
  224. uint8_t ret = 0;
  225. for(uint8_t i = 1; i <= SensorID_Cnt; i++){
  226. if(SensorID_buf[i] > 0){
  227. ret += 0x01 << (SensorID_buf[i] - 1);
  228. }
  229. }
  230. return ret;
  231. }
  232. uint8_t Lora_Buf[100] = {0,};
  233. #if 0 // PYJ.2019.04.14_BEGIN -- //Uart Value Data
  234. void RGB_Data_Stack(uint8_t* rgb_buf){
  235. uint8_t mynumcnt = RGB_BufCal(rgb_buf[bluecell_srcid]);
  236. Lora_Buf[bluecell_stx] = 0xbe;
  237. Lora_Buf[bluecell_type] = RGB_Lora_Data_Report;
  238. Lora_Buf[bluecell_length] = Lora_Max_Amount + 2; //length 1byte + type 1byte + RGB Data 60byte
  239. Lora_Buf[bluecell_srcid] = MyControllerID;
  240. Lora_Buf[mynumcnt] = rgb_buf[bluecell_srcid];
  241. Lora_Buf[mynumcnt + 1] = rgb_buf[bluecell_red_H + 2];
  242. Lora_Buf[mynumcnt + 2] = rgb_buf[bluecell_red_L + 2];
  243. Lora_Buf[mynumcnt + 3] = rgb_buf[bluecell_green_H + 2];
  244. Lora_Buf[mynumcnt + 4] = rgb_buf[bluecell_green_L + 2];
  245. Lora_Buf[mynumcnt + 5] = rgb_buf[bluecell_blue_H + 2];
  246. Lora_Buf[mynumcnt + 6] = rgb_buf[bluecell_blue_L + 2];
  247. LoraDataSendSet(1);
  248. }
  249. uint8_t RGB_BufCal(uint8_t srcid){
  250. uint8_t ret = 0;
  251. switch(srcid){
  252. case 1:ret = 4;break;
  253. case 2:ret = 11;break;
  254. case 3:ret = 18;break;
  255. case 4:ret = 25;break;
  256. case 5:ret = 32;break;
  257. case 6:ret = 39;break;
  258. case 7:ret = 46;break;
  259. case 8:ret = 53;break;
  260. }
  261. return ret;
  262. }
  263. #else //Uart Flag Data
  264. /*
  265. 현재 Controller 가지고 있는 RGB Sensor ID Check
  266. 현재 비정상적인 동작을 하는 Sensor 에대한 Flag 정보
  267. */
  268. void RGB_Data_Stack(uint8_t* rgb_buf){
  269. memset(&Lora_Buf[0],0x00,8);
  270. /*********************FIX DATA*************************************/
  271. Lora_Buf[bluecell_stx] = 0xbe;
  272. Lora_Buf[bluecell_srcid + 4] = 0xeb;
  273. Lora_Buf[bluecell_type] = RGB_Lora_Data_Report;
  274. Lora_Buf[bluecell_length] = Lora_Max_Amount;// RGB Data 5byte
  275. Lora_Buf[bluecell_srcid] = MyControllerID;
  276. /*********************FIX DATA*************************************/
  277. if(RGB_BufCal(SensorID_buf[1]) == 0){//아무런 Device가 존재 하지않을 때
  278. printf("Not Exist Device \n");
  279. return;
  280. }
  281. for(uint8_t i = 1; i <= (SensorID_Cnt); i++){
  282. Lora_Buf[bluecell_srcid + 1] |= 0x01 << (SensorID_buf[i] - 1);
  283. }
  284. for(uint8_t i = 0; i < 8; i++){
  285. Lora_Buf[bluecell_srcid + 2] |= rgb_buf[i] << i ;
  286. }
  287. Lora_Buf[bluecell_srcid + 3]= STH30_CreateCrc(&Lora_Buf[bluecell_type],Lora_Buf[bluecell_length]);
  288. LoraDataSendSet(1);
  289. }
  290. /*
  291. RGB_Data_Stack에 Lora에 Data를 보내기 위해 Buffer에 Data를 쌓을 때
  292. ID 마다 Location Cnt
  293. */
  294. uint8_t RGB_BufCal(uint8_t srcid){
  295. uint8_t ret = 0;
  296. switch(srcid){
  297. case 1:ret = 4;break;
  298. case 2:ret = 7;break;
  299. case 3:ret = 10;break;
  300. case 4:ret = 13;break;
  301. case 5:ret = 16;break;
  302. case 6:ret = 29;break;
  303. case 7:ret = 32;break;
  304. case 8:ret = 35;break;
  305. }
  306. return ret;
  307. }
  308. #endif // PYJ.2019.04.14_END --
  309. uint8_t datalosscnt[9] = {0,};
  310. void RGB_Controller_Func(uint8_t* data){
  311. RGB_CMD_T type = data[bluecell_type];
  312. // static uint8_t temp_sensorid;
  313. uint8_t Result_buf[100] = {0,};
  314. switch(type){
  315. case RGB_Status_Data_Request:
  316. datalosscnt[data[bluecell_srcid + 1]]++;
  317. if(datalosscnt[data[bluecell_srcid + 1]] > 3 && data[bluecell_srcid + 1] != 0){
  318. RGB_SensorIDAutoSet(1);
  319. memset(&SensorID_buf[0],0x00,8);
  320. }
  321. data[5] = STH30_CreateCrc(&data[bluecell_type],data[bluecell_length]);
  322. memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],RGB_SensorDataRequest_Length);
  323. break;
  324. case RGB_ControllerID_SET:
  325. memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
  326. MyControllerID = data[bluecell_srcid]; // �긽��諛⑹쓽 SRC ID�뒗 �굹�쓽 DST ID�씠�떎.
  327. break;
  328. case RGB_SensorID_SET:
  329. RGB_SensorIDAutoSet(1);
  330. memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
  331. Result_buf[5] = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
  332. break;
  333. case RGB_SensorID_SET_Success:
  334. SensorID_Cnt++;
  335. SensorID_buf[SensorID_Cnt] = data[bluecell_length + 1];
  336. break;
  337. case RGB_Status_Data_Response:
  338. datalosscnt[data[bluecell_srcid]] = 0;
  339. data[bluecell_length] += 1;// Device On OFF status Send byte
  340. data[bluecell_srcid + 9] = RGB_DeviceStatusCheck();// Device On OFF status Send byte
  341. memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
  342. Result_buf[5] = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
  343. RGB_Alarm_Check(&data[bluecell_stx]);
  344. break;
  345. case RGB_ControllerLimitSet:
  346. memcpy(&Result_buf[bluecell_stx],&data[bluecell_stx],data[bluecell_length] + 3);
  347. RGB_SensorRedLimit_Buf[data[bluecell_dstid]] = ((data[bluecell_red_H] << 8) |data[bluecell_red_L]);
  348. RGB_SensorGreenLimit_Buf[data[bluecell_dstid]] = ((data[bluecell_green_H] << 8) |data[bluecell_green_L]);
  349. RGB_SensorBlueLimit_Buf[data[bluecell_dstid]] = ((data[bluecell_blue_H] << 8) |data[bluecell_blue_L]);
  350. Result_buf[bluecell_crc] = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
  351. break;
  352. case RGB_Reset:
  353. NVIC_SystemReset();
  354. break;
  355. case RGB_ID_Allocate_Request:
  356. break;
  357. case RGB_Location_Report:
  358. break;
  359. case RGB_Location_Response:
  360. break;
  361. case RGB_ControllerID_GET:
  362. Result_buf[bluecell_stx] = 0xbe;
  363. Result_buf[bluecell_type] = RGB_ControllerID_GET;
  364. Result_buf[bluecell_length] = 3;
  365. Result_buf[bluecell_srcid] = MyControllerID;
  366. Result_buf[bluecell_srcid + 1] = STH30_CreateCrc(&Result_buf[bluecell_type],Result_buf[bluecell_length]);
  367. Result_buf[bluecell_srcid + 2] = 0xeb;
  368. break;
  369. default:
  370. break;
  371. }
  372. RGB_Response_Func(&Result_buf[bluecell_stx]);
  373. return;
  374. }