1、问题起源：
最近做一个人脸识别加一个人脸追踪的需求。做人脸追踪的时候，烧录了官方的示例，IDE总是连接上运行之后会自动断开，舵机也不会动，LCD也只会亮背光。针对现象在Q群上询问了大家，大家都说是供电的问题，然后我用的是一个12V电池转5V开关电源供电给舵机，K210用USB供电，开关电源模块与K210共地，舵机信号线连接在K210上。问题还是没解决，这个供电方案，我觉得没什么问题。
然后问题来了，这是什么问题？我用串口输出官方云台人脸追踪的示例，输出一行黄色的代码:
SYSCALL:sys_exit called by core o with 0×539
不知道什么问题的我，去问了q群的大佬–大老鼠，他说：遇事不决，更新固件

2、问题发现：
so ,我开始更新固件，我原本的固件版本
maixpy_v0.6_1_gfa51290_minimum_with_ide_support.bin
然后我就更新固件升级到
maixpy_v0.6.2_28_g4ae4fa3f7_minimum_with_ide_support .bin
用着这个固件版本，我运行官方云台人脸追踪示例，按照我上述的供电方案，IDE 不会自动断开开发板了，屏幕也不会只会亮背光了，它开始也会显示东西了，但是奇怪的是，LCD显示上像多了一层白雾，白蒙蒙一片。

3、问题探究：
我用着这个固件版本重新运行了官方示例，人脸识别的示例，之前用着固件版本 maixpy_v0.6_1_gfa51290_minimum_with_ide_support.bin显示的好好的，现在也多了一层白蒙蒙的一片，而且这人脸识别的功能也不能用了–识别不到了。

然后我连续换了好几个固件，
从maixpy_v0.6.2_22_g353f843a8_minimum_with_ide_support.bin，到maixpy_v0.6.2_26_g0bd0bea55_minimum_with_ide_support.bin，到
maixpy_v0.6.2_27_g4d8d4fbf0_minimum_with_ide_support.bin 再到
maixpy_v0.6.2_28_g4ae4fa3f7_minimum_with_ide_support .bin
问题依然存在
我把固件换回
maixpy_v0.6_1_gfa51290_minimum_with_ide_support.bin ，这人脸识别功能也就正常了，也不会白蒙蒙的一片了。

以下是：正常人脸LCD显示以及白蒙蒙一片LCD显示的对比：

4、共同探讨
1、云台人脸追踪，供电方案没有问题的情况下，为何IDE会自动断开开发板吗？是固件的问题吗？
云台人脸追踪，这份官方示例可以写的详细一些，不知道怎么用emm。
2、LCD白蒙蒙一片的原因。

