全自动运球

位置更改
备赛场地有点不平，还没开测
2025-07-16 22:12:51 +08:00 · 2025-07-09 09:43:10 +08:00 · 2025-07-07 13:25:06 +08:00 · 2025-07-02 19:50:35 +08:00 · 2025-07-01 15:00:28 +08:00 · 2025-07-01 00:14:45 +08:00
32 changed files with 1333 additions and 1061 deletions
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@ -0,0 +1,20 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "compilerPath": "D:\\mingw\\MinGW\\bin\\gcc.exe",
+            "cStandard": "c17",
+            "cppStandard": "gnu++17",
+            "intelliSenseMode": "windows-gcc-x64"
+        }
+    ],
+    "version": 4
+}
--- a/Core/Inc/main.h
+++ b/Core/Inc/main.h
@ -79,6 +79,9 @@ void Error_Handler(void);
 #define CLOSE_GPIO_Port GPIOE
 #define DOWN_Pin GPIO_PIN_11
 #define DOWN_GPIO_Port GPIOE
+#define TEST_Pin GPIO_PIN_12
+#define TEST_GPIO_Port GPIOB
+#define TEST_EXTI_IRQn EXTI15_10_IRQn

 /* USER CODE BEGIN Private defines */

--- a/Core/Inc/stm32f4xx_it.h
+++ b/Core/Inc/stm32f4xx_it.h
@ -60,6 +60,7 @@ void EXTI9_5_IRQHandler(void);
 void TIM1_UP_TIM10_IRQHandler(void);
 void USART1_IRQHandler(void);
 void USART3_IRQHandler(void);
+void EXTI15_10_IRQHandler(void);
 void DMA2_Stream1_IRQHandler(void);
 void DMA2_Stream2_IRQHandler(void);
 void DMA2_Stream3_IRQHandler(void);
--- a/Core/Src/gpio.c
+++ b/Core/Src/gpio.c
@ -64,7 +64,7 @@ void MX_GPIO_Init(void)
  /*Configure GPIO pin : BALL_Pin */
  GPIO_InitStruct.Pin = BALL_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
-  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
+  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(BALL_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : up_ball_Pin */
@ -93,6 +93,12 @@ void MX_GPIO_Init(void)
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

+  /*Configure GPIO pin : TEST_Pin */
+  GPIO_InitStruct.Pin = TEST_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
+  GPIO_InitStruct.Pull = GPIO_PULLUP;
+  HAL_GPIO_Init(TEST_GPIO_Port, &GPIO_InitStruct);
+
  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI0_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI0_IRQn);
@ -100,6 +106,9 @@ void MX_GPIO_Init(void)
  HAL_NVIC_SetPriority(EXTI9_5_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);

+  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
+
 }

 /* USER CODE BEGIN 2 */
--- a/Core/Src/stm32f4xx_it.c
+++ b/Core/Src/stm32f4xx_it.c
@ -292,6 +292,20 @@ void USART1_IRQHandler(void)
 //  /* USER CODE END USART3_IRQn 1 */
 //}

+/**
+  * @brief This function handles EXTI line[15:10] interrupts.
+  */
+void EXTI15_10_IRQHandler(void)
+{
+  /* USER CODE BEGIN EXTI15_10_IRQn 0 */
+
+  /* USER CODE END EXTI15_10_IRQn 0 */
+  HAL_GPIO_EXTI_IRQHandler(TEST_Pin);
+  /* USER CODE BEGIN EXTI15_10_IRQn 1 */
+
+  /* USER CODE END EXTI15_10_IRQn 1 */
+}
+
 /**
  * @brief This function handles DMA2 stream1 global interrupt.
  */
