关于：基于STM2的元器件特性测试仪过程

五连环画

元器件特性测试仪任务要求在人们的关注下51电子网终于成长为人们所需求的那样，为市场而生，为需求而来。

通过编程完成对5种以上元器件特性的测量


能够自动识别元器件


在OLED屏幕上通过图形化的界面显示各种元器件的符号及测量得到的信息


验环境


硬件：STM2G01G8U6核心板、硬禾学堂制作的底板


软件：STM2CMX、CL、STM2CP


现思路


首先进行一个大致的元器件类型的判断，再精确地测量元器件的各项属性，最后显示在OLED屏幕上


各部分的介绍元器件类型的判断


思路：首先给元器件放电，再轮番给这中的每2进行正反地通电，会得到六次结果。将每2的结果存储下来，进行排序后根据元器件特性进行判断元器件的类型，初步判断后存下引脚信息并进行参数的测量和屏幕显示，具体参考如图：





代码如下


QC（） {


QUICKJUDGE  = {0};  ，     


8_ BJTFEA［4］ = “011”; BJT


8_ DF［4］ = “001”; E-MOS


8_ RF［4］ = “002”;  


8_ CF［4］ = “000”;  


8_ ; 交换时用于缓存变量


（）;


（QTB2P（MP， HP， LP））


B = 1;


* 共六组测量，代码省略 *


（）;


（QTB2P（LP， HP， MP））


B = 1;


S［0］ = B + B + ‘0’;


S［1］ = B + B + ‘0’;


S［2］ = B + B + ‘0’;


S      


（S［0］ 》 S［1］）


= S［0］， S［0］ = S［1］， S［1］ = ;


（S［1］ 》 S［2］）


= S［1］， S［1］ = S［2］， S［2］ = ;


（S［0］ 》 S［2］）


= S［0］， S［0］ = S［2］， S［2］ = ;


S［］ = ‘’;


以下是逐个判断元器件特征是否和已知特征符合


（（S， CF） == 0） {


（IC_C（）） {


CF = COMPONENT_CAPACITANCE;


C_C（*CPCAPPARAM， *CPCAPPARAM）;


C_D（CP）;


}  {


E_R（）;


}


}   （（S， DF） == 0） {


TODO:A   


TODO:S        


CF = COMPONENT_DIODE;


（B + B） {


CPDP = ∓


CPDP = &LP;


}   （B + B） {


CPDP = ∓


CPDP = &HP;


}   （B + B） {


CPDP = &LP;


CPDP = &HP;


}


D_C（*CPDP， *CPDP）;


D_D（CP）;


}   （（S， RF） == 0） {


8_  = 0;


（B + B） {


= IIOR_C_B2P（MP， LP， HP）;


CPRESPARAM = ∓


CPRESPARAM = &LP;


CPINDPARAM = ∓


CPINDPARAM = &LP;


}   （B + B） {


= IIOR_C_B2P（HP， MP， LP）;


CPRESPARAM = ∓


CPRESPARAM = &HP;


CPINDPARAM = ∓


CPINDPARAM = &HP;


}   （B + B） {


= IIOR_C_B2P（LP， HP， MP）;


CPRESPARAM = &LP;


CPRESPARAM = &HP;


CPINDPARAM = &LP;


CPINDPARAM = &HP;


}


（ == 1） {


I_C（*CPINDPARAM， *CPINDPARAM）;


I_D（CP）;


}   （ == 2） {


R_C（*CPRESPARAM， *CPRESPARAM）;


R_D（CP）;


}  {


E_R（）;


}


}   （（S， BJTFEA） == 0） {


CF = COMPONENT_BJT;


（B + B） {


CPBJTPARAM = &LP;


CPBJTPARAMC = B;


}   （B + B） {


CPBJTPARAM = &HP;


CPBJTPARAMC = B;


}  {


CPBJTPARAM = ∓


CPBJTPARAMC = B;


}


BJT_C（）;


BJT_D（CP）;


}  {


E_R（）;


}


（）;


}


区分电阻和电感


可以给元器件充电后断电，如果检测到下端不为低电平，那就是电感。具体代码如下


**


* @         


* @ ，  P  H    P  


*         ADC   ：


* P------680---P


* VCC ADC1 GND


* ，  P  L    470   


*         ADC   ：


* P---470------680---P


* GND ADC2 GND


*       ADC1   ADC2   