附录：
固件升级出现问题的代码：
人脸识别：
`
import sensor
import image
import lcd
import KPU as kpu
import time
from Maix import FPIOA, GPIO
import gc
from fpioa_manager import fm
from board import board_info
import utime

task_fd = kpu.load(0×200000)
task_ld = kpu.load(0×300000)
task_fe = kpu.load(0×400000)

clock = time.clock()

fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS0)
key_gpio = GPIO(GPIO.GPIOHS0, GPIO.IN)
start_processing = False

BOUNCE_PROTECTION = 50

def set_key_state(*_):
global start_processing
start_processing = True
utime.sleep_ms(BOUNCE_PROTECTION)

key_gpio.irq(set_key_state, GPIO.IRQ_RISING, GPIO.WAKEUP_NOT_SUPPORT)

lcd.init()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_hmirror(1)
sensor.set_vflip(1)
sensor.run(1)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437,
6.92275, 6.718375, 9.01025) # anchor for face detect
dst_point = [(44, 59), (84, 59), (64, 82), (47, 105),
(81, 105)] # standard face key point position
a = kpu.init_yolo2(task_fd, 0.5, 0.3, 5, anchor)
img_lcd = image.Image()
img_face = image.Image(size=(128, 128))
a = img_face.pix_to_ai()
record_ftr = []
record_ftrs = []
names = [‘Mr.1’, ‘Mr.2’, ‘Mr.3’, ‘Mr.4’, ‘Mr.5’,
‘Mr.6’, ‘Mr.7’, ‘Mr.8’, ‘Mr.9’, ‘Mr.10’]

ACCURACY = 85

while (1):
img = sensor.snapshot()
clock.tick()
code = kpu.run_yolo2(task_fd, img)
if code:
for i in code:

Cut face and resize to 128×128

a = img.draw_rectangle(i.rect())
face_cut = img.cut(i.x(), i.y(), i.w(), i.h())
face_cut_128 = face_cut.resize(128, 128)
a = face_cut_128.pix_to_ai()

a = img.draw_image(face_cut_128, (0,0))

Landmark for face 5 points

fmap = kpu.forward(task_ld, face_cut_128)
plist = fmap[:]
le = (i.x() + int(plist[0] * i.w() - 10), i.y() + int(plist[1] * i.h()))
re = (i.x() + int(plist[2] * i.w()), i.y() + int(plist[3] * i.h()))
nose = (i.x() + int(plist[4] * i.w()), i.y() + int(plist[5] * i.h()))
lm = (i.x() + int(plist[6] * i.w()), i.y() + int(plist[7] * i.h()))
rm = (i.x() + int(plist[8] * i.w()), i.y() + int(plist[9] * i.h()))
a = img.draw_circle(le[0], le[1], 4)
a = img.draw_circle(re[0], re[1], 4)
a = img.draw_circle(nose[0], nose[1], 4)
a = img.draw_circle(lm[0], lm[1], 4)
a = img.draw_circle(rm[0], rm[1], 4)

align face to standard position

src_point = [le, re, nose, lm, rm]
T = image.get_affine_transform(src_point, dst_point)
a = image.warp_affine_ai(img, img_face, T)
a = img_face.ai_to_pix()

a = img.draw_image(img_face, (128,0))

del (face_cut_128)

calculate face feature vector

fmap = kpu.forward(task_fe, img_face)
feature = kpu.face_encode(fmap[:])
reg_flag = False
scores = []
for j in range(len(record_ftrs)):
score = kpu.face_compare(record_ftrs[j], feature)
scores.append(score)
max_score = 0
index = 0
for k in range(len(scores)):
if max_score < scores[k]:
max_score = scores[k]
index = k
if max_score > ACCURACY:
a = img.draw_string(i.x(), i.y(), (“%s :%2.1f” % (
names[index], max_score)), color=(0, 255, 0), scale=2)
else:
a = img.draw_string(i.x(), i.y(), (“X :%2.1f” % (
max_score)), color=(255, 0, 0), scale=2)
if start_processing:
record_ftr = feature
record_ftrs.append(record_ftr)
start_processing = False

        break
fps = clock.fps()
print("%2.1f fps" % fps)
a = lcd.display(img)
gc.collect()
# kpu.memtest()

a = kpu.deinit(task_fe)

a = kpu.deinit(task_ld)

a = kpu.deinit(task_fd)

云台舵机人脸追踪：
`
'''
Gimbal demo with classical PID support,
@usage Change parameters at the start of main according to your hardware
like camera and lcd direction, PID parameters etc.
@update https://github.com/sipeed/MaixPy_scripts
@author neucrack@sipeed
@license MIT
'''

import time, sys
from machine import Timer,PWM

from math import pi
from machine import UART

class Servo:
def init(self, pwm, dir=50, duty_min=2.5, duty_max=12.5):
self.value = dir
self.pwm = pwm
self.duty_min = duty_min
self.duty_max = duty_max
self.duty_range = duty_max -duty_min
self.enable(True)
self.pwm.duty(self.value/100*self.duty_range+self.duty_min)

def enable(self, en):
    if en:
        self.pwm.enable()
    else:
        self.pwm.disable()

def dir(self, percentage):
    if percentage > 100:
        percentage = 100
    elif percentage < 0:
        percentage = 0
    self.pwm.duty(percentage/100*self.duty_range+self.duty_min)

def drive(self, inc):
    self.value += inc
    if self.value > 100:
        self.value = 100
    elif self.value < 0:
        self.value = 0
    self.pwm.duty(self.value/100*self.duty_range+self.duty_min)

class PID:
_kp = _ki = _kd = _integrator = _imax = 0
_last_error = _last_t = 0
RC = 1/(2 * pi * 20)
def init(self, p=0, i=0, d=0, imax=0):
self.kp = float(p)
self.ki = float(i)
self.kd = float(d)
self.imax = abs(imax)
self.last_derivative = None

def get_pid(self, error, scaler):
    tnow = time.ticks_ms()
    dt = tnow - self._last_t
    output = 0
    if self._last_t == 0 or dt > 1000:
        dt = 0
        self.reset_I()
    self._last_t = tnow
    delta_time = float(dt) / float(1000)
    output += error * self._kp
    if abs(self._kd) > 0 and dt > 0:
        if self._last_derivative == None:
            derivative = 0
            self._last_derivative = 0
        else:
            derivative = (error - self._last_error) / delta_time
        derivative = self._last_derivative + \
                                 ((delta_time / (self._RC + delta_time)) * \
                                    (derivative - self._last_derivative))
        self._last_error = error
        self._last_derivative = derivative
        output += self._kd * derivative
    output *= scaler
    if abs(self._ki) > 0 and dt > 0:
        self._integrator += (error * self._ki) * scaler * delta_time
        if self._integrator < -self._imax: self._integrator = -self._imax
        elif self._integrator > self._imax: self._integrator = self._imax
        output += self._integrator
    return output

def reset_I(self):
    self._integrator = 0
    self._last_derivative = None

class Gimbal:
def init(self, pitch, pid_pitch, roll=None, pid_roll=None, yaw=None, pid_yaw=None):
self.pitch = pitch
self.roll = roll
self.yaw = yaw
self.pid_pitch = pid_pitch
self.pid_roll = pid_roll
self.pid_yaw = pid_yaw