--- a/MDK-ARM/.vscode/c_cpp_properties.json
+++ b/MDK-ARM/.vscode/c_cpp_properties.json
@ -3,26 +3,26 @@
        {
            "name": "R1",
            "includePath": [
-                "d:\\Desktop\\r1\\R1_up\\Core\\Inc",
-                "d:\\Desktop\\r1\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Inc",
-                "d:\\Desktop\\r1\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Inc\\Legacy",
-                "d:\\Desktop\\r1\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\include",
-                "d:\\Desktop\\r1\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\CMSIS_RTOS_V2",
-                "d:\\Desktop\\r1\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\portable\\RVDS\\ARM_CM4F",
-                "d:\\Desktop\\r1\\R1_up\\Drivers\\CMSIS\\Device\\ST\\STM32F4xx\\Include",
-                "d:\\Desktop\\r1\\R1_up\\Drivers\\CMSIS\\Include",
-                "d:\\Desktop\\r1\\R1_up\\User\\bsp",
-                "d:\\Desktop\\r1\\R1_up\\User\\module",
-                "d:\\Desktop\\r1\\R1_up\\User\\task",
-                "d:\\Desktop\\r1\\R1_up\\User\\lib",
-                "d:\\Desktop\\r1\\R1_up\\User\\device",
+                "d:\\Desktop\\运球赛\\R1_up\\Core\\Inc",
+                "d:\\Desktop\\运球赛\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Inc",
+                "d:\\Desktop\\运球赛\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Inc\\Legacy",
+                "d:\\Desktop\\运球赛\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\include",
+                "d:\\Desktop\\运球赛\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\CMSIS_RTOS_V2",
+                "d:\\Desktop\\运球赛\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\portable\\RVDS\\ARM_CM4F",
+                "d:\\Desktop\\运球赛\\R1_up\\Drivers\\CMSIS\\Device\\ST\\STM32F4xx\\Include",
+                "d:\\Desktop\\运球赛\\R1_up\\Drivers\\CMSIS\\Include",
+                "d:\\Desktop\\运球赛\\R1_up\\User\\bsp",
+                "d:\\Desktop\\运球赛\\R1_up\\User\\module",
+                "d:\\Desktop\\运球赛\\R1_up\\User\\task",
+                "d:\\Desktop\\运球赛\\R1_up\\User\\lib",
+                "d:\\Desktop\\运球赛\\R1_up\\User\\device",
                "D:\\keil\\ARM\\ARMCC\\include",
                "D:\\keil\\ARM\\ARMCC\\include\\rw",
-                "d:\\Desktop\\r1\\R1_up\\MDK-ARM",
-                "d:\\Desktop\\r1\\R1_up\\Core\\Src",
-                "d:\\Desktop\\r1\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Src",
-                "d:\\Desktop\\r1\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source",
-                "d:\\Desktop\\r1\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\portable\\MemMang"
+                "d:\\Desktop\\运球赛\\R1_up\\MDK-ARM",
+                "d:\\Desktop\\运球赛\\R1_up\\Core\\Src",
+                "d:\\Desktop\\运球赛\\R1_up\\Drivers\\STM32F4xx_HAL_Driver\\Src",
+                "d:\\Desktop\\运球赛\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source",
+                "d:\\Desktop\\运球赛\\R1_up\\Middlewares\\Third_Party\\FreeRTOS\\Source\\portable\\MemMang"
            ],
            "defines": [
                "USE_HAL_DRIVER",
--- a/MDK-ARM/.vscode/keil-assistant.log
+++ b/MDK-ARM/.vscode/keil-assistant.log
@ -74,93 +74,43 @@

 [info] Log at : 2025/6/25|19:23:57|GMT+0800

-[info] Log at : 2025/6/27|11:41:11|GMT+0800
+[info] Log at : 2025/6/26|03:33:46|GMT+0800

-[info] Log at : 2025/6/27|15:32:00|GMT+0800
+<<<<<<< HEAD
+[info] Log at : 2025/6/27|10:05:14|GMT+0800

-[info] Log at : 2025/6/27|18:43:18|GMT+0800
+[info] Log at : 2025/6/27|23:24:18|GMT+0800

-[info] Log at : 2025/6/28|01:19:54|GMT+0800
+[info] Log at : 2025/6/28|01:53:31|GMT+0800
+=======
+[info] Log at : 2025/6/26|15:46:24|GMT+0800
+>>>>>>> 7b54a46bd3c69e44a04ffd669bb7d3b115fc9e9b

-[info] Log at : 2025/6/28|14:29:33|GMT+0800
+[info] Log at : 2025/6/30|23:46:31|GMT+0800

-[info] Log at : 2025/6/28|16:39:11|GMT+0800
+[info] Log at : 2025/6/30|23:48:14|GMT+0800

-[info] Log at : 2025/6/28|16:39:57|GMT+0800
+[info] Log at : 2025/6/30|23:49:51|GMT+0800

-[info] Log at : 2025/6/28|18:37:20|GMT+0800
+[info] Log at : 2025/7/1|00:00:07|GMT+0800

-[info] Log at : 2025/6/29|15:33:54|GMT+0800
+[info] Log at : 2025/7/1|14:59:17|GMT+0800

-[info] Log at : 2025/6/30|10:24:59|GMT+0800
+[info] Log at : 2025/7/2|14:47:50|GMT+0800

-[info] Log at : 2025/7/1|10:57:51|GMT+0800
+[info] Log at : 2025/7/2|19:49:16|GMT+0800

-[info] Log at : 2025/7/2|02:59:15|GMT+0800
+[info] Log at : 2025/7/9|09:48:19|GMT+0800

-[info] Log at : 2025/7/2|17:15:33|GMT+0800
+[info] Log at : 2025/7/9|09:49:07|GMT+0800

-[info] Log at : 2025/7/4|09:10:46|GMT+0800
+[info] Log at : 2025/7/10|15:36:20|GMT+0800

-[info] Log at : 2025/7/6|22:01:26|GMT+0800
+[info] Log at : 2025/7/11|18:17:38|GMT+0800

-[info] Log at : 2025/7/6|22:02:13|GMT+0800
+[info] Log at : 2025/7/13|01:22:22|GMT+0800

-[info] Log at : 2025/7/6|23:12:04|GMT+0800
+[info] Log at : 2025/7/13|01:27:09|GMT+0800

-[info] Log at : 2025/7/7|04:53:38|GMT+0800
-
-[info] Log at : 2025/7/7|08:44:07|GMT+0800
-
-[info] Log at : 2025/7/7|14:20:11|GMT+0800
-
-[info] Log at : 2025/7/8|02:49:12|GMT+0800
-
-[info] Log at : 2025/7/8|13:15:42|GMT+0800
-
-[info] Log at : 2025/7/8|18:00:22|GMT+0800
-
-[info] Log at : 2025/7/8|20:39:07|GMT+0800
-
-[info] Log at : 2025/7/9|08:39:28|GMT+0800
-
-[info] Log at : 2025/7/9|11:36:02|GMT+0800
-
-[info] Log at : 2025/7/9|16:01:34|GMT+0800
-
-[info] Log at : 2025/7/9|23:48:02|GMT+0800
-
-[info] Log at : 2025/7/10|01:59:23|GMT+0800
-
-[info] Log at : 2025/7/10|15:33:45|GMT+0800
-
-[info] Log at : 2025/7/10|17:26:59|GMT+0800
-
-[info] Log at : 2025/7/10|22:12:10|GMT+0800
-
-[info] Log at : 2025/7/11|10:11:25|GMT+0800
-
-[info] Log at : 2025/7/11|17:39:11|GMT+0800
-
-[info] Log at : 2025/7/12|23:45:28|GMT+0800
-
-[info] Log at : 2025/7/13|11:08:55|GMT+0800
-
-[info] Log at : 2025/7/13|12:29:41|GMT+0800
-
-[info] Log at : 2025/7/13|16:33:17|GMT+0800
-
-[info] Log at : 2025/7/13|16:42:25|GMT+0800
-
-[info] Log at : 2025/7/13|22:38:15|GMT+0800
-
-[info] Log at : 2025/7/14|07:52:29|GMT+0800
-
-[info] Log at : 2025/7/14|12:31:22|GMT+0800
-
-[info] Log at : 2025/7/14|13:56:03|GMT+0800
-
-[info] Log at : 2025/7/16|22:15:00|GMT+0800
-
-[info] Log at : 2025/7/16|22:26:06|GMT+0800
+[info] Log at : 2025/7/13|08:37:10|GMT+0800

--- a/MDK-ARM/.vscode/uv4.log
+++ b/MDK-ARM/.vscode/uv4.log
@ -1,9 +1,8 @@
 *** Using Compiler 'V5.06 update 7 (build 960)', folder: 'D:\keil\ARM\ARMCC\Bin'
 Build target 'R1'
-compiling ballTask.cpp...
-compiling shootTask.cpp...
+compiling ball.cpp...
 linking...
-Program Size: Code=31984 RO-data=1832 RW-data=272 ZI-data=32264  
+Program Size: Code=29156 RO-data=1832 RW-data=300 ZI-data=32220  
 FromELF: creating hex file...
 "R1\R1.axf" - 0 Error(s), 0 Warning(s).
-Build Time Elapsed:  00:00:05
+Build Time Elapsed:  00:00:04
--- a/MDK-ARM/.vscode/uv4.log.lock
+++ b/MDK-ARM/.vscode/uv4.log.lock
@ -1 +1 @@
-2025/7/16 22:30:59
+2025/7/13 7:05:23
--- a/MDK-ARM/R1.uvoptx
+++ b/MDK-ARM/R1.uvoptx
@ -154,76 +154,43 @@
        </SetRegEntry>
      </TargetDriverDllRegistry>
      <Breakpoint/>
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> 上层测试
      <WatchWindow1>
        <Ww>
          <count>0</count>
          <WinNumber>1</WinNumber>
-          <ItemText>rc_ctrl,0x0A</ItemText>
+          <ItemText>ttttt1,0x0A</ItemText>
        </Ww>
        <Ww>
          <count>1</count>
          <WinNumber>1</WinNumber>
-          <ItemText>shoot,0x0A</ItemText>
+          <ItemText>ball,0x0A</ItemText>
        </Ww>
        <Ww>
          <count>2</count>
          <WinNumber>1</WinNumber>
-<<<<<<< HEAD
-          <ItemText>ball,0x0A</ItemText>
-=======
-          <ItemText>ball</ItemText>
->>>>>>> 上层测试
+          <ItemText>nucbuf</ItemText>
        </Ww>
        <Ww>
          <count>3</count>
          <WinNumber>1</WinNumber>
-<<<<<<< HEAD
-          <ItemText>nucbuf</ItemText>
-=======
-          <ItemText>and1</ItemText>
->>>>>>> 上层测试
+          <ItemText>runCount,0x0A</ItemText>
        </Ww>
        <Ww>
          <count>4</count>
          <WinNumber>1</WinNumber>
-<<<<<<< HEAD
-          <ItemText>nuc_v</ItemText>
-=======
-          <ItemText>and1</ItemText>
->>>>>>> 上层测试
+          <ItemText>rc_ctrl,0x0A</ItemText>
        </Ww>
        <Ww>
          <count>5</count>
          <WinNumber>1</WinNumber>
-<<<<<<< HEAD
-          <ItemText>abc,0x0A</ItemText>
-=======
-          <ItemText>nucbuf</ItemText>
->>>>>>> 上层测试
+          <ItemText>runCount,0x0A</ItemText>
        </Ww>
        <Ww>
          <count>6</count>
          <WinNumber>1</WinNumber>
-<<<<<<< HEAD
-          <ItemText>shoot_wait,0x0A</ItemText>
-        </Ww>
-        <Ww>
-          <count>7</count>
-          <WinNumber>1</WinNumber>
-          <ItemText>error_code</ItemText>
+          <ItemText>ball_task_active,0x0A</ItemText>
        </Ww>
      </WatchWindow1>
-=======
->>>>>>> 上层测试
-=======
-          <ItemText>drop_message,0x0A</ItemText>
-        </Ww>
-      </WatchWindow1>
->>>>>>> 上层测试
      <MemoryWindow4>
        <Mm>
          <WinNumber>4</WinNumber>
--- a/MDK-ARM/README.md
+++ b/MDK-ARM/README.md
@ -36,29 +36,10 @@ r1上层
  + 拨置👇发射清空掉落信号

 + 用一个攻守方档
-  + 初始移动到最上面 更待蓄力(不管攻方守方都在最上面等待)
  + 攻方时拨下立马蓄力并伸出(可小角度)
  + 守方时不动并保持缩回
  + 👇  运球档正常运球
  + 中  初始档直接缩回
  + 👆 配合档 完成配合并伸出才能发射

-+ 传球模式
-  + 自动
-    + 底盘的传球对准档拨下
-    + 我的蓄力进入传球拟合
-    + 继续拨下发射
-  + 手动
-    + 目前只能打固定距离
-      + 切相同传球档 自动蓄力到传球力度
-      + 发射档发射
-    + 图传多距离
-      + 传球档
-      + 旋钮+看图传点位调整
-
-+ 修复
-  + 6.29 发射误操作导致没有拟合作用就射了(已修复)
-  + 6.29 串口不稳定 重新拔插一下
-  + 6.29 nuc位置更新慢
-  + 6.29 添加光电上电保护防止跳尺(已添加)
-  
+ 运球赛专属简单代码
--- a/R1.ioc
+++ b/R1.ioc
@ -153,20 +153,21 @@ Mcu.Pin22=PD14
 Mcu.Pin23=PA0-WKUP
 Mcu.Pin24=PE13
 Mcu.Pin25=PE11
-Mcu.Pin26=PA7
-Mcu.Pin27=VP_CRC_VS_CRC
-Mcu.Pin28=VP_FREERTOS_VS_CMSIS_V2
-Mcu.Pin29=VP_SYS_VS_Systick
+Mcu.Pin26=PB12
+Mcu.Pin27=PA7
+Mcu.Pin28=VP_CRC_VS_CRC
+Mcu.Pin29=VP_FREERTOS_VS_CMSIS_V2
 Mcu.Pin3=PB3
-Mcu.Pin30=VP_TIM4_VS_ClockSourceINT
-Mcu.Pin31=VP_TIM10_VS_ClockSourceINT
+Mcu.Pin30=VP_SYS_VS_Systick
+Mcu.Pin31=VP_TIM4_VS_ClockSourceINT
+Mcu.Pin32=VP_TIM10_VS_ClockSourceINT
 Mcu.Pin4=PA14
 Mcu.Pin5=PA13
 Mcu.Pin6=PB7
 Mcu.Pin7=PB6
 Mcu.Pin8=PD0
 Mcu.Pin9=PC11
-Mcu.PinsNb=32
+Mcu.PinsNb=33
 Mcu.ThirdPartyNb=0
 Mcu.UserConstants=
 Mcu.UserName=STM32F407IGHx
@ -184,6 +185,7 @@ NVIC.DMA2_Stream6_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DMA2_Stream7_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DebugMonitor_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false
 NVIC.EXTI0_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
+NVIC.EXTI15_10_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
 NVIC.EXTI9_5_IRQn=true\:5\:0\:true\:false\:true\:false\:true\:true\:true
 NVIC.ForceEnableDMAVector=true
 NVIC.HardFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false
@ -218,6 +220,12 @@ PA7.Signal=SPI1_MOSI
 PA9.Locked=true
 PA9.Mode=Asynchronous
 PA9.Signal=USART1_TX
+PB12.GPIOParameters=GPIO_PuPd,GPIO_Label,GPIO_ModeDefaultEXTI
+PB12.GPIO_Label=TEST
+PB12.GPIO_ModeDefaultEXTI=GPIO_MODE_IT_RISING
+PB12.GPIO_PuPd=GPIO_PULLDOWN
+PB12.Locked=true
+PB12.Signal=GPXTI12
 PB3.GPIOParameters=GPIO_PuPd
 PB3.GPIO_PuPd=GPIO_PULLUP
 PB3.Mode=Full_Duplex_Master
@ -369,6 +377,8 @@ RCC.VCOOutputFreq_Value=336000000
 RCC.VcooutputI2S=192000000
 SH.GPXTI0.0=GPIO_EXTI0
 SH.GPXTI0.ConfNb=1
+SH.GPXTI12.0=GPIO_EXTI12
+SH.GPXTI12.ConfNb=1
 SH.GPXTI7.0=GPIO_EXTI7
 SH.GPXTI7.ConfNb=1
 SH.S_TIM10_CH1.0=TIM10_CH1,PWM Generation1 CH1
--- a/README.md
+++ b/README.md
@ -5,60 +5,19 @@ r1上层
 ## 外设

 + CAN1
-  + 扳机2006 id:0x201
-+ CAN2
-  + 小米电机 id:1  
+  - 扳机2006 id:0x205
+  - 三摩擦 id:123 
 + UART
-  + uart1 波特率4000000 id：2
-  + uart6 nuc
-  + uart3 遥控器接收
+  - uart1 波特率4000000 id：2
+  - uart6 nuc
+  - uart3 遥控器接收
 + GPIO
-  + PI6运球光电
-  + PE13 爪气缸
-  + PE14 砸气缸
+  - PI6运球光电 
+  - PE11 运球气缸
+
+

 ## 遥控器

-## 待解决

-+ 用了将运球和伸缩绑定到一起  √
-+ 串口收数加个滤波  √

-## 思路
-
-+ 👆 传球档           👆  配合档  
-+ 中  初始档           中  初始档
-+ 👇  发射档          👇  运球档
-+ 起步遥控档我直接蓄力准备接球  + 可多次的运球
-  + 缩回转移球
-  + 蓄力到位,收到掉落信号和已伸出信号
-  + 根据视觉拟合信息的动态调整
-  + 拨置👇发射清空掉落信号
-
-+ 用一个攻守方档
-  + 初始移动到最上面 更待蓄力(不管攻方守方都在最上面等待)
-  + 攻方时拨下立马蓄力并伸出(可小角度)
-  + 守方时不动并保持缩回
-  + 👇  运球档正常运球
-  + 中  初始档直接缩回
-  + 👆 配合档 完成配合并伸出才能发射
-
-+ 传球模式
-  + 自动
-    + 底盘的传球对准档拨下
-    + 我的蓄力进入传球拟合
-    + 继续拨下发射
-  + 手动
-    + 目前只能打固定距离
-      + 切相同传球档 自动蓄力到传球力度
-      + 发射档发射
-    + 图传多距离
-      + 传球档
-      + 旋钮+看图传点位调整
-
-+ 修复
-  + 6.29 发射误操作导致没有拟合作用就射了(已修复)
-  + 6.29 串口不稳定 重新拔插一下
-  + 6.29 nuc位置更新慢
-  + 6.29 添加光电上电保护防止跳尺(已添加)
-  
--- a/User/bsp/TopDefine.h
+++ b/User/bsp/TopDefine.h
@ -16,7 +16,10 @@
 #endif


-#define ONE_CONTROL 1
+#define ONE_CONTROL 0
+
+
+

 //是否使用大疆DT7遥控器
 #ifndef DT7
@ -28,8 +31,7 @@
 //================任务通知,时间组================//
 //事件组
 #define EVENT_RC    (1<<1)
-#define EVENT_CAN1  (1<<2)
-#define EVENT_CAN2  (1<<3)
+#define EVENT_CAN   (1<<2)

 //================任务通知================//
 //运球
@ -41,10 +43,6 @@
 #define HANDING_FINISH (1<<2)
 //伸缩结束
 #define EXTEND_OK	(1<<3)
-//等待ok
-#define WAIT_OK		(1<<4)
-//可以防守收回
-#define DEF_READY	(1<<5)

 //要发送ok了
 #define BALL_SEND (1<<6)
--- a/User/bsp/gpio_it.c
+++ b/User/bsp/gpio_it.c
@ -20,23 +20,23 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
 }

 /* Exported functions ------------------------------------------------------- */
-// int8_t BSP_GPIO_RegisterCallback(uint16_t pin, void (*callback)(void)) {
-//   if (callback == NULL) return BSP_ERR_NULL;
+int8_t BSP_GPIO_RegisterCallback(uint16_t pin, void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;

-//   for (uint8_t i = 0; i < 16; i++) {
-//     if (pin & (1 << i)) {
-//       GPIO_Callback[i] = callback;
-//       break;
-//     }
-//   }
-//   return BSP_OK;
-// }
+  for (uint8_t i = 0; i < 16; i++) {
+    if (pin & (1 << i)) {
+      GPIO_Callback[i] = callback;
+      break;
+    }
+  }
+  return BSP_OK;
+}

 // int8_t BSP_GPIO_EnableIRQ(uint16_t pin) {
 //   switch (pin) {

-//     case KEY_Pin:
-//       HAL_NVIC_EnableIRQ(KEY_Pin);
+//     case USER_KEY_Pin:
+//       HAL_NVIC_EnableIRQ(USER_KEY_EXTI_IRQn);
 //       break;

 //       /*
@ -54,9 +54,9 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
 // int8_t BSP_GPIO_DisableIRQ(uint16_t pin) {
 //   switch (pin) {

-//     case KEY_Pin:
-//       HAL_NVIC_DisableIRQ(KEY_IRQn);
-//       break;
+//     // case USER_KEY_Pin:
+//     //   HAL_NVIC_DisableIRQ(USER_KEY_EXTI_IRQn);
+//     //   break;

 //       /*
 //       case XXX_Pin:
--- a/User/device/detect.c
+++ b/User/device/detect.c
@ -3,6 +3,7 @@
 #include "bsp_delay.h"
 int key=0;
 int ball_exit=0;
+int test_exit=0;

 // 按键中断回调函数
 void detect_exit(void)
@ -15,17 +16,35 @@ void detect_exit(void)
 void detect_ball(void)
 {

-    ball_exit++; // 按键按下时变量自增
+    // ball_exit++; // 按键按下时变量自增
    __HAL_GPIO_EXTI_CLEAR_IT(BALL_Pin); // 清除中断标志位
 }

+void detect_test(void)
+{
+    delay_ms(10); // 延时10ms
+    if(HAL_GPIO_ReadPin(TEST_GPIO_Port, TEST_Pin) == GPIO_PIN_RESET)
+    {
+      ball_exit++; 
+    }


+    __HAL_GPIO_EXTI_CLEAR_IT(TEST_Pin); // 清除中断标志位
+}
+
 void detect_init(void)
 {

-    // BSP_GPIO_RegisterCallback(KEY_Pin, detect_exit);
-    // BSP_GPIO_RegisterCallback(BALL_Pin, detect_ball);
+    BSP_GPIO_RegisterCallback(KEY_Pin, detect_exit);
+    BSP_GPIO_RegisterCallback(BALL_Pin, detect_ball);
+    BSP_GPIO_RegisterCallback(TEST_Pin, detect_test);

+    // // 启用按键中断
+    // if (BSP_GPIO_EnableIRQ(KEY_Pin) != BSP_OK) {
+    //     // 错误处理
+    // }  
+    // if (BSP_GPIO_EnableIRQ(BALL_Pin) != BSP_OK) {
+    //     // 错误处理
+    // }  
    
 }
--- a/User/device/djiMotor.c
+++ b/User/device/djiMotor.c
@ -215,13 +215,15 @@ static osThreadId_t thread_alert;
 void Dji_Motor_CB()
 {
  HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &dji_rx_header, dji_rx_data);
-  osThreadFlagsSet(thread_alert, EVENT_CAN1);

+  osThreadFlagsSet(thread_alert, EVENT_CAN);
+ // osEventFlagsSet(eventReceive, EVENT_CAN);
 }
 void can2_Motor_CB(void)
 {
  HAL_CAN_GetRxMessage(&hcan2, CAN_RX_FIFO1, &rx_header, rx_data);
-  osThreadFlagsSet(thread_alert, EVENT_CAN2);
+
+  //osThreadFlagsSet(thread_alert, EVENT_CAN);
 }

 /**
@ -232,6 +234,9 @@ void can2_Motor_CB(void)
 void djiInit(void)
 {
  thread_alert = osThreadGetId();
+
+  
+
  BSP_CAN_RegisterCallback(BSP_CAN_1, HAL_CAN_RX_FIFO0_MSG_PENDING_CB,
                          Dji_Motor_CB);
  BSP_CAN_RegisterCallback(BSP_CAN_2, HAL_CAN_RX_FIFO1_MSG_PENDING_CB,
@ -245,9 +250,11 @@ void djiInit(void)
 */
 uint32_t waitNewDji() 
 {
-  // 等待CAN1或CAN2任意一个事件
+  // return osEventFlagsWait(
+	// 			eventReceive, EVENT_CAN,osFlagsWaitAny, osWaitForever);
  return osThreadFlagsWait(
-    EVENT_CAN1 | EVENT_CAN2, osFlagsWaitAny, osWaitForever);
+    EVENT_CAN, osFlagsWaitAll, osWaitForever);
+
 }
 #endif