*        ADC1       ADC2   GND


* @ P


* @ P


* @ P


* @  0      ，


*  1      


*  2     


*


8_ IIOR_C_B2P（MEASUREPORT P， MEASUREPORT P， MEASUREPORT P） {


16_ V1， V2;


MP_I（P， PORT_WITH_NONE， GPIO_PIN_SET）;


MP_I（P， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


V1 = GV（P）;


MP_I（P， PORT_WITH_470K， GPIO_PIN_RESET）;


V2 = GV（P）;


（（V1 《 ADCZERO） && （V2 《 ADCZERO）） {


0;


}   （V2 《 ADCZERO） {


CPINDPARAM = &P;


CPINDPARAM = &P;


2;


}  {


CPRESPARAM = &P;


CPRESPARAM = &P;


1;


}


}


电阻的测量


电阻的参数主要有电阻值，可通过分压法测量。


首先使用680电阻，电阻接在上端和下端各测试一次，并计算电阻值。如果电阻阻值过大，可以换用470电阻。代码如下


**


* @     


* @      ：


* FP------680---RP


* GND ADC VCC


*      ：


* FP---680------RP


* GND ADC VCC


*        470


*    680      


*     


* @ FP


* @ RP


*


TODO:    ADC        470


R_C（MEASUREPORT FP， MEASUREPORT RP） {


16_ ［4］;


［4］;


MEASUREPORT P = GUP（&FP， &RP）;


MP_I函数用于重新初始化一个上的个引脚至指定电阻和电平。


如使用680电阻，重新初始化其他两个引脚为浮空高阻，将连接着680电阻的引脚设为指定电平


MP_I（FP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（RP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


重新初始化ADC引脚。ADC引脚一般为提供电阻的那组引脚中未接电阻的引脚


HAL_GPIO_RI（RPPIN_WITH_NONEGPIO， RPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


GV函数用于测量指定引脚组中未接电阻那个引脚的电压


［0］ = GV（RP）;


［0］ = 680  （000  ［0］ - 1）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（RP， PORT_WITH_NONE， GPIO_PIN_SET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


［1］ = GV（FP）;


［1］ = 680  （［1］  000） - 680;


（（［0］ + ［1］） 》 1000） {


* 与上面的代码类似，仅将680R改为470K电阻，省略 *


}


（（［0］ + ［1］） 《= 10000） {


CPRESPARAMRV = （2_） （［0］ + ［1］）  2;


}   （（［0］ + ［1］） 《= 1000000） {


（， 4， （）， ）;


CPRESPARAMRV = （2_） （［1］ + ［2］）  2;


}  {


CPRESPARAMRV = （2_） （［2］ + ［］）  2;


}


}


电感的测量


电感的测量可以通过充电后测量放电时间来大致计算出电感值


**


* @      


* @            


*         ADC   ：


* FP---680------RP


* VCC ADC GND


*  ，   FP  


*         ADC   ：


* FP---680------RP


* GND ADC GND


*       ，   470     


* @         


* @ FP


* @ RP


*


I_C（MEASUREPORT FP， MEASUREPORT RP） {


16_ 1， 2;


16_ 1， 2;


16_  = 0;


MEASUREPORT P = GUP（&FP， &RP）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（RP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


HAL_D（100）;


1 = GV（FP）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = HAL_GT（）;


（ 《 0） {


2 = GV（FP）;


++;


（2 《 ADCZERO） {


;


}


}


2 = HAL_GT（）;


（ 《 100） {


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（RP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


HAL_D（100）;


1 = GV（FP）;


MP_I（FP， PORT_WITH_470K， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = HAL_GT（）;


（ 《 0） {


2 = GV（FP）;


++;


（2 《 ADCZERO） {


;


}


}


2 = HAL_GT（）;


CPINDPARAMIV = （2 - 1）  （470000 * （1  （） 2））  1000;


}  {


CPINDPARAMIV = （2 - 1）  （680 * （1  （） 2））  1000;


}


}


电容的测量


和电感类似，充电后放电，计算放电的时间。


需要注意的是这边似乎可能会对有极性的电容进行了反向充电，或者对低耐压的电容充过压，暂时没想到好的解决方法。


**


* @      


* @       680     


*         


*       ，  470    680


* @      


*      


* @ FP


* @ RP


*


TODO:    ，    HAL_GT


TODO:U         