def set_out(self, pitch, roll, yaw=None):
    pass

def run(self, pitch_err, roll_err=50, yaw_err=50, pitch_reverse=False, roll_reverse=False, yaw_reverse=False):
    out = self._pid_pitch.get_pid(pitch_err, 1)
    # print("err: {}, out: {}".format(pitch_err, out))
    if pitch_reverse:
        out = - out
    self._pitch.drive(out)
    if self._roll:
        out = self._pid_roll.get_pid(roll_err, 1)
        if roll_reverse:
            out = - out
        self._roll.drive(out)
    if self._yaw:
        out = self._pid_yaw.get_pid(yaw_err, 1)
        if yaw_reverse:
            out = - out
        self._yaw.drive(out)

if name == “main”:
'''
servo:
freq: 50 (Hz)
T: 1/50 = 0.02s = 20ms
duty: [0.5ms, 2.5ms] -> [0.025, 0.125] -> [2.5%, 12.5%]
pin:
IO24 <–> pitch
IO25 <–> roll
'''
init_pitch = 80 # init position, value: [0, 100], means minimum angle to maxmum angle of servo
init_roll = 50 # 50 means middle
sensor_hmirror = False
sensor_vflip = False
lcd_rotation = 2
lcd_mirror = True
pitch_pid = [0.23, 0, 0.015, 0] # P I D I_max
roll_pid = [0.23, 0, 0.015, 0] # P I D I_max
target_err_range = 10 # target error output range, default [0, 10]
target_ignore_limit = 0.02 # when target error < target_err_range*target_ignore_limit , set target error to 0
pitch_reverse = False # reverse out value direction
roll_reverse = True # ..

import sensor,image,lcd
import KPU as kpu
class Target():
    def __init__(self, out_range=10, ignore_limit=0.02, hmirror=False, vflip=False, lcd_rotation=2, lcd_mirror=True):
        self.pitch = 0
        self.roll = 0
        self.out_range = out_range
        self.ignore = ignore_limit
        self.task_fd = kpu.load(0x300000) # face model addr in flash
        anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
        kpu.init_yolo2(self.task_fd, 0.5, 0.3, 5, anchor)
        lcd.init()
        lcd.rotation(lcd_rotation)
        lcd.mirror(lcd_mirror)
        sensor.reset()
        sensor.set_pixformat(sensor.RGB565)
        sensor.set_framesize(sensor.QVGA)
        sensor.set_windowing((128,128))
        if hmirror:

            sensor.set_hmirror(1)
        if vflip:
            sensor.set_vflip(1)

    def get_target_err(self):
        img = sensor.snapshot()
        code = kpu.run_yolo2(self.task_fd, img)
        if code:
            max_area = 0
            max_i = 0
            for i, j in enumerate(code):
                a = j.w()*j.h()
                if a > max_area:
                    max_i = i
                    max_area = a

            img = img.draw_rectangle(code[max_i].rect())
            self.pitch = (code[max_i].y() + code[max_i].h() / 2)/240*self.out_range*2 - self.out_range
            self.roll = (code[max_i].x() + code[max_i].w() / 2)/320*self.out_range*2 - self.out_range
            # limit
            if abs(self.pitch) < self.out_range*self.ignore:
                self.pitch = 0
            if abs(self.roll) < self.out_range*self.ignore:
                self.roll = 0
            img = img.draw_cross(160, 120)
            lcd.display(img)
            return (self.pitch, self.roll)
        else:
            img = img.draw_cross(160, 120)
            lcd.display(img)
            return (0, 0)

target = Target(target_err_range, target_ignore_limit, sensor_hmirror, sensor_vflip, lcd_rotation, lcd_mirror)

tim0 = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)
tim1 = Timer(Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM)
pitch_pwm = PWM(tim0, freq=50, duty=0, pin=24)
roll_pwm  = PWM(tim1, freq=50, duty=0, pin=25)
pitch = Servo(pitch_pwm, dir=init_pitch)
roll = Servo(roll_pwm, dir=init_roll)
pid_pitch = PID(p=pitch_pid[0], i=pitch_pid[1], d=pitch_pid[2], imax=pitch_pid[3])
pid_roll = PID(p=roll_pid[0], i=roll_pid[1], d=roll_pid[2], imax=roll_pid[3])
gimbal = Gimbal(pitch, pid_pitch, roll, pid_roll)

target_pitch = init_pitch
target_roll = init_roll
t = time.ticks_ms()
_dir = 0
t0 = time.ticks_ms()
stdin = UART.repl_uart()
while 1:
    # get target error
    err_pitch, err_roll = target.get_target_err()
    # interval limit to > 10ms
    if time.ticks_ms() - t0 < 10:
        continue
    t0 = time.ticks_ms()
    # run
    gimbal.run(err_pitch, err_roll, pitch_reverse = pitch_reverse, roll_reverse=roll_reverse)