--- a/User/device/nuc.c
+++ b/User/device/nuc.c
@ -6,7 +6,7 @@ static osThreadId_t thread_alert;

 volatile uint32_t drop_message = 0;

-uint8_t nucbuf[18];
+uint8_t nucbuf[6];
 uint8_t packet[32]; // 假设最大数据包长度为 32 字节

 static void NUC_CBLTCallback(void)
@ -150,19 +150,19 @@ int8_t NUC_RawParse(NUC_t *n) {
  else
  {

-      if (nucbuf[17] != TAIL) goto error;
+      if (nucbuf[5] != TAIL) goto error;

-      instance.data[3] = nucbuf[8];
-      instance.data[2] = nucbuf[7];
-      instance.data[1] = nucbuf[6];
-      instance.data[0] = nucbuf[5];
+      instance.data[3] = nucbuf[4];
+      instance.data[2] = nucbuf[3];
+      instance.data[1] = nucbuf[2];
+      instance.data[0] = nucbuf[1];
      n->vision.x = instance.x[0];

-      instance.data[7] = nucbuf[16];
-      instance.data[6] = nucbuf[15];
-      instance.data[5] = nucbuf[14];
-      instance.data[4] = nucbuf[13];
-      n->vision.y = instance.x[1];
+      // instance.data[7] = nucbuf[16];
+      // instance.data[6] = nucbuf[15];
+      // instance.data[5] = nucbuf[14];
+      // instance.data[4] = nucbuf[13];
+      // n->vision.y = instance.x[1];

  }
   return DEVICE_OK;
@ -247,6 +247,3 @@ int8_t NUC_HandleOffline(NUC_t *cmd)
 	return 0;
 }

