diff --git a/PORTING/CNN/cnn.c b/PORTING/CNN/cnn.c
index 36b433e..6cbcc2c 100644
--- a/PORTING/CNN/cnn.c
+++ b/PORTING/CNN/cnn.c
@@ -41,7 +41,6 @@ float* expand(const float* old_matrix, int old_matrix_length, int layer){
 //c_rl 输出图像的边长：100
 //返回卷积的结果
 float* convolution(Model model_w, Model model_b, const float* input_matrix, int input_matrix_length){
-	DEBUG_PRINTF("卷积开始\r\n");
     // 初始化卷积层参数
     int im_l = input_matrix_length;
     int cr_l = input_matrix_length - 2;
@@ -97,7 +96,6 @@ float* convolution(Model model_w, Model model_b, const float* input_matrix, int
     }
     myfree(SRAMEX,_conv_rlst);
     _conv_rlst = NULL;
-	DEBUG_PRINTF("卷积结束\r\n");
     return conv_rlst;
 }
 
@@ -176,10 +174,6 @@ float* output(const float* input_matrix){
     float *affine2_rslt = (float *) mymalloc(SRAMEX,sizeof(float)*7);
     memset(affine2_rslt, 0, sizeof(float)*7);
 
-// 比较输出层的最大值
-    float temp = -100; // 用于存储最大值的临时变量，初始化为一个非常小的值
-    int predict_num; // 用于存储预测的数字（对应最大值的索引）
-
 // 遍历10个输出神经元（假设有10个类别）
     for(int n=0; n<7; n++)
     {
@@ -194,18 +188,8 @@ float* output(const float* input_matrix){
         // 加上对应神经元的偏置
         affine2_temp = affine2_temp + fc2_weight.array[n];
         affine2_rslt[n] = affine2_temp; // 存储输出层的结果
-
-        // 寻找最大值
-        if(temp <= affine2_rslt[n])
-        {
-            temp = affine2_rslt[n]; // 更新最大值
-            predict_num = n; // 记录最大值对应的类别索引
-        }
     }
 
-    print_rslt(affine2_rslt,7,7);
-    printf("Label is:%d\r\n",predict_num+1);
-
     return affine2_rslt;
 }
 
@@ -272,74 +256,123 @@ float* generateMatrix(Model model, const float* value)
     return CNN_data;
 }
 
+float calculate_probabilities(float *input_array)
+{
+    float sum = 0;
+    u8 input_num = 7;
+    float *result = (float *) mymalloc(SRAMEX,sizeof(float)*input_num);
+    memset(result, 0, sizeof(float)*input_num);
+
+    float *temp = (float *) mymalloc(SRAMEX,sizeof(float)*input_num);
+    memset(temp, 0, sizeof(float)*input_num);
+
+    for (int i = 0; i < input_num; i++)
+    {
+        temp[i] = expf(input_array[i]);
+        sum = sum + temp[i];
+    }
+    for (int j = 0; j < input_num; j++)
+    {
+        result[j] = temp[j] / sum;
+        if(isnan(result[j]))result[j] = 1;
+    }
+
+    int max_index = 0;
+    float max_value = result[0];
+    for (int k = 1; k < input_num; k++)
+    {
+        if (result[k] > max_value)
+        {
+            max_value = result[k];
+            max_index = k;
+        }
+    }
+
+    float _tmp = result[max_index] * 100;
+    myfree(SRAMEX,temp);
+    temp = NULL;
+    myfree(SRAMEX,result);
+    result = NULL;
+    return _tmp;
+}
+
+
+u8 calculate_layer(float *input_array){
+    u8 input_num = 7;
+    u8 predict_num = 0;
+    float max_temp = -100;
+    for(int n=0; n<input_num; n++)
+    {
+        if(max_temp <= input_array[n])
+        {
+            max_temp = input_array[n]; // 更新最大值
+            predict_num = n; // 记录最大值对应的类别索引
+        }
+    }
+    //print_rslt(input_array,7,7);
+    return predict_num+1;
+}
+
+
 void cnn_run(){
-	DEBUG_PRINTF("开始CNN\r\n");
     float value[3] = {0};
     calculate_statistics(data,&value[0]);
     if (check_threshold(data,&value[0])){
+		//初始化：生成100 * 100 矩阵
         float* _data = generateMatrix(data,&value[0]);
-		send_blocks(_data);
 
-		DEBUG_PRINTF("开始第一层\r\n");
+		printf("检测到放电！最大值:%f 平均值:%f 标准差:%f\r\n",value[0],value[1],value[2]);
+		char* _uuid = uuid();
+		send_blocks(_data,_uuid);
+
         //第一层：填充102 * 102
         float* expand_matrix_1 = expand(_data, 100, 1);
         float* conv_rlst_1 = convolution(conv1_weight,conv1_bias,expand_matrix_1, 102);
         float* pool_rslt_1 = pooling(conv1_weight, conv_rlst_1, 100);
 
-		{
         myfree(SRAMEX,_data);
         _data = NULL;
         myfree(SRAMEX,expand_matrix_1);
         expand_matrix_1 = NULL;
         myfree(SRAMEX,conv_rlst_1);
         conv_rlst_1 = NULL;
-		}
 
-
-		DEBUG_PRINTF("开始第二层\r\n");
         //第二层：填充32 * 52 * 52
         float* expand_matrix_2 = expand(pool_rslt_1, 50, 32);
         float* conv_rlst_2 = convolution(conv2_weight,conv2_bias,expand_matrix_2, 52);
         float* pool_rslt_2 = pooling(conv2_weight, conv_rlst_2, 50);
 
-		{
         myfree(SRAMEX,pool_rslt_1);
         pool_rslt_1 = NULL;
         myfree(SRAMEX,expand_matrix_2);
         expand_matrix_2 = NULL;
         myfree(SRAMEX,conv_rlst_2);
         conv_rlst_2 = NULL;
-		}
 
-		DEBUG_PRINTF("开始第三层\r\n");
         //第三层：填充 64 * 27 * 27
         float* expand_matrix_3 = expand(pool_rslt_2, 25, 64);
         float* conv_rlst_3 = convolution(conv3_weight,conv3_bias,expand_matrix_3, 27);
         float* pool_rslt_3 = pooling(conv3_weight, conv_rlst_3, 25);
 
-		{
         myfree(SRAMEX,pool_rslt_2);
         pool_rslt_2 = NULL;
         myfree(SRAMEX,expand_matrix_3);
         expand_matrix_3 = NULL;
         myfree(SRAMEX,conv_rlst_3);
         conv_rlst_3 = NULL;
-		}
 
-		DEBUG_PRINTF("开始第四层\r\n");
         float* affine1_rslt = hidden(pool_rslt_3);
-
-		DEBUG_PRINTF("开始第五层\r\n");
         float* affine2_rslt = output(affine1_rslt);
 
-		{
+        printf("概率：%f\r\n",calculate_probabilities(affine2_rslt));
+        printf("Label is:%d\r\n",calculate_layer(affine2_rslt));
+
         myfree(SRAMEX,pool_rslt_3);
         pool_rslt_3 = NULL;
         myfree(SRAMEX,affine1_rslt);
         affine1_rslt = NULL;
         myfree(SRAMEX,affine2_rslt);
         affine2_rslt = NULL;
-		}
 
     } else{
         printf("未放电！最大值:%f 平均值:%f 标准差:%f\r\n",value[0],value[1],value[2]);
diff --git a/PORTING/CNN/tools.c b/PORTING/CNN/tools.c
index 17d14ce..b2160b7 100644
--- a/PORTING/CNN/tools.c
+++ b/PORTING/CNN/tools.c
@@ -1,9 +1,8 @@
 #include "tools.h"
 
 
-
-void send_blocks(float* arr){
-    char uuid_str[9];
+char* uuid(){
+    static char uuid_str[9];
     u32 time_stamp = HAL_GetTick();
     u32 random_part = rand();
     snprintf(uuid_str, 9,  // 16 位 UUID（8 个字符 + 空终止符）
@@ -11,6 +10,11 @@ void send_blocks(float* arr){
              (unsigned long)(time_stamp & 0xFFFF),
              (unsigned long)(random_part & 0xFFFF));
 
+    return uuid_str;
+}
+
+
+void send_blocks(float* arr, char* uuid_str){
     // 按块处理 每个块的最大字符数（最多存储1000个浮点数的字符串）
     char* block = (char*) mymalloc(SRAMEX,sizeof(char)*100*100);
     memset(block, 0 ,sizeof(char)*100*100);
diff --git a/PORTING/CNN/tools.h b/PORTING/CNN/tools.h
index c072e51..6264833 100644
--- a/PORTING/CNN/tools.h
+++ b/PORTING/CNN/tools.h
@@ -2,5 +2,5 @@
 #include "debug.h"
 
 
-
-void send_blocks(float* arr);
+char* uuid(void);
+void send_blocks(float* arr, char* uuid_str);