C_C（MEASUREPORT FP， MEASUREPORT RP） {


16_ 1， 2;


16_ 1， 2;


16_  = 0;


MEASUREPORT P = GUP（&FP， &RP）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（RP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_D（100）;


1 = GV（FP）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = HAL_GT（）;


（ 《 0） {


2 = GV（FP）;


++;


（2 《 ADCZERO） {


2 = HAL_GT（）;


;


}


}


（ 《 100） {


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


HAL_D（100）;


1 = GV（FP）;


MP_I（FP， PORT_WITH_470K， GPIO_PIN_SET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = HAL_GT（）;


（ 《 0） {


2 = GV（FP）;


++;


（2 《 ADCZERO） {


2 = HAL_GT（）;


;


}


}


CPCAPPARAMCV = （2 - 1）  （470000 * （1  （） 2））  1000;


}  {


CPCAPPARAMCV = （2 - 1）  （680 * （1  （） 2））  1000;


}


}


二极管的测量


二极管的测量最为简单，直接测正反压降取小的即可


**


* @      


* @         ADC   ：


* P---680------680---P


* VCC ADC1 ADC2 GND


*          V


*   VCC  GND   


* @ FP


* @ RP


*


D_C（MEASUREPORT FP， MEASUREPORT RP） {


16_ 1， 2;


16_ V;


MEASUREPORT P = GUP（&FP， &RP）;


MP_I（FP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（RP， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


HAL_GPIO_RI（RPPIN_WITH_NONEGPIO， RPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（FP）;


2 = GV（RP）;


V = （1 - 2）;


（V 》 000） {


MP_I（FP， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（RP， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_RESET）;


HAL_GPIO_RI（FPPIN_WITH_NONEGPIO， FPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


HAL_GPIO_RI（RPPIN_WITH_NONEGPIO， RPPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（FP）;


2 = GV（RP）;


V = （1 - 2）;


MEASUREPORT * = CPDP;


CPDP = CPDP;


CPDP = ;


}


CPDPU = V;


}


极管的测量


可以知道得到0次导通的那两个脚为集电极和发极，因为基极与其他两个集都能导通一次。再检查基极向集电极或者发集是否导通，导通即为NPN，不导通即为PNP。分出极管类型后测量放大和倒置状态下的FE，也就是，大者即为放大状态和正确的放大倍数。


极管测量FE的方法：以NPN为例，给基极和集电极通过一个680R电阻接高电平，测量基极和集电极电压。如果基极电压不为接近0，表明极管处于放大状态，基极电流为（00-1）680，集电极电流为（00-2）680，FE即为（00 - 2）  （00 - 1）。如果基极电压接近0，表明极管基极电流过大，处于饱和状态。增大基极电阻再试一次。


* 晶体管极性 *


# P_CHANNEL 1 NPN


# N_CHANNEL 0 PNP


**


* @   


* @       CH579


* @ ‘  


*


BJT_C（） {


16_ 1， 2， ， 4;


16_ 1， 2;


（CPBJTPARAMC == P_CHANNEL） {


（CPBJTPARAM == &LP） {


（）;


1 = BJT_C_NPN（LP， MP， HP）;


（）;


2 = BJT_C_NPN（LP， HP， MP）;


（1 》 2） {


CPBJTPARAM = ∓


CPBJTPARAM = &HP;


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = &HP;


CPBJTPARAM = ∓


CPBJTPARAMFE = 2;


}


}   （CPBJTPARAM == &HP） {


（）;


1 = BJT_C_NPN（HP， LP， MP）;


（）;


2 = BJT_C_NPN（HP， MP， LP）;


（1 》 2） {


CPBJTPARAM = &LP;


CPBJTPARAM = ∓


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = ∓


CPBJTPARAM = &LP;


CPBJTPARAMFE = 2;


}


}  {


（）;


1 = BJT_C_NPN（MP， HP， LP）;


（）;


2 = BJT_C_NPN（MP， LP， HP）;


（1 》 2） {


CPBJTPARAM = &HP;


CPBJTPARAM = &LP;


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = &LP;


CPBJTPARAM = &HP;


CPBJTPARAMFE = 2;


}


}


}  {


（CPBJTPARAM == &LP） {


（）;


1 = BJT_C_PNP（LP， MP， HP）;


（）;


2 = BJT_C_PNP（LP， HP， MP）;


（1 》 2） {


CPBJTPARAM = ∓


CPBJTPARAM = &HP;


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = &HP;


CPBJTPARAM = ∓


CPBJTPARAMFE = 2;


}


}   （CPBJTPARAM == &HP） {


（）;


1 = BJT_C_PNP（HP， LP， MP）;


（）;


2 = BJT_C_PNP（HP， MP， LP）;


（1 》 2） {


CPBJTPARAM = &LP;


CPBJTPARAM = ∓


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = ∓


CPBJTPARAM = &LP;


CPBJTPARAMFE = 2;


}


}  {


（）;


1 = BJT_C_PNP（MP， HP， LP）;


（）;


2 = BJT_C_PNP（MP， LP， HP）;


（1 》 2） {


CPBJTPARAM = &HP;


CPBJTPARAM = &LP;


CPBJTPARAMFE = 1;


}  {


CPBJTPARAM = &LP;


CPBJTPARAM = &HP;


CPBJTPARAMFE = 2;


}


}


}


}