-
-
-
--- a/User/lib/calc_lib.c
+++ b/User/lib/calc_lib.c
@ -164,8 +164,7 @@ fp32 abs_limit_min_max_fp(fp32 *num, fp32 Limit_min,fp32 Limit_max)
        *num = Limit_min;
        return Limit_min;
    }
-
-     return *num; // 如果在范围内，直接返回原值
-}
  
+    return *num;
+}

--- a/User/module/ball.cpp
+++ b/User/module/ball.cpp
@ -6,10 +6,14 @@
 #include "user_math.h"
 #include "shoot.hpp"

+NUC_t nuc_d;
+
+#define HANGDING_TWO 0 // 是否使用两次运球
+
 extern RC_ctrl_t rc_ctrl;
 extern int ball_exit;

-// 外死点168  外163 中150  内127  限位124.8
+
 // 伸缩
 //外死点89  外85 中75  内49  限位46 

@ -18,18 +22,22 @@ extern int ball_exit;
 #define WAIT_POS 75
 #define HANGDING_POS 89

-// PE11 气缸git stash apply
+uint8_t stop_flag[3] = {0XFF,0X01,0XFE};
+
+// PE11 气缸

 Ball ::Ball()
 {
+    detect_init();
+
    // 小米电机
    feedback = get_CyberGear_point();

    // 小米电机初始化
    xiaomi.position = I_ANGLE; //
-    xiaomi.speed = 35;         //
-    xiaomi.K_P = 40;           // 位置增益
-    xiaomi.K_D = 100;           // 位置阻尼
+    xiaomi.speed = 40;         //
+    xiaomi.K_P = 80;           // 位置增益
+    xiaomi.K_D = 20;           // 位置阻尼
    xiaomi.K_C = 12;           // 力矩
    xiaomi.Pmax = 1;           // 好像没啥用

@ -48,7 +56,11 @@ Ball ::Ball()
 // E键 sw[1]  👆 200 shoot  中 1000 stop sw[2]👇1800
 // G键 sw[6]👆 200  中 1000 👇1800
 //     sw[5] 👆 200 👇1800
+// H键 sw[6] 👆200 👇1800
 // 左旋 sw[7] 200 --1800
+
+int last_sw5 = 1800; // 上一次拨杆状态
+
 void Ball::rc_mode()
 {
    if (rc_ctrl.sw[6] == 200)
@ -73,14 +85,15 @@ void Ball::rc_mode()
        extern_key = OUT;
    }

-    if (rc_ctrl.sw[5] == 1800)
-    {
-        ready_key = SIDE;
-    }
-    if (rc_ctrl.sw[5] == 200)
-    {
-        ready_key = DEF; // 默认不准备
-    }
+    // if (rc_ctrl.sw[5] == 200 && last_sw5 == 1800) // 只在1800->200的瞬间触发
+    // {
+    //     rc_key = DOWN2;
+    // }
+    // else
+    // {
+    //     rc_key = 0; // 其他情况不触发
+    // }
+    // last_sw5 = rc_ctrl.sw[5];
 }

 void Ball::Send_control()
@ -99,6 +112,8 @@ void Ball::ballDown(void)
    HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 确保下气缸关闭
 }

+
+
 void Ball::Move_Extend()
 {
    if (extern_key == IN)
@ -108,45 +123,431 @@ void Ball::Move_Extend()
    if (extern_key == OUT)
    {
        xiaomi.position = HANGDING_POS;
+       
    }
 }

+int runCount = 0;
+int last_ball_state = 0;
+int step = 0;
+int ball_task_active = 0;
+int last_data = 0; // 新增
+
+void Ball::data_get(const NUC_t &nuc_d)
+{
+    data = nuc_d.vision.x;
+    // 只在data从0变为非0时激活流程（上升沿触发）
+    if (data != 0 && last_data == 0 && ball_task_active == 0) {
+        ball_task_active = 1;
+        runCount = 0; // 只在收到新指令时清零
+        currentState1 = BALL_FORWARD;
+    }
+    last_data = data;
+}
+
+#if HANGDING_TWO == 0
+
 void Ball::ball_control()
 {
-    ball_state = HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin); // 读取光电状态(有球 1，无球 0)
+
+    ball_state = HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin);
+
+    if (ball_task_active == 0) {
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+        currentState1 = BALL_IDLE;
+        return;
+    }
+
+    switch (currentState1)
+    {
+    case BALL_FORWARD:
+        osDelay(500);
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET);
+        osDelay(5);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET);
+        currentState1 = BALL_DROP;
+        break;
+
+    case BALL_DROP:
+        osDelay(100);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+        if (ball_state == 1 && last_ball_state == 0) {
+            currentState1 = BALL_FLAG;
+        }
+        last_ball_state = ball_state;
+        break;
+
+    case BALL_FLAG:
+        osDelay(10);
+        if (ball_state == 0 && last_ball_state == 1) {
+            currentState1 = BALL_CLOSE;
+        }
+        last_ball_state = ball_state;
+        break;
+
+    case BALL_CLOSE:
+        osDelay(100);
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+        currentState1 = BALL_FINISH;
+        break;
+
+    case BALL_FINISH:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+        runCount++;
+        if (runCount < 2) {
+            currentState1 = BALL_FORWARD;
+        } else {
+            // 运完两次，流程结束
+            ball_task_active = 0;
+            data = 0;
+            HAL_UART_Transmit(&huart6, stop_flag, 3, 10);
+            osDelay(500);
+            // runCount 不要在这里清零
+            currentState1 = BALL_IDLE;
+        }
+        break;
+
+    default:
+        currentState1 = BALL_IDLE;
+        break;
+    }
+}
+
+// int runCount = 0;        // 运球次数计数
+// int last_ball_state = 0; // 上一次的光电状态
+// int step = 0;            // 0:持球 1:击球 2:反弹 3:完全离开
+// int ball_task_active = 0; // 运球流程激活标志
+// int ifyun=0;
+
+// void Ball::data_get(const NUC_t &nuc_d)
+// {
+//     data = nuc_d.vision.x;
+//     // 收到上位机新指令且未在运球流程中，激活流程
+//     if (data !=0 && ball_task_active == 0) {
+//         ball_task_active = 1;
+//         runCount = 0;
+//         ifyun=0;
+//         currentState1 = BALL_FORWARD;
+//     }
+// }
+
+// #if HANGDING_TWO == 0
+
+// void Ball::ball_control()
+// {
+//     ball_state = HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin);
+    
+//     if (ball_task_active == 0) {
+//         // 未激活流程，保持空闲
+//         HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+//         HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+//         currentState1 = BALL_IDLE;
+//         return;
+//     }
+// if(ifyun==0){
+//     switch (currentState1)
+//     {
+//     case BALL_FORWARD:
+//         osDelay(100);
+//         HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET);
+//         osDelay(5);
+//         HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET);
+//         currentState1 = BALL_DROP;
+//         break;
+
+//     case BALL_DROP:
+//         osDelay(100);
+//         HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+//         if (ball_state == 1 && last_ball_state == 0) {
+//             currentState1 = BALL_FLAG;
+//         }
+//         last_ball_state = ball_state;
+//         break;
+
+//     case BALL_FLAG:
+//         osDelay(10);
+//         if (ball_state == 0 && last_ball_state == 1) {
+//             currentState1 = BALL_CLOSE;
+//         }
+//         last_ball_state = ball_state;
+//         break;
+
+//     case BALL_CLOSE:
+//         osDelay(100);
+//         HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+//         currentState1 = BALL_FINISH;
+//         break;
+
+//     case BALL_FINISH:
+//         //osDelay(200);
+//         HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
+//         HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
+//         runCount++;
+//         if (runCount < 2) {
+//             currentState1 = BALL_FORWARD;
+            
+//         } else {
+//             // 运完两次，流程结束
+//             ball_task_active = 0;
+//             data = 0;
+//             // 通过串口发送stop_flag数组给上位机，通知停止
+//             HAL_UART_Transmit(&huart6, stop_flag, 3, 10);
+//                 ifyun=1;
+//             currentState1 = BALL_IDLE;
+//         }
+//         break;
+
+//     default:
+//         currentState1 = BALL_IDLE;
+//         break;
+//     }
+
+// }
+// }
+#else
+
+void Ball::ball_control()
+{
+    ball_state = HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin); // 读取光电状态(有球 0，无球 1)

    Move_Extend();

