详细照片2
原始照片，用于采集训练
放大训练照片
放大训练照片2
雷达驱动代码# RadarDriver - By: CaiZhipeng - 周二 6月 27 2023
import time, math,image
from fpioa_manager import fm
from machine import Timer,PWM,UART
class RadarData:
def __init__(self,angle, distance):
self.angle = angle
self.distance = distance
def PrintRadarData(self):
print("angle:{:0.2f} distance:{:0.2f}".format(self.angle,self.distance))
def ToRectangularCoordinates(self):
angle_rad = math.radians(self.angle)
x = self.distance * math.cos(angle_rad)
y = self.distance * math.sin(angle_rad)
return x, y
def ToBytes(self):
angle_int = int(self.angle)
distance_int = int(self.distance)
angle_byte_H = (angle_int >> 8) & 0xFF
angle_byte_L = angle_int & 0xFF
distance_byte_H = (distance_int >> 8) & 0xFF
distance_byte_L = distance_int & 0xFF
return
class RadarClusterData:
def __init__(self,ClusterList):
self.ClusterList = ClusterList
self.length = len(ClusterList)
angles =
distances =
average_angle = sum(angles) / self.length
average_distance = sum(distances) / self.length
self.AverageRadarData = RadarData(average_angle,average_distance)
self.VarianceAngle = sum((x - average_angle) ** 2 for x in angles) / self.length
self.VarianceDistance = sum((x - average_distance) ** 2 for x in distances) / self.length
def PrintRadarClusterData(self):
print("AverageRadarData:")
self.AverageRadarData.PrintRadarData()
print("VarianceAngle:{:0.2f} VarianceDistance:{:0.2f}".format(self.VarianceAngle,self.VarianceDistance))
class RadarDbscan:
def __init__(self,DataList,Eps,MinPts):
self.DataList = DataList
self.Eps = Eps
self.MinPts = MinPts
self.ClusterList = []
self.NoiseList = []
def GetDistance(self, Data1, Data2):
# 定义极坐标的距离公式
theta_diff = Data1.angle - Data2.angle
return math.sqrt(Data1.distance**2 + Data2.distance**2 - 2*Data1.distance*Data2.distance*math.cos(theta_diff))
def GetNeighbour(self, Data):
# 获取邻居
NeighbourList = []
for data in self.DataList:
if self.GetDistance(Data,data) <= self.Eps:
NeighbourList.append(data)
return NeighbourList
def GetCoreObject(self):
# 获取核心对象
CoreObjectList = []
for data in self.DataList:
if len(self.GetNeighbour(data)) >= self.MinPts:
CoreObjectList.append(data)
return CoreObjectList
def GetCluster(self):
# 获取聚类
CoreObjectList = self.GetCoreObject()
ClusterList = []
NoiseList = []
OkList = []
for data in CoreObjectList:
if data not in OkList:
Cluster = []
Cluster.append(data)
OkList.append(data)
NeighbourList = self.GetNeighbour(data)
for Neighbour in NeighbourList:
if Neighbour not in Cluster:
Cluster.append(Neighbour)
OkList.append(Neighbour)
NewClusterData = RadarClusterData(Cluster)
ClusterList.append(NewClusterData)
for data in self.DataList:
if data not in OkList:
NoiseList.append(data)
self.ClusterList = ClusterList
self.NoiseList = NoiseList
return ClusterList, NoiseList
def SortByCluster_size(self):
self.ClusterList.sort(key=lambda x: x.length)
def SortByVariance_distance(self):
self.ClusterList.sort(key=lambda x: x.VarianceDistance)
def SortByVariance_angle(self):
self.ClusterList.sort(key=lambda x: x.VarianceAngle)
class RadarDriver:
# 雷达驱动类
def __init__(self,port_RX, port_TX,PWM_pin,PWM_freq,PWM_duty):
# 进行初始化设置和准备工作
fm.register(port_RX, fm.fpioa.UART2_RX, force=True)
fm.register(port_TX, fm.fpioa.UART2_TX, force=True)
tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)
self.Time_interupt = Timer(Timer.TIMER1, Timer.CHANNEL0, mode=Timer.MODE_PERIODIC, period=4000, callback=self.ClearFlash)
self.MotorPWM = PWM(tim, freq=PWM_freq, duty=PWM_duty, pin=PWM_pin)
self.RplidarA1uart = UART(UART.UART2, 115200, read_buf_len=1024)
self.RadarDataList = []
self.SwitchFlag = 0
self.MinAngle = 0
self.MaxAngle = 360
self.MaxDistance = 500
self.MapImg = image.Image(size=(224,224))
def CheckHealthy(self):
CheckData =
Res = []
self.RplidarA1uart.write(bytes(CheckData))
text = self.RplidarA1uart.read()
if text:
for txt in text:
Res.append(txt)
if len(Res) >= 8:
if(Res == 0xA5 and
Res == 0x5A and
Res == 0x03 and
Res == 0x00 and
Res == 0x00 and
Res == 0x00 and
Res == 0x06):
if Res == 0x00:
return 1
else:
return Res[-2:]
return 0
def EnableRplidar(self):
if(self.CheckHealthy()):
self.Time_interupt.start()
self.MotorPWM.enable()
return 1
return 0
def DisableRplidar(self):
self.PauseScan()
self.MotorPWM.disable()
def PauseScan(self):
if self.SwitchFlag == 1:
self.Time_interupt.stop()
EndData =
self.RplidarA1uart.write(bytes(EndData))
self.SwitchFlag = 0
def ContinueScan(self):
Res = []
StartData =
if self.SwitchFlag == 0:
self.Time_interupt.start()
self.RplidarA1uart.write(bytes(StartData))
text = self.RplidarA1uart.read()
if text:
for txt in text:
Res.append(txt)
if len(Res) >= 7:
if(Res == 0xA5 and
Res == 0x5A and
Res == 0x54 and
Res == 0x00 and
Res == 0x00 and
Res == 0x40 and
Res == 0x82):
self.SwitchFlag = 1
return 1
return 0
def Decode_q3_6bit(self, number):
if number >= 32:
number = number - 64
return number / 8.0
def validate_packet(self,packet):
TrueChkSum = (packet&0x0F) | ((packet&0x0F)<<4)
data = packet
ChkSum = 0
for byte in data:
ChkSum ^= byte
return TrueChkSum == ChkSum
def ExpressAnalyseByte(self, Byte, Start_angle, Delta_angle, index):
distance1 = ((Byte&0xFC) >> 2 | Byte << 6)/10
distance2 = ((Byte&0xFC) >> 2 | Byte << 6)/10
theta1 = (Byte&0x03)<<4 | (Byte&0x0F)
theta2 = (Byte&0x03)<<4 | ((Byte&0xF0) >> 4)
angle1 = Start_angle + Delta_angle / 32.0 * index - self.Decode_q3_6bit(theta1)
angle2 = Start_angle + Delta_angle / 32.0 * (index+1) - self.Decode_q3_6bit(theta2)
if angle1 > 360:
angle1 = angle1 - 360
if angle2 > 360:
angle2 = angle2 - 360
if distance1>0:
self.RadarDataList.append(RadarData(angle1,distance1))
if distance2>0:
self.RadarDataList.append(RadarData(angle2,distance2))
def AngleDiff(self, Start_angle, new_Start_angle):
if Start_angle <= new_Start_angle:
result = new_Start_angle - Start_angle
else:
result = 360 + new_Start_angle - Start_angle
return result
def ExpressAnalyseData(self, data):
Start_angle = (data | (data&0x7F) << 8)/64.0
new_Start_angle = (data | (data&0x7F) << 8)/64.0
Delta_angle = self.AngleDiff(Start_angle,new_Start_angle)
for i in range(16):
self.ExpressAnalyseByte(data,Start_angle,Delta_angle,2*i+1)
def ExpressGetData(self, batch):
temp = []
RplidarA1Data = []
AnalyseRadarDataList = []
self.RadarDataList.clear()
while len(self.RadarDataList) < 32:
self.ContinueScan()
ResFlag = 0
text = self.RplidarA1uart.read(84*batch)
if text:
#self.PauseScan()
for txt in text:
if(txt & 0xF0) == 0xA0 and ResFlag == 0:# 验证头帧
temp.append(txt)
ResFlag = 1
elif(txt & 0xF0) == 0x50 and ResFlag == 1:# 验证头帧
temp.append(txt)
ResFlag = 2
elif ResFlag < 2:# 有冗余数据舍去
temp.clear()
ResFlag = 0
if ResFlag == 2:
RplidarA1Data.extend(temp)# 存放头数据并开始接收
temp.clear()
ResFlag = 3
elif ResFlag == 3 and len(RplidarA1Data) < 84:
RplidarA1Data.append(txt)
if len(RplidarA1Data) == 84:# 一次接收完成
if self.validate_packet(RplidarA1Data):# 验证数据
AnalyseRadarDataList.append(RplidarA1Data[:])# 存入解析队列（一个数据解析需要它的下一个数据的一个表象）
if len(AnalyseRadarDataList) == 2:# 开始解析
self.ExpressAnalyseData(AnalyseRadarDataList)
AnalyseRadarDataList.pop(0)
RplidarA1Data.clear()
temp.clear()
ResFlag = 0
def ClearFlash(self,Time_interupt):
self.RplidarA1uart.read(1024)
def ReadRadarData(self):
if self.MaxAngle > 360:
temp = self.MaxAngle
while self.MaxAngle > 360:
self.MaxAngle = self.MaxAngle - 360
self.RadarDataList =
self.MaxAngle = temp
else:
self.RadarDataList =
self.RadarDataList.sort(key=lambda x: x.angle)
return self.RadarDataList
def CreatMapping(self,weight=224,height=224):
self.MapImg.clear()
X_max = self.MaxDistance * math.cos(math.radians(45))
Y_max = self.MaxDistance * math.cos(math.radians(45))
self.ReadRadarData()
for data in self.RadarDataList:
x,y = data.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_line(x,y,x,y,(225,225,255),thickness = 3)
return self.MapImg
def CreatDbscanMapping(self,ClusterTotalList,NoiseList,weight=224,height=224):
self.MapImg.clear()
X_max = self.MaxDistance * math.cos(math.radians(45))
Y_max = self.MaxDistance * math.cos(math.radians(45))
for ClusterInedex in range(len(ClusterTotalList)):
g = int((ClusterInedex / len(ClusterTotalList)) * 255)
b = int(((len(ClusterTotalList) - ClusterInedex) / len(ClusterTotalList)) * 255)
for data in ClusterTotalList.ClusterList:
x,y = data.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_line(x,y,x,y,(255,g,b),thickness = 3)
for data in NoiseList:
x,y = data.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_line(x,y,x,y,(255,0,0),thickness = 3)
return self.MapImg
def CreatAveragRadarDataMapping(self,ClusterTotalList,Dbscan,weight=224,height=224):
MaxIndex = 2
self.MapImg.clear()
X_max = self.MaxDistance * math.cos(math.radians(45))
Y_max = self.MaxDistance * math.cos(math.radians(45))
for Cluster in ClusterTotalList:
x,y = Cluster.AverageRadarData.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_line(x,y,x,y,(255,255,255),thickness = 3)
Dbscan.SortByVariance_angle()
if len(ClusterTotalList) < 2:
MaxIndex = len(ClusterTotalList)
for i in range(MaxIndex):
x,y = ClusterTotalList.AverageRadarData.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_circle(x,y,10,(255,0,0),thickness = 3)
Dbscan.SortByVariance_distance()
for i in range(MaxIndex):
x,y = ClusterTotalList.AverageRadarData.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_circle(x,y,10,(0,255,0),thickness = 3)
Dbscan.SortByCluster_size()
for i in range(MaxIndex):
x,y = ClusterTotalList.AverageRadarData.ToRectangularCoordinates()
x = int(x / X_max * weight / 2 + weight / 2)
y = int(y / Y_max * height / 2 + height / 2)
self.MapImg.draw_circle(x,y,10,(0,0,255),thickness = 3)
return self.MapImg
def SetScope(self,minangle,maxangle,distance=500):
minangle = int(minangle)
maxangle = int(maxangle)
distance = int(distance)
if minangle < maxangle and minangle < 360 and maxangle < 720:
if minangle < 0:
minangle = 0
if maxangle > 360 and maxangle-360 > minangle:
maxangle = 360
self.MinAngle = minangle
self.MaxAngle = maxangle
if distance > 0 :
self.MaxDistance = distance
return self.MinAngle,self.MaxAngle,self.MaxDistance
def GetScope(self):
return self.MinAngle,self.MaxAngle,self.MaxDistance
#Radar = RadarDriver(10,11,31,50000,69)
#Radar.EnableRplidar()
#while True:
#Radar.ExpressGetData(10)
#DataList = Radar.ReadRadarData()
#for data in DataList:
#data.PrintRadarData()
#print(data.ToBytes())
照片拍摄驱动代码# Untitled - By: CaiZhipeng - 周日 7月 16 2023
import os, sensor, utime, lcd
class TakePhotoDriver:
def __init__(self, DataNum, DataName, FileName):
self.datanum = DataNum
self.dataname = DataName
self.filename = FileName
self.nownum = 1
lcd.init(freq=15000000)
def rename_files_in_directory(self,path):
files = os.listdir(path)
jpg_files = .isdigit()]
jpg_files = sorted(jpg_files, key=lambda x: int(x.split('.')))
for idx, file in enumerate(jpg_files, start=1):
old_file_path = "{}/{}".format(path, file)
new_file_path = "{}/{}.jpg".format(path, idx)
if old_file_path != new_file_path:
os.rename(old_file_path, new_file_path)
def InitDataFile(self,modes = 1):
if not "TrainData" in os.listdir("/sd"):
os.mkdir("/sd/TrainData")
if not self.filename in os.listdir("/sd/TrainData"):
os.mkdir("/sd/TrainData/%s" % self.filename)
if not self.dataname in os.listdir("/sd/TrainData/%s" % self.filename):
os.mkdir("/sd/TrainData/{}/{}".format(self.filename, self.dataname))
path = "/sd/TrainData/{}/{}".format(self.filename, self.dataname)
if modes==1:
self.rename_files_in_directory(path)
files = os.listdir(path)
jpg_files = .isdigit()]
max_index = 0
for f in jpg_files:
if f.endswith('.jpg'):
index = int(f.split('.'))
max_index = max(index, max_index)
self.nownum = max_index + 1
def TakePhoto(self,img = None,fliename = -1):
if self.nownum < self.datanum:
if img:
if fliename == -1:
img.save("/sd/TrainData/{}/{}/{}.jpg".format(self.filename, self.dataname, self.nownum))
else:
img.save("/sd/TrainData/{}/{}/{}.jpg".format(self.filename, self.dataname, fliename))
else:
if fliename == -1:
sensor.snapshot().save("/sd/TrainData/{}/{}/{}.jpg".format(self.filename, self.dataname, self.nownum))
else:
sensor.snapshot().save("/sd/TrainData/{}/{}/{}.jpg".format(self.filename, self.dataname, fliename))
utime.sleep_ms(5)
self.nownum += 1
def ShowInformation(self):
if self.datanum - self.nownum > 0:
ShowImg = sensor.snapshot()
ShowImg.draw_string(0,0,self.filename+"/"+self.dataname,(255,0,0))
ShowImg.draw_string(0,20,"NeedNum:{}/{}".format(self.nownum, self.datanum),(255,0,0))
lcd.display(ShowImg)
else:
lcd.draw_string(110, 120, "Data Is OK", lcd.BLACK, lcd.WHITE)
串口飞机通讯驱动代码# RadarDriver - By: CaiZhipeng - 周二 6月 27 2023
from Driver import UartDriver as UD,TakePhotoDriver as TD,RadarDriver as RD
import sensor,image,lcd,time,gc, sys, os
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
sensor.set_windowing((224, 224))
sensor.set_vflip(1)
#lcd.init(freq=15000000)
labels = ['FlightPark']
anchors =
ParkingTask = kpu.load("/sd/Models/Parking.kmodel")
ParkingNetwork = kpu.init_yolo2(ParkingTask, 0.4, 0.3, 5, anchors)
UartToStc32 = UD.UartDriver(6, 7,,)#rx tx 发送帧头 接收帧头
MyRadar = RD.RadarDriver(10, 11, 31, 50000, 70)
MyRadar.EnableRplidar()
MyData = TD.TakePhotoDriver(DataNum = 200, DataName = "Radar", FileName = "2021Game")
MyData.InitDataFile()
def ToBytes(num):
num_H = (num >> 8) & 0xFF
num_L = num & 0xFF
return
def JoinBytes(Bytes):
low_byte = Bytes
high_byte = Bytes
return (high_byte << 8) | low_byte
def GetMinDistance(Radar):
Radar.ExpressGetData(10)
DataList = Radar.ReadRadarData()
if DataList:
min_radar_data = min(DataList, key=lambda radar_data: radar_data.distance)
return min_radar_data.ToBytes()
else:
return
def SetAngleScope(Scope,Radar):
MinAngle = JoinBytes(Scope)
MaxAngle = JoinBytes(Scope)
Maxdistance = JoinBytes(Scope)
Radar.SetScope(int(MinAngle),(MaxAngle))
def GetAngleScope(Radar):
minangle,maxangle,maxdistance = Radar.GetScope()
return ToBytes(minangle)+ToBytes(maxangle)+ToBytes(maxdistance)
def FindfrequentBarCode(List):
counter = {}
for s in List:
if s not in counter:
counter = 0
counter += 1
Frequentstr = max(counter, key=counter.get)
return int(Frequentstr)
def IdentifyBarCode(Batch,TimeOut):
timeout = TimeOut
DataList = []
while(len(DataList) < Batch and timeout > 0):
img = sensor.snapshot()
barcodes = img.find_barcodes()
if barcodes:
for barcode in barcodes:
barcodeData = barcode.payload()
(x, y, w, h) = barcode.rect()
#img.draw_rectangle(barcode.rect())
#img.draw_string(x, y, barcodeData, color=(0,255,0), scale=1)
#lcd.display(img)
DataList = DataList +
else:
timeout -= 1
if len(DataList) > Batch//2:
return FindfrequentBarCode(DataList)
return -1
def BarcodeTask(Uart,Radar):
Data =
#IdentifyResult = IdentifyBarCode(10,5)
#if IdentifyResult == -1:
Data = Data +
Result = GetMinDistance(Radar)
Data = Data + Result
Scope = GetAngleScope(Radar)
Data = Data + Scope
Uart.SendData(Data)
def CalculateCenter(rect):
x, y, width, height = rect
center_x = x + width // 2
center_y = y + height // 2
return
def AverageCoordinate(List):
x_List, y_List = zip(*List)
x_avg = sum(x_List) / len(x_List)
y_avg = sum(y_List) / len(y_List)
return
#Batch：识别Batch帧的数据平均成一帧 TimeOut：尝试TimeOut次未达到收集不齐Batch帧率，收集多少算多少
def SearchPark(YoloV2Task, Batch, TimeOut):
ResultList = []
timeout = TimeOut
while(len(ResultList) < Batch and timeout > 0):
img = sensor.snapshot()
SearchResults = kpu.run_yolo2(YoloV2Task,img)
if SearchResults:
timeout = TimeOut
for Result in SearchResults:
img.draw_rectangle(Result.rect())
Coordinate = CalculateCenter(Result.rect())
ResultList.append(Coordinate)
#lcd.display(img)
timeout -= 1
if ResultList:
return ResultList
else:
return
def SearchParkTask(MyUart):
Data = #发送时带模式号
ParkingList = SearchPark(ParkingTask, 1, 10)
if ParkingList != 0xff:
ParkImgCoordinate = AverageCoordinate(ParkingList)
else:
ParkImgCoordinate = ParkingList
#ParkCoordinate = [(int)(ParkImgCoordinate-112)//1,(int)(112-ParkImgCoordinate)//1] # 计算以最中心点为原点的坐标
ParkCoordinate = [(int)(ParkImgCoordinate),(int)(ParkImgCoordinate)]
Data = Data + ParkCoordinate
MyUart.SendData(Data)
# Batch:识别多少次 TimeOut：识别不到重试次数
def JudgeColorBlobs(Batch, TimeOut):
Color = (37, 95, -28, -6, -39, 29)
ColorRoi = (54,54,112,112)
timeout = TimeOut
SuccessCount = 0
while(SuccessCount < Batch and timeout > 0):
Picture = sensor.snapshot()
ColorBlobs = Picture.find_blobs(,roi=ColorRoi, x_stride = 5,y_stride = 5,pixels_threshold=50,merge=True)
if ColorBlobs:
SuccessCount += 1
else:
timeout -= 1
if SuccessCount == Batch:
return 1
return 0
def JudgeColorTask(MyUart):
Data = #发送时带模式号
Result = JudgeColorBlobs(5,10)
Data = Data +
MyUart.SendData(Data)
OldRevDatas =
Count = 0
while True:
RevDatas = UartToStc32.ReadData()# 串口读到的模式标志为是持久性的 stc发送一次改变模式 直到下一次收到数据后
if RevDatas:
RevCmd = RevDatas
if RevCmd != 0x00 and RevCmd != 0x11 and RevCmd != 0x01 and RevCmd != 0x02 and RevCmd != 0x03 and RevCmd != 0x0F and RevCmd != 0xF0:
UartToStc32.RcvData = OldRevDatas
if RevCmd == 0x01:
BarcodeTask(UartToStc32,MyRadar)
elif RevCmd == 0x11:
if len(RevDatas)>=7:
SetAngleScope(RevDatas,MyRadar)
UartToStc32.RcvData =
elif RevCmd == 0x02:
MyRadar.PauseScan()
SearchParkTask(UartToStc32)
elif RevCmd == 0x03:
MyRadar.PauseScan()
JudgeColorTask(UartToStc32)
elif RevCmd == 0x0F:
MyData.TakePhoto()
UartToStc32.SendData(+ToBytes(MyData.datanum-MyData.nownum+1))
UartToStc32.RcvData = OldRevDatas
elif RevCmd == 0x0E:
MapImg = MyRadar.CreatMapping()
MyData.TakePhoto(img = MapImg)
UartToStc32.SendData(+ToBytes(MyData.datanum-MyData.nownum+1))
UartToStc32.RcvData = OldRevDatas
elif RevCmd == 0x00:
Count += 1
MyRadar.PauseScan()
if Count >= 50:
Count = 0
UartToStc32.SendData()# 停机
OldRevDatas = RevDatas[:]
gc.collect()
所使用K210原理图
规格尺寸图，方便打板
备赛通讯文档（MARKDOWN格式）
1. 数据帧基本格式（帧头+模式）
| 发送 | 0x4e,0x35（头）0x35 0x4e(尾) |
| ---- | ---------------------------- |
| 接收 | 0x4e,0x35 |
| 模式 | 0x00/0x01/0x02 |
**接收/发送帧头可修改**
```python
UartToStc32 = UD.UartDriver(6, 7,,)#rx tx 发送帧头 接收帧头
```
2. 停机坪任务任务 0x02(0x4e 0x35 0x02)
- 未找到停机坪：`0xff,0xff`
eg.`0x4e 0x35 0x02 0xff 0xff 0x35 0x4e`
- 找到停机坪：`x,y`
x:0~224 y:0~244 以左上角为原点向左向下分别为x，y正轴
eg.`0x4E 0x35 0x02 0x9D 0x6C 0x35 0x4e
表示坐标：157 108`
3. 颜色判断任务 0x03(0x4e 0x35 0x03)
- 识别到草地`0x01`
eg.`0x4E 0x35 0x03 0x01 0x35 0x4e `
- 没有识别到草地`0x00`
eg.`0x4E 0x35 0x03 0x00 0x35 0x4e`
4. 停机模式 0x00(默认为停机模式)(0x4e 0x35 0x00)
返回`0x4E 0x35 0x00 0x00 0x00 0x35 0x4e `
# 水平方向K210与stc串口通讯协议
1. 数据帧基本格式（帧头+模式）
| 发送 | 0x4e,0x35 |
| --- | --- |
| 接收 | 0x4e,0x35 |
| 模式 | 0x00/0x01 |
**接收/发送帧头可修改**
```python
UartToStc32 = UD.UartDriver(6, 7,,)#rx tx 发送帧头 接收帧头
```
2. 识别条形码任务0x01（0x4e 0x35 0x01）
- 识别到条形码返回条形码数据（0x01 data）
eg.`0x4E 0x35 0x01 0x01 0x03 0x35 0x4e`
识别到了条形码，数字为3
- 未识别到条形码返回最近的雷达信息（0x00 angle_H, angle_L, distance_H, distance_L，min_scope_angle_H,min_scope_angle_L,max_scope_angle_H,max_scope_angle_L）
eg.`0x4E 0x35 0x01 0x00 0x00 0xB3 0x00 0x16 0x00 0x00 0x01 0x0E 0x35 0x4e`
未识别到了条形码，最近障碍为263° 16cm处(此时从0到270°中的最小值)
3. 停机模式 0x00(默认为停机模式)(0x4e 0x35 0x00)
返回`0x4E 0x35 0x00 0x00 0x00 0x35 0x4e`
# 辅助功能
1. 拍照（0x4e 0x35 0x0F）
进行拍照并存入SD卡返回剩余拍照的数量eg.0x4e 0x35 0x0F 0x02 0x53 表示剩余595张图片
```python
MyData = TrainDataCollection(DataNum = 800, DataName = "Parking", FileName = "2021Game")//拍照数量/二级文件夹名称/一级文件夹名称
```
2. 拍照（0x4e 0x35 0x11min_scope_angle_H,min_scope_angle_L,max_scope_angle_H,max_scope_angle_L）
eg.`0x4E 0x35 0x11 0x00 0x00 0x01 0x0E`修改扫描范围为0到270°