**


* @         


* @ P   


* @ P   


* @ P   


* @


*


16_ BJT_C_PNP（MEASUREPORT P， MEASUREPORT P， MEASUREPORT P） {


16_ 1， 2;


16_ ;


MP_I（P， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（P， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（P， PORT_WITH_NONE， GPIO_PIN_RESET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（P）;


（1 》 ADCZERO） {


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


2 = GV（P）;


= （00 - 2）  1;


}  {


MP_I（P， PORT_WITH_470K， GPIO_PIN_RESET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（P）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


2 = GV（P）;


= （470000 * （00 - 2）  1000）  （680 * 1  1000） - 1;


}


;


}


**


* @         


* @ P   


* @ P   


* @ P   


* @


*


16_ BJT_C_NPN（MEASUREPORT P， MEASUREPORT P， MEASUREPORT P） {


16_ 1， 2;


16_ ;


MP_I（P， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（P， PORT_WITH_680， GPIO_PIN_SET）;


MP_I（P， PORT_WITH_680， GPIO_PIN_SET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（P）;


（1 》 ADCZERO） {


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


2 = GV（P）;


= （00 - 2）  （00 - 1）;


}  {


MP_I（P， PORT_WITH_470K， GPIO_PIN_RESET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


1 = GV（P）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


2 = GV（P）;


= （470000 * （00 - 2）  1000）  （680 * （00 - 1）  1000）;


}


;


}


OLED的显示


元器件的各种信息通过一个全局共用体传递。OLED使用软件I2C进行驱动，具体的库和现省略，我直播时也有讲过，可以参考我整理的一些驱动。


由于OS上缺少一些取模软件，这里我暂时使用字符象形一下元件，比如电阻：


R_D（COMPONENTPARAMETER CP） {


［70］;


（， “R %-［］-%R=% O”，


CPTN（CPRESPARAM-》PIN_WITH_NONEGPIO_P），


CPTN（CPRESPARAM-》PIN_WITH_NONEGPIO_P），


CPRESPARAMRV）;


OLED_C（）;


OLED_SS（0， 0， （8_ *） ， 12）;


}


一些中间层的函数


QTB2P


测试两脚之间有没有元件


**


* @        2


* @         ADC   ：


* P------680---P


* VCC ADC GND


*  P    680        


*    - P       ADC


*           


* @ P   ，   


* @ P   ，        680


* @       P  P


*


8_ QTB2P（MEASUREPORT P， MEASUREPORT P， MEASUREPORT P） {


MP_I（P， PORT_WITH_NONE， GPIO_PIN_SET）;


MP_I（P， PORT_WITH_680， GPIO_PIN_RESET）;


MP_I（P， PORT_FLOATING， GPIO_PIN_SET）;


HAL_GPIO_RI（PPIN_WITH_NONEGPIO， PPIN_WITH_NONEGPIO_P， GPIO_MODE_ANALOG）;


HAL_D（50）;


16_ ADCV = GV（P）;


ADCV 》 ADCZERO;


}


GV


测量指定脚位电压


**


* @      -   


*   


* @ PG


* @     5   （）


*