-    switch (rc_key)
+    switch (currentState1)
    {
-    case MIDDLE2:
+    case BALL_IDLE:
        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
-        if (currentState1 == BALL_FINISH)
+        if (rc_key == DOWN2)                                           // 检测按键是否被按下
        {
-            currentState1 = BALL_IDLE;
+            runCount = 0; // 每次拨动重新计数
+            currentState1 = BALL_FORWARD;
+        }
+        break;
+
+    case BALL_FORWARD:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 打开气缸爪子
+        osDelay(5);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET); // 打开下气缸
+        currentState1 = BALL_DROP;                                 // 切换到球下落状态
+        break;
+
+    case BALL_DROP:
+        osDelay(100);                                                // 延时 100ms
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 关闭下气缸
+        // 一直检测有球（ball_state == 0），等球离开
+        if (ball_state == 1 && last_ball_state == 0) // 球离开
+        {
+            currentState1 = BALL_FLAG;
+        }
+        last_ball_state = ball_state;
+        break;
+
+    case BALL_FLAG:
+        osDelay(10); // 延时 50ms
+        // 等待球弹回再次检测到球
+        if (ball_state == 0 && last_ball_state == 1) // 球弹回
+        {
+            currentState1 = BALL_CLOSE;
+        }
+        last_ball_state = ball_state;
+        break;
+
+    case BALL_CLOSE:
+        osDelay(100);
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 闭合气缸爪子
+        currentState1 = BALL_FINISH;                                   // 切换到反转状态
+        break;
+
+    case BALL_FINISH:
+        osDelay(200);                                                  // 延时 50ms
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保气缸爪子闭合
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        runCount++;
+        osDelay(200); // 延时 50ms
+        if (runCount < 2)
+        {
+            currentState1 = BALL_FORWARD; // 继续下一次运球
+            osDelay(50);
        }
        else
        {
-            currentState1 = BALL_IDLE; // 默认回到空闲状态
+            currentState1 = BALL_IDLE; // 完成两次，回到空闲
        }
        break;

-    case UP2:
-        ballDown();
-        break;
-
-    case DOWN2:
-        ballHadling();
-
+    default:
+        currentState1 = BALL_IDLE; // 默认回到空闲状态
        break;
    }

    Send_control();
 }

-int ball_state = 0;
-int last_ball_state = 0; // 上一次的光电状态
+#endif
+
+void Ball::Close(void)
+{
+    HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
+    HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+    currentState1 = BALL_IDLE;                                     // 回到空闲状态
+}
+
+void Ball::Hadling(void)
+{
+    switch (currentState1)
+    {
+    case BALL_IDLE:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        if (rc_key == DOWN2)
+        {
+            ball_exit = 0; // 进入流程时清零
+            currentState1 = BALL_FORWARD;
+        }
+        break;
+
+    case BALL_FORWARD:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 打开气缸爪子
+        osDelay(5);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET); // 打开下气缸
+        currentState1 = BALL_DROP;                                 // 切换到球下落状态
+        break;
+
+    case BALL_DROP:
+        osDelay(100);                                                // 延时 100ms
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 关闭下气缸
+        // 只响应第一次边沿
+        if (ball_exit == 1)
+        {
+            currentState1 = BALL_FLAG;
+        }
+        break;
+    }
+}
+
+void Ball::exit_Handling(void)
+{
+    switch (currentState1)
+    {
+    case BALL_IDLE:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        if (rc_key == DOWN2)
+        {
+            ball_exit = 0; // 进入流程时清零
+            currentState1 = BALL_FORWARD;
+        }
+        break;
+
+    case BALL_FORWARD:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 打开气缸爪子
+        osDelay(5);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET); // 打开下气缸
+        currentState1 = BALL_DROP;                                 // 切换到球下落状态
+        break;
+
+    case BALL_DROP:
+        osDelay(100);                                                // 延时 100ms
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 关闭下气缸
+        // 只响应第一次边沿
+        if (ball_exit == 1)
+        {
+            currentState1 = BALL_FLAG;
+        }
+        break;
+
+    case BALL_FLAG:
+        // osDelay(10); // 延时 10ms
+        //  只响应第二次边沿
+        if (ball_exit == 3)
+        {
+            currentState1 = BALL_CLOSE;
+        }
+        break;
+
+    case BALL_CLOSE:
+        osDelay(25);
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 闭合气缸爪子
+        currentState1 = BALL_FINISH;                                   // 切换到反转状态
+        break;
+
+    case BALL_FINISH:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保气缸爪子闭合
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        ball_exit = 0;                                                 // 流程完成后清零
+        break;
+
+    default:
+        currentState1 = BALL_IDLE; // 默认回到空闲状态
+        break;
+    }
+}
+
+void Ball::test_up(void)
+{
+
+    switch (currentState1)
+    {
+    case BALL_IDLE:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        if (rc_key == DOWN2)                                           // 检测按键是否被按下
+        {
+            step = 0;
+            currentState1 = BALL_FORWARD;
+        }
+        break;
+
+    case BALL_FORWARD:
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 打开气缸爪子
+        osDelay(5);
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET); // 打开下气缸
+        currentState1 = BALL_DROP;                                 // 切换到球下落状态
+        break;
+
+    case BALL_DROP:
+        osDelay(50);                                                 // 延时 100ms
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 关闭下气缸
+
+        // 步骤0：等待球离开（持球->无球）
+        if (step == 0 && ball_state == 1 && last_ball_state == 0)
+        {
+            step = 1;
+        }
+        // 步骤1：等待球反弹回来（无球->持球）
+        else if (step == 1 && ball_state == 0 && last_ball_state == 1)
+        {
+            step = 2;
+        }
+        // 步骤2：等待球完全上升离开（持球->无球）
+        else if (step == 2 && ball_state == 1 && last_ball_state == 0)
+        {
+            step = 3;
+            currentState1 = BALL_CLOSE; // 进入闭合气缸
+        }
+        last_ball_state = ball_state;
+        break;
+
+    case BALL_CLOSE:
+        // osDelay(25);
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 闭合气缸爪子
+        currentState1 = BALL_FINISH;                                   // 切换到完成状态
+        break;
+
+    case BALL_FINISH:
+        osDelay(50);                                                   // 延时 50ms
+        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保气缸爪子闭合
+        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        // currentState1 = BALL_IDLE; // 可选：回到空闲状态
+        break;
+
+    default:
+        currentState1 = BALL_IDLE; // 默认回到空闲状态
+        break;
+    }
+}

 void Ball::ballHadling(void)
 {
@ -211,210 +612,31 @@ void Ball::ballHadling(void)
    }
 }

-#endif
-
-#if ONE_CONTROL
-
-void Ball::ball_control()
+void Ball::ballHadling_two(void)
 {
-    hand_thread = osThreadFlagsGet();                              // 获取任务通知标志位
-    ball_state = HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin); // 读取光电状态(有球 0，无球 1)
-    
-
-    // 进攻
-    if (ready_key == SIDE)
+    switch (currentState1)
    {
-        osThreadFlagsClear(DEF_READY);
-        switch (rc_key)
-        {
-        case MIDDLE2:
-            Idle_control();
-            break;
-
-        case UP2:
-            ballDown();
-            break;
-
-        case DOWN2:
-            ballHadling();
-            break;
-        }
-
-        Send_control();
-    }
-    // 防守
-    else if(ready_key == DEF)
-    {
-        if(hand_thread & DEF_READY)
-        {
-         xiaomi.position = I_ANGLE; 
-
-        }
-                                    // 保持收回
+    case BALL_IDLE:
        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
-
-        osThreadFlagsClear(EXTEND_OK);
-        osThreadFlagsClear(READY_TELL); // 蓄力标志位
-        osThreadFlagsClear(HANDING_FINISH);
-
-        haveball=0;//变为空球状态
-
-        currentState1 = BALL_IDLE;
-
-        Send_control();
-    }
-
-}
-
-// 任务通知来作全过程
-
-void Ball::ballDown(void)
-{
-     osThreadFlagsClear(HANDING_FINISH);
-    switch (currentState1)
-    {
-    case BALL_IDLE:
-        xiaomi.position = I_ANGLE; // 保持收回
-        if (feedback->position_deg >= I_ANGLE - 1 && feedback->position_deg <= I_ANGLE + 1)
-        {
-            currentState1 = EXTEND_DOWN;
-        }
-        break;
-
-    case EXTEND_DOWN:
-        osDelay(500); // 不放太快
-        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET);
-        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);
-        // 检测到球自由下落一次就切换状态
-        if (ball_state == 1)
-        {
-            currentState1 = EXTEND_OUT;
-        }
-        break;
-
-    case EXTEND_OUT:
-        xiaomi.position = O_ANGLE; // 保持伸出
-        if (feedback->position_deg >= O_ANGLE - 1 && feedback->position_deg <= O_ANGLE + 1)
-        {
-
-            osThreadFlagsSet(task_struct.thread.shoot, EXTEND_OK);
-            currentState1 = EXTEND_FINISH; // 保持伸出，直到拨杆复位
-        }
-        break;
-
-    case EXTEND_FINISH:
-        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET);
-        xiaomi.position = O_ANGLE; // 一直保持伸出
-        // 等待拨杆复位（如切到MIDDLE2），Idle_control会负责回位
-        break;
-
-    default:
-        currentState1 = BALL_IDLE;
-        break;
-    }
-}
-
-
-void Ball::Idle_control()
-{
-    if(ball_state==1 && haveball==0)// 读取光电状态(有球 0，无球 1)
-    {
-      HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 确保爪气缸张开  
-
-    }
-    if(ball_state==0)
-    {
-        haveball=1;//变为持球状态
-        osDelay(500);
-        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸闭合
-    }
-
-
-    // HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保爪气缸关闭
-    HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
-
-    osThreadFlagsClear(EXTEND_OK);
-
-    if (ready_key == SIDE) // 检测是否准备好
-    {
-        if(hand_thread & HANDING_FINISH)
-        {
-            xiaomi.position=HANGDING_POS;//继续保持外伸
-
-        }
-        else
-        {
-          xiaomi.position = WAIT_POS;
-          if (feedback->position_deg >= WAIT_POS - 3)
-         {
-            // 只在READY_TELL未置位时发送，防止重复
-            if ((osThreadFlagsGet() & READY_TELL) == 0)
-            {
-                osThreadFlagsSet(task_struct.thread.shoot, READY_TELL);
-            }
-         }
-        }
-
-
-    }
-    else
-    {
-        xiaomi.position = I_ANGLE; // 默认回到收回位置
-    }
-
-    // 拨杆回到中间挡位时，回位并重置状态机
-    if (currentState1 == EXTEND_FINISH) // 转移后
-    {
-        xiaomi.position = I_ANGLE;
-        currentState1 = BALL_IDLE;
-    }
-    if (currentState1 == BALL_FINISH) // 运球完成
-    {
-        xiaomi.position = O_ANGLE;
-        currentState1 = BALL_IDLE;
-    }
-    else
-    {
-        currentState1 = BALL_IDLE;
-    }
-
-}
-
-
-
-int ball_state = 0;
-int last_ball_state = 0; // 上一次的光电状态
-
-void Ball::ballHadling(void)
-{
-
-    switch (currentState1)
-    {
-    case BALL_IDLE:
        if (rc_key == DOWN2)
        {
-            xiaomi.position = HANGDING_POS;                 // 外伸
-            if (feedback->position_deg >= HANGDING_POS - 0.5f) // 确保伸缩电机到位
-            {
-                currentState1 = BALL_FORWARD;
-            }
+            runCount = 0; // 每次拨动重新计数
+            currentState1 = BALL_FORWARD;
        }
        break;

    case BALL_FORWARD:
-        osDelay(300); // 不放太快
        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_SET); // 打开气缸爪子
        osDelay(5);
        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_SET); // 打开下气缸
-        currentState1 = BALL_DROP;                                 // 切换到球下落状态
+        currentState1 = BALL_DROP;
        break;

    case BALL_DROP:
-        osDelay(100); //不要动这里                                        
+        osDelay(100);
        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET); // 关闭下气缸
-        // 一直检测有球（ball_state == 0），等球离开
-        if (ball_state == 1 && last_ball_state == 0) // 球离开
+        if (ball_state == 1 && last_ball_state == 0)                 // 球离开
        {
            currentState1 = BALL_FLAG;
        }
@ -422,8 +644,7 @@ void Ball::ballHadling(void)
        break;

    case BALL_FLAG:
-        osDelay(10); // 延时 50ms
-        // 等待球弹回再次检测到球
+        osDelay(10);
        if (ball_state == 0 && last_ball_state == 1) // 球弹回
        {
            currentState1 = BALL_CLOSE;
@ -432,21 +653,28 @@ void Ball::ballHadling(void)
        break;

    case BALL_CLOSE:
-
-         osDelay(100); 
+        osDelay(25);
        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 闭合气缸爪子
-        currentState1 = BALL_FINISH;                                   // 切换到反转状态
+        currentState1 = BALL_FINISH;
        break;

    case BALL_FINISH:
-        osDelay(50); // 延时 50ms
-        osThreadFlagsSet(task_struct.thread.ball, HANDING_FINISH);
+        osDelay(50);
        HAL_GPIO_WritePin(CLOSE_GPIO_Port, CLOSE_Pin, GPIO_PIN_RESET); // 确保气缸爪子闭合
        HAL_GPIO_WritePin(DOWN_GPIO_Port, DOWN_Pin, GPIO_PIN_RESET);   // 确保下气缸关闭
+        runCount++;
+        if (runCount < 2)
+        {
+            currentState1 = BALL_FORWARD; // 继续下一次运球
+        }
+        else
+        {
+            currentState1 = BALL_IDLE; // 完成两次，回到空闲
+        }
        break;

    default:
-        currentState1 = BALL_IDLE; // 默认回到空闲状态
+        currentState1 = BALL_IDLE;
        break;
    }
 }
--- a/User/module/ball.hpp
+++ b/User/module/ball.hpp
@ -10,7 +10,7 @@
 #include "pid.h"
 #include "filter.h"
 #include "calc_lib.h"
-
+#include "nuc.h"


 // 定义状态枚举
@ -39,8 +39,7 @@ typedef enum
    DOWN2,
    IN,
    OUT,
-    SIDE,
-    DEF
+    SIDE
 }ball_rc_mode;

 // 定义光电传感器检测宏
@ -56,12 +55,18 @@ public:
    void Move_Extend(void);
    void Idle_control(void);
    void rc_mode(void);
-    void test_Handling(void);
+    void ballHadling_two(void);
    void ball_control(void);
+    void exit_Handling(void);
+    void Hadling(void);
+    void Close(void);
+    void test_up(void);
+    void data_get(const NUC_t &nuc_d);
  
    BallState_t currentState1; // 运球任务状态机
      int flag_thread;//暂时还没用到
 	  int ball_state ;//光电检测
+      float data;
    

    //小米电机伸缩
@ -74,10 +79,11 @@ public:
    int16_t extern_key;
    int16_t ready_key; //准备按键
    //用于传接球,运球后通知
+    volatile BallState_t ballStatus;//是否有球
    volatile uint32_t hand_thread;//接收传回的线程通知

 private:  
-    bool haveball;
+

    
 };