16_ GV（MEASUREPORT PG） {


**


* ［0］-》PA5


* ［1］-》PA6


* ［2］-》PA7


* ［］-》V_


*


16_ ［4］ = {0};


16_  = 0，  = 0;


16_  = *（__IO 16_ *） 01FFF75AA;


（8_  = 0;  《 5; ++） {


（8_  = 0;  《 4; ++） {


［］ += HAL_ADC_R（&1）;


}


}


［］ = 5;


HAL_ADC_S（&1）;


= （16_） （ * 0000  ［］）;


（PGPIN_WITH_NONEGPIO_P） {


GPIO_PIN_5：


= ［0］ * 00  40960  5;


;


GPIO_PIN_6：


= ［1］ * 00  40960  5;


;


GPIO_PIN_7：


= ［2］ * 00  40960  5;


;


：


;


}


;


}





给元器件放电


**


* @   


* @ N


* @ N


*


（） {


MP_I（HP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（MP， PORT_WITH_NONE， GPIO_PIN_RESET）;


MP_I（LP， PORT_WITH_NONE， GPIO_PIN_RESET）;


HAL_D（50）;


}


MP_I


重新初始化一个上的个引脚至指定电阻和电平


**


* @ I   


* @     


* @      


* @ PS     


* @ N


*


MP_I（MEASUREPORT ， PORTMODE ， GPIO_PS PS） {


（） {


PORT_WITH_NONE：


HAL_GPIO_RI（PIN_WITH_NONEGPIO， PIN_WITH_NONEGPIO_P， GPIO_MODE_OUTPUT_PP）;


HAL_GPIO_RI（PIN_WITH_680GPIO， PIN_WITH_680GPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_470KGPIO， PIN_WITH_470KGPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_WP（PIN_WITH_NONEGPIO， PIN_WITH_NONEGPIO_P， PS）;


;


PORT_WITH_680：


HAL_GPIO_RI（PIN_WITH_NONEGPIO， PIN_WITH_NONEGPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_680GPIO， PIN_WITH_680GPIO_P， GPIO_MODE_OUTPUT_PP）;


HAL_GPIO_RI（PIN_WITH_470KGPIO， PIN_WITH_470KGPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_WP（PIN_WITH_680GPIO， PIN_WITH_680GPIO_P， PS）;


;


PORT_WITH_470K：


HAL_GPIO_RI（PIN_WITH_NONEGPIO， PIN_WITH_NONEGPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_680GPIO， PIN_WITH_680GPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_470KGPIO， PIN_WITH_470KGPIO_P， GPIO_MODE_OUTPUT_PP）;


HAL_GPIO_WP（PIN_WITH_470KGPIO， PIN_WITH_470KGPIO_P， PS）;


;


PORT_FLOATING：


HAL_GPIO_RI（PIN_WITH_NONEGPIO， PIN_WITH_NONEGPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_680GPIO， PIN_WITH_680GPIO_P， GPIO_MODE_INPUT）;


HAL_GPIO_RI（PIN_WITH_470KGPIO， PIN_WITH_470KGPIO_P， GPIO_MODE_INPUT）;


：


;


}


HAL_ADC_R


进行一次ADC的测量


16_ HAL_ADC_R（） {


HAL_ADC_S（&1）;


HAL_ADC_PFC（&1，0）;


HAL_ADC_GV（&1）;


}


HAL_GPIO_RI


重新初始化GPIO


HAL_GPIO_RI（GPIO_TD *GPIO， 16_ GPIO_P， 2_ M）{


HAL_GPIO_DI（GPIO，GPIO_P）;


GPIO_ITD GPIO_IS = {0};


GPIO_ISP = GPIO_P;


GPIO_ISM = M;


GPIO_ISP = GPIO_NOPULL;


HAL_GPIO_I（GPIO， &GPIO_IS）;


}


CPTN


将GPIO_PIN_X转换成引脚12


16_ CPTN（16_ GPIO_P） {


（GPIO_P == GPIO_PIN_5） {


1;


}   （GPIO_P == GPIO_PIN_6） {


2;


}   （GPIO_P == GPIO_PIN_7） {


;


}


0;


}


遇到的问题


STM2的ADC采得电压不是很准确，使用校准后漂移更为离谱


电阻测量时使用470电阻时测得电阻偏差较大，猜测可能为ADC内阻导致


电容的测量暂未想到较好的方案


FLASH占用较高（约90%），以后可以使用LL库代替HAL库来节省FLASH开支


由于忙于第四期FPGA活动等事，仅针对部分元件为了直播从沁恒于浩然老师的代码中移植整理了部分代码，同时电感的代码仅移植也未经测试