--- a/User/module/gimbal.cpp
+++ b/User/module/gimbal.cpp
@ -0,0 +1,113 @@
+#include "TopDefine.h"
+#include "gimbal.hpp"
+#include "remote_control.h"
+#include "calc_lib.h"
+#include "FreeRTOS.h"
+#include <cmsis_os2.h>
+
+#define KP 0.12
+#define KD 0.008
+//可活动角度
+#define ANGLE_ALLOW 1.0f
+extern RC_ctrl_t rc_ctrl;
+NUC_t nuc;
+
+const fp32 Gimbal:: Gimbal_speed_PID[3] = {50, 0.1,  0};
+const fp32 Gimbal:: Gimbal_angle_PID[3]=  { 5, 0.01, 0};
+
+#if GM6020ING ==1
+Gimbal::Gimbal()
+{
+  // GM6020_Motor = get_motor_point(6);
+  // GM6020_Motor->type = GM6020;
+  // PID_init(&speed_pid,PID_POSITION,Gimbal_speed_PID,16000, 6000);
+  // PID_init(&angle_pid,PID_POSITION,Gimbal_angle_PID,5000, 2000);
+
+  // result = 0;
+  // angleSet = 0;
+
+}
+
+void Gimbal::gimbalFlow()
+{
+  int16_t delta[1];
+  //angleSet = angle1;
+  delta[0] = PID_calc(&angle_pid,GM6020_Motor->total_angle,angleSet);
+  result = PID_calc(&speed_pid, GM6020_Motor->speed_rpm, delta[0]);
+
+  CAN_cmd_1FF(0,0,result,0,&hcan1);
+  osDelay(1);
+
+}
+
+void Gimbal::gimbalZero()
+{
+  angleSet=0;
+  //gimbalFlow();
+
+}
+
+void Gimbal::gimbalVision(const NUC_t &nuc)
+{
+    int16_t delta[1];
+    angleSet = nuc.vision.x;
+    delta[0] = PID_calc(&angle_pid,GM6020_Motor->total_angle,angleSet);
+    result = PID_calc(&speed_pid, GM6020_Motor->speed_rpm, delta[0]);
+
+    CAN_cmd_1FF(0,0,result,0,&hcan1);
+    osDelay(1);
+}
+
+
+
+#else
+Gimbal::Gimbal()
+{
+
+			Kp = KP;
+			Kd = KD;
+			allowRange = ANGLE_ALLOW;
+}   
+
+void Gimbal::gimbalInit(void)
+{
+		int i;
+    GO_M8010_init();
+    for(i = 0;i < GO_NUM;i ++)
+    {
+        goData[i] = getGoPoint(i);//获取电机数据指针
+
+        angleSet[i] = 0;
+        offestAngle[i] = 0;
+				GO_M8010_send_data(&huart6, i,0,0,0,0,0,0);
+				offestAngle[i] = goData[i]->Pos;
+				HAL_Delay(100);
+
+    }
+		
+}
+
+void Gimbal::gimbalFlow(void)
+{
+
+    //angleSet[0] = map_fp32((float)rc_ctrl.ch[3],-800.0f,800.0f,-allowRange,allowRange) + offestAngle[0];
+    GO_M8010_send_data(&huart6, 0,0,0,angleSet[0],1,KP,KD);
+		osDelay(1);
+
+
+}
+
+
+void Gimbal::gimbalZero(void)
+{
+  GO_M8010_send_data(&huart6, 0,0,0,0,0,0,0);
+}
+
+void Gimbal::gimbalVision(const NUC_t &nuc)
+{
+    angleSet[0] = nuc.vision.x;
+    GO_M8010_send_data(&huart6, 0,0,0,angleSet[0],1,KP,KD);
+    osDelay(1);
+}
+
+#endif
--- a/User/module/gimbal.hpp
+++ b/User/module/gimbal.hpp
@ -0,0 +1,57 @@
+#ifndef GIMBAL_HPP
+#define GIMBAL_HPP
+
+#include "GO_M8010_6_Driver.h"
+#include "djiMotor.h"
+#include "pid.h"
+#include "nuc.h"
+
+class Gimbal
+{
+public:
+    Gimbal();
+    void gimbalFlow(void);//云台随遥控器转动
+    void gimbalZero(void);//云台零阻尼模式
+		void gimbalInit(void);//go初始化
+    void gimbalVision(const NUC_t &nuc); // 接收 NUC_t 数据
+
+    int16_t result;
+    //暂存要发送的扭矩
+    //float result[GO_NUM]; 
+//		float Kp;
+//		float Kd;
+private:
+
+#if GM6020ING == 1
+//GM6020电机数据
+ motor_measure_t *GM6020_Motor;
+
+ static const float Gimbal_speed_PID[3];
+ static const float Gimbal_angle_PID[3];
+
+  //电机速度pid结构体
+  pid_type_def speed_pid;
+  //位置环pid
+  pid_type_def angle_pid;
+
+  float angleSet;
+
+#else
+    motor_measure_t *motorData[GO_NUM];
+  //视觉发送的要调的角度
+    float self_angleSet;
+    GO_Motorfield* goData[GO_NUM];
+    //暂存目标位置
+    float angleSet[GO_NUM];
+    float offestAngle[GO_NUM];//go数据
+		float Kp;
+		float Kd;
+		float allowRange;
+
+#endif    
+};
+
+
+
+
+#endif
--- a/User/module/shoot.cpp
+++ b/User/module/shoot.cpp
--- a/User/module/shoot.hpp
+++ b/User/module/shoot.hpp
@ -18,8 +18,7 @@ typedef enum {
    SHOOT_RETURN,       // 自动返回状态
    //运射配合
    GO_TOP,
-    BAKC,
-    WAIT_CHANGE
+    BAKC
 } ShootState_t;

 // // 定义状态枚举
@ -41,10 +40,8 @@ typedef enum
    WAIT,
    TEST,
    VSION,
-    PASS,
    OFFENSIVE,
    DEFENSE
-    
 }rc_mode;

 // 光电传感器读取宏
@ -87,7 +84,6 @@ public:

    //滤波器
    LowPassFilter2p_t distance_filter; // 用于滤波视觉距离
-    LowPassFilter2p_t pass_filter;

    //==========================公共变量==========================
    int16_t rc_key; //遥控器按键
@ -98,7 +94,6 @@ public:

    volatile uint32_t shoot_thread;//接收传回的线程通知
    fp32 distance;   //视觉距离
-    fp32 pass_distance;   //视觉距离

 private:
    //扳机2006
@ -114,8 +109,6 @@ private:
    
    float limit_speed;//go电机限速

-    int shoot_wait;
-

 };

--- a/User/task/ballTask.cpp
+++ b/User/task/ballTask.cpp
@ -6,10 +6,14 @@
 #include "ball.hpp"
 #include "remote_control.h"
 #include "vofa.h"
+#include "nuc.h"
 extern RC_ctrl_t rc_ctrl;
 Ball ball;
+NUC_t Data; 

-
+//检查光电
+int abc=0;
+//3   👆1800 中1000 👇200
 extern int speedm;

 void FunctionBall(void *argument)
@ -18,7 +22,7 @@ void FunctionBall(void *argument)

    const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_BALL;
 	
-	  osDelay(6000);//等待极致控制板启动
+		osDelay(6000);//等待极致控制板启动
    XiaomiWait_init(1,&hcan2); //小米电机初始化
    
    uint32_t tick = osKernelGetTickCount();
@ -28,10 +32,23 @@ void FunctionBall(void *argument)
 #ifdef DEBUG
     task_struct.stack_water_mark.ball = osThreadGetStackSpace(osThreadGetId());  
 #endif          
-      ball.rc_mode(); // 遥控器模式  
-    
-      ball.ball_control(); // 控制球的动作    

+    abc=HAL_GPIO_ReadPin(up_ball_GPIO_Port, up_ball_Pin);
+
+     ball.rc_mode(); // 遥控器模式  
+
+    
+     	if (osMessageQueueGet(task_struct.msgq.nuc, &Data, NULL, 0) == osOK)
+      {
+          ball.data_get(Data);
+      }
+     
+       ball.Move_Extend();
+       ball.ball_control(); // 控制球的动作   
+      
+      ball.Send_control();
+
+     
    tick += delay_tick; /* 计算下一个唤醒时刻 */
    osDelayUntil(tick);
    
--- a/User/task/encodeCan.cpp
+++ b/User/task/encodeCan.cpp
@ -26,7 +26,7 @@ void FunctionCan(void *argument)
     task_struct.stack_water_mark.can = osThreadGetStackSpace(osThreadGetId()); 
    
  #endif 
-        //waitNewDji();
+        waitNewDji();
        djiMotorEncode();
        can2MotorEncode();

--- a/User/task/gimbalTask.cpp
+++ b/User/task/gimbalTask.cpp
@ -0,0 +1,47 @@
+#include "TopDefine.h"
+#include "FreeRTOS.h"
+#include "userTask.h"
+#include <cmsis_os2.h>
+#include "gimbalTask.hpp"
+#include "gimbal.hpp"
+#include "main.h"
+#include "remote_control.h"
+#include "nuc.h"
+Gimbal gimbal;
+// NUC_t nucData; // 用于存储从队列接收的数据
+extern RC_ctrl_t rc_ctrl;
+int cnt1=0;
+
+void FunctionGimbal(void *argument)
+{
+	(void)argument; /* 未使用argument，消除警告 */
+
+    const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CTRL_GIMBAL;
+	
+	HAL_GPIO_WritePin(LED_G_GPIO_Port,LED_G_Pin,GPIO_PIN_SET);
+
+	uint32_t tick = osKernelGetTickCount();
+
+	while(1)
+	{
+   #ifdef DEBUG
+		task_struct.stack_water_mark.gimbal = osThreadGetStackSpace(osThreadGetId());  
+   #endif 
+
+		//cnt1++;
+
+    //  gimbal.gimbalFlow();
+		// 从消息队列接收视觉数据
+		// if (osMessageQueueGet(task_struct.msgq.nuc, &nucData, NULL, 0) == osOK)
+		// {
+		// 	// 使用接收到的视觉数据调整云台
+		// 	//gimbal.gimbalVision(nucData);
+		// }
+			
+		osDelay(1);
+
+		tick += delay_tick; /* 计算下一个唤醒时刻 */
+        osDelayUntil(tick);
+	}
+}
+
--- a/User/task/gimbalTask.hpp
+++ b/User/task/gimbalTask.hpp
@ -0,0 +1,5 @@
+#ifndef GIMBALTASK_HPP
+#define GIMBALTASK_HPP
+
+
+#endif
--- a/User/task/nucTask.cpp
+++ b/User/task/nucTask.cpp
@ -1,67 +1,58 @@
 #include "nucTask.hpp"
 #include "nuc.h"
 #include "userTask.h"
-#include "TopDefine.h" //事件组的一些东西
+#include "TopDefine.h"//事件组的一些东西
 #include "FreeRTOS.h"
 #include <cmsis_os2.h>
 #include <stdio.h>
-#include "bsp_buzzer.h"
+

 #ifdef DEBUG

 NUC_t cmd_fromnuc;
+//int send[3]={1,2,3};
+float send[3]={1,2,3};

 #endif

 void Function_nuc(void *argument)
 {
-        (void)argument; /* 未使用argument，消除警告 */
+    (void)argument; /* 未使用argument，消除警告 */
+    
+   const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_AI;

-        const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_AI;
+    NUC_Init(&cmd_fromnuc);
+  
+    HAL_GPIO_WritePin(LED_G_GPIO_Port,LED_G_Pin,GPIO_PIN_SET);

-        NUC_Init(&cmd_fromnuc);
+   uint32_t tick = osKernelGetTickCount();

-        uint32_t tick = osKernelGetTickCount();
-
-        while (1)
-        {
+    while(1)
+    {
 #ifdef DEBUG
-        task_struct.stack_water_mark.nuc = osThreadGetStackSpace(osThreadGetId());
-#endif
+        task_struct.stack_water_mark.nuc = osThreadGetStackSpace(osThreadGetId());  
+#endif         
        NUC_StartReceiving();

-        // NUC_RawParse(&cmd_fromnuc);
-        // NUC_SendPacket(&send, sizeof(send)); // 发送数据包
-        // 掉线处理有空写
-        //  if(NUC_WaitDmaCplt())
-        //  {
-        //      NUC_RawParse(&cmd_fromnuc);
-
+        NUC_RawParse(&cmd_fromnuc);
+        //NUC_SendPacket(&send, sizeof(send)); // 发送数据包
+//掉线处理有空写 
+        // if(NUC_WaitDmaCplt())
+        // {
+        //     NUC_RawParse(&cmd_fromnuc);
+            
        // }
        // else
        // {
        //     NUC_HandleOffline(&cmd_fromnuc);
        // }

-        if (NUC_RawParse(&cmd_fromnuc) == DEVICE_OK)
-        {
-                //BSP_Buzzer_Stop();
-                HAL_GPIO_WritePin(LED_G_GPIO_Port, LED_G_Pin, GPIO_PIN_SET);   
-                HAL_GPIO_WritePin(LED_R_GPIO_Port, LED_R_Pin, GPIO_PIN_RESET); 
-                osMessageQueueReset(task_struct.msgq.nuc);                     // 清空消息队列
-                osMessageQueuePut(task_struct.msgq.nuc, &(cmd_fromnuc), 0, 0);
-        }
-        else
-        {
+        osMessageQueueReset(task_struct.msgq.nuc); // 清空消息队列
+        osMessageQueuePut(task_struct.msgq.nuc,&(cmd_fromnuc),0,0);
+        osDelay(2);

-                // BSP_Buzzer_Start();
-                // BSP_Buzzer_Set(1, 5000);
-                HAL_GPIO_WritePin(LED_G_GPIO_Port, LED_G_Pin, GPIO_PIN_RESET); 
-                HAL_GPIO_WritePin(LED_R_GPIO_Port, LED_R_Pin, GPIO_PIN_SET);   
-                NUC_HandleOffline(&cmd_fromnuc);
-        }
-
-        tick += delay_tick; /* 计算下一个唤醒时刄1ķ*/
-        osDelayUntil(tick);
-        }
+       tick += delay_tick; /* 计算下一个唤醒时刄1ķ*/
+       osDelayUntil(tick);
+        
+    }
 }
--- a/User/task/shootTask.cpp
+++ b/User/task/shootTask.cpp
@ -10,14 +10,14 @@ extern RC_ctrl_t rc_ctrl;
 Shoot shoot;
 NUC_t nucData; // 自瞄

-
+int aaaxxx=0;

 void FunctionShoot(void *argument)
 {
 	(void)argument; /* 未使用argument，消除警告 */

-    const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_SHOOT;
-	osDelay(3000);//等待M2006电机启动
+    const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CTRL_SHOOT;
+
 	uint32_t tick = osKernelGetTickCount();

 while(1)
@ -28,12 +28,12 @@ while(1)

 	shoot.rc_mode(); //遥控器模式
 	
-	if (osMessageQueueGet(task_struct.msgq.nuc, &nucData, NULL, 0) == osOK)
-	{
-		shoot.distanceGet(nucData);
-	}
+	// if (osMessageQueueGet(task_struct.msgq.nuc, &nucData, NULL, 0) == osOK)
+	// {
+	// 	shoot.distanceGet(nucData);
+	// }

-	shoot.shoot_control();
+	// shoot.shoot_control();
 	
 	tick += delay_tick; /* 计算下一个唤醒时刻 */
 	osDelayUntil(tick);		
--- a/User/task/userTask.h
+++ b/User/task/userTask.h
@ -13,8 +13,11 @@ extern "C" {
 /* Exported constants ------------------------------------------------------- */

 /* 所有任务都要define一个“任务运行频率”和“初始化延时” */
-#define TASK_FREQ_SHOOT (500u)
-#define TASK_FREQ_CAN (500u)
+#define TASK_FREQ_CTRL_GIMBAL (250u)
+#define TASK_FREQ_CTRL_SHOOT (500u)
+#define TASK_FREQ_CTRL_COMMAND (500u)
+#define TASK_FREQ_MONITOR (2u)
+#define TASK_FREQ_CAN (1500u)
 #define TASK_FREQ_AI (500u)
 #define TASK_FREQ_BALL (500u)

@ -39,6 +42,8 @@ typedef struct
        //osThreadId_t rc;
        osThreadId_t nuc;
        osThreadId_t shoot;
+        osThreadId_t gimbal;
+        //osThreadId_t handling;
        osThreadId_t ball;

    }thread;
@ -59,23 +64,32 @@ typedef struct
    #ifdef DEBUG
    struct {
        UBaseType_t can;
+        //UBaseType_t rc;
        UBaseType_t nuc;
        UBaseType_t shoot;
+        UBaseType_t gimbal;
+        //UBaseType_t handling;
        UBaseType_t ball;

    } stack_water_mark; /* stack使用 */

    struct {
        float can;
+        //float rc;
        float nuc;
        float shoot;
+        float gimbal;
+        //float handling;
        float ball;
    } freq; /* 任务运行频率 */

    struct {
        float can;
+        //float rc;
        float nuc;
        float shoot;
+        float gimbal;
+        //float handling;
        float ball;
    } last_up_time; /* 任务最近运行时 */
 #endif
@ -92,6 +106,7 @@ extern const osEventFlagsAttr_t attr_event;


 /* Exported functions prototypes -------------------------------------------- */
+void FunctionTake(void *argument);
 void FunctionShoot(void *argument);
 void FunctionCan(void *argument);
 void FunctionRc(void *argument);
Author	SHA1	Message	Date
ws	464544450b	全自动运球	2025-07-16 22:12:51 +08:00
ws	cbbbc1a0cc	位置更改	2025-07-09 09:43:10 +08:00
ws	873f653116	备赛场地有点不平，还没开测	2025-07-07 13:25:06 +08:00
ws	9bfe4580f8	微调伸缩位置	2025-07-02 19:50:35 +08:00
ws	7e2fb5370a	单拨两次运球但会出小失误	2025-07-01 15:00:28 +08:00
ws	4de285abfb	ok去试试一键运两次球	2025-07-01 00:14:45 +08:00
ws	512c223748	更新？	2025-06-30 23:55:15 +08:00
ws	94eadcfa16	拨杆+码盘	2025-06-30 23:36:01 +08:00
ws	960778a7fb	运球赛回弹拨杆码盘跑点	2025-06-30 23:29:54 +08:00
ws	0abece2ee1	回弹式拨杆	2025-06-28 02:22:44 +08:00
ws	117acf4142	运球赛	2025-06-28 01:54:37 +08:00
ws	7b54a46bd3	回弹按键运两次球	2025-06-26 15:49:00 +08:00