嵌入式期末复习题（三）

1嵌入式系统的定义

①嵌入式系统是用于控制、监视或辅助操作机器和设备的装置

②嵌入式系统是以应用为中心，以计算机技术为基础，软硬件可裁剪，适应应用系统对功能、可靠性、成本、体积和功耗等严格要求的专用计算机系统

2嵌入式系统的特点

①嵌入式系统通常是面向特定应用的

②嵌入式系统是将先进的计算机技术、半导体技术和电子技术与各个行业的具体应用相结合后的产物

③嵌入式系统的硬件和软件都必须高效率地设计、量体裁衣、去除冗余

④嵌入式系统和具体应用有机地结合在一起

⑤嵌入式系统中的软件一般都固化在存储器芯片或单片机本身中

⑥嵌入式系统本身不具备自主开发能力

3嵌入式系统的组成

①软件结构：应用软件、操作系统、软件程序

②硬件结构：存储器、处理器、输入、输出（输入、输出：外围电路）

4嵌入式系统的开发方法：系统需求分析（规格说明书）、系统体系结构设计、系统硬件功能设计（机械/结构设计、系统软件功能设计）、系统集成（联调)、系统综合测试、产品

5嵌入式处理器的分类①微控制器MCU（MCS-51、STM32）②数字信号处理器DSP③微处理器MPU④嵌入式片上可编程系统SOPC

6 ①stm32F100超值型24MHz②101基本36M③102USB基本48④103增强72⑤ 105/107互联72⑥L系列超低功耗72

7 ROM和RAM（半导体存储器）：ROM停止供电可保持数据（EEPROM电擦除功能，价格高，写入时间长、慢）；RAM掉电丢失数据 （SRAM读/写速度最快，昂贵）。Flash结合所有优点。

8处理器最小系统组成：电源电路、时钟晶振电路、复位电路、启动电路、程序下载电路

9电源供电方案①VSSA，VDDA=2.0~3.6V：为ADC、复位模块、RC振荡器和PLL模拟部分供电（使用ADC时，VDD>2.4V）②VDD=2.0~3.6V，VDD管脚为I/O管脚和内部解调器供电③VBAT=1.8~3.6V，关闭VDD时（通过内部电源切换器）为RTC、外部32KHz振荡器和后备存储器供电

1DMA指一种高速的数据传输操作，允许在外部设备和存储器之间利用系统总线直接读/写数据，即不通过微处理器，也不需要微处理器干预。

特点：“分散—收集”。

缺点：允许外设直接访问内存形成对总线的独占；如果传输数据量大，造成中断延时过长。DMA传送方式的优先级高于程序中断。

2 DMA3要素：①传输源②传输目标③触发信号。

１ADC功能：

①规则转换和注入转换均有外部触发选项

②在规则通道转换期间，可以产生DMA请求

③自校准。在每次ADC开始转换前进行一次自校准

④通道采样间隔时间可编程

⑤带内嵌数据一致性的数据对齐

⑥可设置成单次、连续、扫描、间断模式

⑦双ADC模式，带2个ADC设备ADC1和ADC2，有8种转换方式

⑧)转换结束、注入转换结束和发生模拟看门狗事件时产生中断

2ADC结构：模拟信号通道、A/D转换器、模拟看门狗部分、中断电路

1启动模式①主闪存存储器（BOOT1=X BOOT0=0）②系统存储器（BOOT1=0 BOOT0=1）③内置SRAM（BOOT1=1 BOOT0=1）

2①嵌入式C程序就是针对嵌入式产品开发的C语言程序

②在ANSI标准C语言程序设计的基础上，加上特定的处理器头，在特定的编译环境下，生成可执行文件

3嵌入式C程序模块化设计思想：主程序、A/D转换、数字滤波、参数比较、故障标志生成、手动（气缸上升、气缸下降、变频参数输出、阻机转动）、自动、故障显示

4 Gene8310嵌入式系统：开关电源、液晶显示 摄像头、扬声器、麦克风 人脸跟踪、语音识别、无线通讯系统 动作、行走控制

5 STM32命名：①STM32：基于ARM的32位微控制器②F：通用类型③103：增强型④T：36脚、C48 R64 V100 Z144⑤4:16KBFlash 6:32 8:64 B128 C256 D384 E512⑥封装T=LQFP

6 GPIO_DeInit  将外设GPIOX寄存器设为缺省值

GPIO_AFIODeInit  将复用功能（重映射事件控制和EXTI设置）重设为缺省值

GPIO_Init  根据GPIO_InitStruct中指定的参数初始化外设GPIOX寄存器

GPIO_StructInit  把GPIO_InitStruct中的每一个参数按缺省值填入

GPIO_ReadInputDataBit  读取指定端口管脚的输入

GPIO_ReadInputData  读取指定的GPIO端口输入 

GPIO_ReadOutputDataBit  读取指定端口管脚的输出

GPIO_SetBits  设置指定的数据端口位

GPIO_ResetBits  清除指定的数据端口位

GPIO_WriteBit  设置或清除指定的数据端口位

GPIO_Write  向指定GPIO数据端口写入数据

GPIO_PinLockConfig  锁定GPIO管脚设置寄存器

GPIO_EventOutputConfig  选择GPIO管脚用作事件输出

GPIO_EventOutputCmd  使能或失能事件输出

GPIO_PinRemapConfig  改变指定管脚的映射

GPIO_EXTILineConfig  选择GPIO管脚用作外部中断线路

7  GPIO_Speed  描述

GPIO_Mode_AIN          模拟输入

GPIO_Mode_IN_FLOATING  浮空输入

GPIO_Mode_IPD          下拉输入

GPIO_Mode_IPU          上拉输入

GPIO_Mode_OUT_OD       开漏输出

GPIO_Mode_OUT_PP       推挽输出

GPIO_Mode_AF_OD        复用开漏输出

GPIO_Mode_AF_PP        复用推挽输出

1 stm32嵌入式处理器中断

①中断通道：处理中断的信号通路。每个中断通道对应唯一的中断向量和唯一的中断服务程序。

②51单片机中断通道有5个：外部中断0、定时器中断0、外部中断1、定时器中断1、串口中断

③stm32F103嵌入式处理器有60个中断通道；stm32F107嵌入式处理器有68个中断通道。

2 中断优先级与嵌套：

①STM32中有两个优先级的概念:抢占式优先级和响应优先级，响应优先级称作“亚优先级”或“副优先级”，每个中断源都需要被指定这两种优先级。

具有高抢占式优先级的中断可以在具有低抢占式优先级的中断处理过程中被响应，即中断的嵌套。

当两个中断源的抢占式优先级相同时，这两个中断将没有嵌套关系，当一个中断到来后，如果正在处理另一个中断，这个后到来的中断就要等到前一个中断处理完之后才能被处理。

②假设STM2配置了三个中断向量，其属性如下。那么STM22在响应中断时，中断A能否打断中断C的中断服务函数?中断B能否打断中断C?如果中断B和中断C中断同时到达，响应哪个中断?。

中断向量  抢占优先级  响应优先级

A          0            0

B          1            0

C          1            1

若内核正在执行C的中断服务函数，则它能被抢占优先级更高的中断A打断，由于B和C的抢占优先级相同，所以C不能被B打断。↓

但如果B和C中断是同时到达的，内核就会首先响应响应优先级别更高的B中断。

3 void USART_Transmit(u8 data)
while(USART_GetFlagStatus(USARTl,USART_FLAG_TXE)==RESET);USART_SendData(USART1,data);

}
void put_s(u8 *s)
while(*s)

{
USART_Transmit(*s);

s++;

}

4 STM32 AD转换及硬件设计

STM32芯片内部集成的12位ADC:

是一种逐次逼近型模拟数字转换器。

具有18个通道

可测量16个外部和2个内部信号源。

1μs转换时间

ADC供电要求: 2.4V到3.6V

ADC输入 范围: VREF < VIN < VREF+

5 STM32 USART①串口1:PA9、PA10②串口2:PA1、PA2③串口3:PB10、PB11

6 AD转换结果计算

ADC=（Vin*4096）/Vref【Vin：被选中引脚的输入电压 Vref：参考电压】

7 CM3（一个字32位）处理器内核是嵌入式微控制器的中央处理单元。CM3内核基本结构：CM3内核、调试系统、外设、存储器、时钟和复位、I/O。CM3用3级流水线：取指、解码、执行

8 调用固件库函数

①函数GPIO_SetBits   函数GPIO_ResetBits

//点亮LED灯

GPIO_ResetBits（GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7）;

//熄灭LED灯

GPIO_SetBits（GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7）;

②函数GPIO_WriteBit

//点亮LED灯

GPIO_WriteBit（GPIOA,GPIO_Pin_4，Bit_RESET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_5，Bit_RESET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_6，Bit_RESET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_7，Bit_RESET）;

//熄灭LED灯

GPIO_WriteBit（GPIOA,GPIO_Pin_7，Bit_SET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_7，Bit_SET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_7，Bit_SET）;

GPIO_WriteBit（GPIOA,GPIO_Pin_7，Bit_SET）;

9 void GPIO_Init_B(void)

{

  GPIO_InitTypeDef GPIO_InitStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);

  GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1|GPIO_Pin_0|GPIO_Pin_5|GPIO_Pin_6;

  GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;

  GPIO_Init(GPIOB,&GPIO_InitStructure);

1while(1)

{

ReadValue1=GPIO_InputDataBit(GPIOB,GPIO_Pin_0);

ReadValue2=GPIO_InputDataBit(GPIOB,GPIO_Pin_1);

ReadValue3=GPIO_InputDataBit(GPIOB,GPIO_Pin_5);

ReadValue4=GPIO_InputDataBit(GPIOB,GPIO_Pin_6);

if(ReadValue1==0)

{

GPIO_WriteBit(GPIOA,GPIO_Pin_4,Bit_SET);

}

if(ReadValue2==0)

{

GPIO_WriteBit(GPIOA,GPIO_Pin_5,Bit_SET);

}

if(ReadValue3==0)

{

GPIO_WriteBit(GPIOA,GPIO_Pin_6,Bit_SET);

}

if(ReadValue4==0)

{

GPIO_WriteBit(GPIOA,GPIO_Pin_7,Bit_SET);

}

一按键流水灯

#include "stm32f10x.h"

unsigned char ReadValue1;

unsigned char ReadValue2;

void Gpio_Init_Port(void)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

    GPIO_Init(GPIOD, &GPIO_InitStructure);

}

void Gpio_Init_Key(void)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);

   

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

}

  //yanchi

void Delay_MS(u32 time)

{

  unsigned char i;

  unsigned int j;

  for(j=0;j<time;j++)

  {

    for(i=0;i<120;i++)

    {

      ;;

    }

   }

}

int main(void)

{

   Gpio_Init_Port();

     Gpio_Init_Key();

 while(1)

 {

    GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_SET);

    GPIO_WriteBit(GPIOD, GPIO_Pin_2, Bit_SET);

   

    ReadValue1= GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_5);

    ReadValue2= GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15); 

     

     if(ReadValue1==0)

     {

        GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_RESET);

     }

      if(ReadValue2==0)

     {

        GPIO_WriteBit(GPIOD, GPIO_Pin_2, Bit_RESET);

     }

  }

 }

二按键中断

#include "stm32f10x.h"

void Gpio_Init_Port(void)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

}

 void EXTI_Configuration(void)

{

    EXTI_InitTypeDef EXTI_InitStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

   

    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);

    EXTI_InitStructure.EXTI_Line=EXTI_Line0;

    EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;

    EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising;

    EXTI_Init(&EXTI_InitStructure);

   

}

void NVIC_Config(void)

{

    NVIC_InitTypeDef NVIC_InitStructure;

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

    NVIC_InitStructure.NVIC_IRQChannel=EXTI0_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x00;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;

    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;

    NVIC_Init(&NVIC_InitStructure);

}

 void EXTI_IRQHandler(void)

 {

    if( EXTI_GetITStatus(EXTI_Line0)!=RESET)

    {

GPIO_WriteBit(GPIOA,GPIO_Pin_8,(BitAction)((1-GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_8))));

    }

   EXTI_ClearFlag(EXTI_Line0);

 }

 int main(void)

 {

     Gpio_Init_Port();

     EXTI_Configuration();

       NVIC_Config();

     GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_RESET);

     while(1);

 }

三串口发送字符

#include "stm32f10x.h"

  u16 RxData;

//时钟配置

void Gpio_Init_A(void)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    }  

void Usart_init(void)

{

   USART_InitTypeDef USART_InitStructure;

   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);

   USART_InitStructure.USART_BaudRate=115200;

   USART_InitStructure.USART_WordLength = USART_WordLength_8b;

   USART_InitStructure.USART_StopBits = USART_StopBits_1;

   USART_InitStructure.USART_Parity = USART_Parity_No;

   USART_InitStructure.USART_HardwareFlowControl =USART_HardwareFlowControl_None;

   USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;

   USART_Init(USART1, &USART_InitStructure);

   USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);

   USART_Cmd(USART1, ENABLE);

   USART_ClearFlag(USART1,USART_FLAG_TC);

}

void Nvic_Init(void)

{

  NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

}

void USART1_IRQHandler(void)

{

 if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)

 {

 RxData=USART_ReceiveData(USART1);

 USART_SendData(USART1,RxData);

 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

 }

}

  void USART_Transmit(u8 data)

{

 while( USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

 USART_SendData(USART1,data);

}

 void put_s(u8*s)

{

 while(*s)

 {

   USART_Transmit(*s);

   s++;

 }

}

  //延迟函数

void Delay_MS(u32 time)

{

  unsigned char i;

  unsigned int j;

  for(j=0;j<time;j++)

  {

    for(i=0;i<120;i++)

    {

      ;;

    }

   }

}

int main(void)

{

  Gpio_Init_A();

  Usart_init();

  Nvic_Init();

 

  while(1)

  {

   put_s("桂林航天工业学院");

   put_s("\n");

   Delay_MS(10000);

   Delay_MS(10000);

   Delay_MS(10000);

  }

 }

四单路AD

#include "stm32f10x.h"

//变量定义

     u16 RxData;

u16 RxData;

u16 ADC_value[10];

u32 ADC_value_add;

u16 ADC_value_true;

u8 ADC_volt[]={0,46,0,0,0};

u8 ADC_convert_volt ;

//端口配置（初始化：使能该GPIO口的时钟，定义GPIO口的使用引脚、速度、使用方式）

void Gpio_Init_A(void) 

{

    GPIO_InitTypeDef GPIO_InitStructure; 

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);  

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_4|GPIO_Pin_5; 

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 ,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

}

//AD转换初始化子函数 

void ADC_init(void)

{

ADC_InitTypeDef ADC_InitStructure ;

ADC_InitStructure.ADC_Mode=ADC_Mode_Independent; //独立模式

    ADC_InitStructure.ADC_ScanConvMode = DISABLE;//单通道模式

    ADC_InitStructure.ADC_ContinuousConvMode =ENABLE;//连续转换

  ADC_InitStructure.ADC_ExternalTrigConv=ADC_ExternalTrigConv_None;//转换由软件启动，不受外界决定

    ADC_InitStructure.ADC_DataAlign=ADC_DataAlign_Right;//右对齐

  ADC_InitStructure.ADC_NbrOfChannel=1;//AD转换通道数

    ADC_Init(ADC1, &ADC_InitStructure);

  ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_1Cycles5);//ADC1的通道，采样时间为1.5周期

    ADC_Cmd(ADC1, ENABLE);//使能指定的ADC

    ADC_SoftwareStartConvCmd(ADC1, ENABLE);//使能ADC1的软件转换启动功能。

    }

//读出AD转换结果

void ADC_data_read(void)

{

u8 i=0;

    for(;i<10;i++)

    {

        while(ADC_GetFlagStatus(ADC1,  ADC_FLAG_EOC)==RESET);

        ADC_value[i]=ADC_GetConversionValue(ADC1);

        ADC_value[i]=ADC_value[i]&0x0fff;

    }

}

void ADC_data_filter()

{

    ADC_value_add=ADC_value[0]+ ADC_value[1]+ADC_value[2]+ADC_value[3]+ADC_value[4]+ADC_value[5]+ADC_value[6]+ADC_value[7]+ADC_value[8]+ADC_value[9];

    ADC_value_true=(u16)(ADC_value_add/10);

}

void ADC_data_convert()

{

ADC_convert_volt=ADC_value_true*330/4096;

ADC_volt[0]= ADC_convert_volt/100+48;

ADC_volt[2]= (ADC_convert_volt- (ADC_volt[0]-48)*100    )/10+48;

ADC_volt[3]= ADC_convert_volt%10+48;

}

  //串口编程

void USART_Transmit(u8 data)   

{

while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

    USART_SendData(USART1, data);

}

void put_s(u8*s)

{

while(*s)

{

USART_Transmit(*s);

s++;

}

}

//串口配置

void Usart_Init(void)

{

USART_InitTypeDef USART_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 ,ENABLE);//使能串口1时钟

   

USART_InitStructure.USART_BaudRate=9600;//波特率9600

USART_InitStructure.USART_WordLength=USART_WordLength_8b;//数据位为8位

USART_InitStructure.USART_StopBits =USART_StopBits_1;//1位停止位

USART_InitStructure.USART_Parity =USART_Parity_No;//无校验位

USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;//接收、发送使能

USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制失能

USART_Init(USART1, &USART_InitStructure);

USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

USART_Cmd(USART1, ENABLE);//使能USART1外设，打开串口1

USART_ClearFlag(USART1, USART_FLAG_TC);//清除USART1发送完成标志位

 } 

  //串口中断配置

void Nvic_init(void)

{

NVIC_InitTypeDef NVIC_InitStructure;

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

NVIC_InitStructure.NVIC_IRQChannel= USART1_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;

NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;

NVIC_InitStructure.NVIC_IRQChannelCmd =ENABLE;

     NVIC_Init(&NVIC_InitStructure);

}

  void USART1_IRQHandler(void)

  {

  if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)//是否产生中断

  {

  RxData = USART_ReceiveData(USART1);   //结束一个字符

  USART_SendData(USART1,RxData) ;

  while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

  }

 }

  //延迟函数

void Delay_MS(u32 time)

{

  unsigned char i;

  unsigned int j;

  for(j=0;j<time;j++)

  {

    for(i=0;i<120;i++)

    {

      ;;

    }

  }

}

int main(void)

{

Gpio_Init_A();

Usart_Init();

Nvic_init();

ADC_init();

while(1)

{

ADC_data_read();

ADC_data_filter();

ADC_data_convert();

put_s(ADC_volt);

put_s("V");

put_s("\n");

Delay_MS(10000);

Delay_MS(10000);

Delay_MS(10000);

}

}

五多路ＡＤ

#include "stm32f10x.h"

  u16 RxData;

  u32  ADC_value_add;

  u16  ADC_value_true;

  u16  ADC_value[10];  

  u8   ADC_volt[]={0,46,0,0,0};

  u8   ADC_convert_volt;

//时钟配置

void Gpio_Init_A(void)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_4|GPIO_Pin_5;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3,ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    }

   

void ADC_init(void)

{

    ADC_InitTypeDef ADC_InitStructure;

    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;

    ADC_InitStructure.ADC_ScanConvMode = DISABLE;

    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;

    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;

    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;

    ADC_InitStructure.ADC_NbrOfChannel = 1;

    ADC_Init(ADC1, &ADC_InitStructure);

    ADC_RegularChannelConfig(ADC1,ADC_Channel_1, 1,ADC_SampleTime_1Cycles5);

    ADC_Cmd(ADC1,ENABLE);

    ADC_SoftwareStartConvCmd(ADC1,ENABLE);

     ADC_Init(ADC2, &ADC_InitStructure);

    ADC_RegularChannelConfig(ADC2,ADC_Channel_2, 1,ADC_SampleTime_1Cycles5);

    ADC_Cmd(ADC2,ENABLE);

    ADC_SoftwareStartConvCmd(ADC2,ENABLE);

     ADC_Init(ADC3, &ADC_InitStructure);

    ADC_RegularChannelConfig(ADC3,ADC_Channel_3, 1,ADC_SampleTime_1Cycles5);

    ADC_Cmd(ADC3,ENABLE);

    ADC_SoftwareStartConvCmd(ADC3,ENABLE);

}

void ADC1_data_read(void)

{

    u8 i=0;

    for(i=0;i<10;i++)

    {while(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC)==RESET);

    ADC_value[i]=ADC_GetConversionValue(ADC1);

    ADC_value[i]=ADC_value[i]&0x0fff;

    }

}

void ADC2_data_read(void)

{

    u8 i=0;

    for(i=0;i<10;i++)

    {while(ADC_GetFlagStatus(ADC2,ADC_FLAG_EOC)==RESET);

    ADC_value[i]=ADC_GetConversionValue(ADC2);

    ADC_value[i]=ADC_value[i]&0x0fff;

    }

}

void ADC3_data_read(void)

{

    u8 i=0;

    for(i=0;i<10;i++)

    {while(ADC_GetFlagStatus(ADC3,ADC_FLAG_EOC)==RESET);

    ADC_value[i]=ADC_GetConversionValue(ADC3);

    ADC_value[i]=ADC_value[i]&0x0fff;

    }

}

void ADC_data_filter(void)

{

  ADC_value_add=ADC_value[0]+ADC_value[1]+ADC_value[2]+ADC_value[3]+ADC_value[4]+ADC_value[5]+ADC_value[6]+ADC_value[7]+ADC_value[8]+ADC_value[9];

  ADC_value_true=(u16)(ADC_value_add/10);

}

void ADC_data_convert(void)

{

   ADC_convert_volt=(ADC_value_true*330)/4096;

    ADC_volt[0]= ADC_convert_volt/100+48;

    ADC_volt[2]=(ADC_convert_volt-(ADC_volt[0]-48)*100)/10+48;

    ADC_volt[3]=ADC_convert_volt%10+48;

}

  

void Usart_Init(void)

{

   USART_InitTypeDef USART_InitStructure;

   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);

   USART_InitStructure.USART_BaudRate=115200;

   USART_InitStructure.USART_WordLength = USART_WordLength_8b;

   USART_InitStructure.USART_StopBits = USART_StopBits_1;

   USART_InitStructure.USART_Parity = USART_Parity_No;

   USART_InitStructure.USART_HardwareFlowControl =USART_HardwareFlowControl_None;

   USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

   USART_Init(USART1, &USART_InitStructure);

   USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);

   USART_Cmd(USART1, ENABLE);

   USART_ClearFlag(USART1,USART_FLAG_TC);

}

void Nvic_Init(void)

{

  NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

}

void USART1_IRQHandler(void)

{

 if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)

 {

 RxData=USART_ReceiveData(USART1);

 USART_SendData(USART1,RxData);

 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

 }

}

 void USART_Transmit(u8 data)

{

 while( USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

 USART_SendData(USART1,data);

}

 void put_s(u8*s)

{

 while(*s)

 {

   USART_Transmit(*s);

   s++;

 }

}

  //延迟函数

void Delay_MS(u32 time)

{

  unsigned char i;

  unsigned int j;

  for(j=0;j<time;j++)

  {

    for(i=0;i<120;i++)

    {

      ;;

    }

   }

}

int main(void)

{

  Gpio_Init_A();

  Usart_Init();

  ADC_init();

  GPIO_WriteBit(GPIOA,GPIO_Pin_4,Bit_RESET);

  GPIO_WriteBit(GPIOA,GPIO_Pin_5,Bit_RESET);

  GPIO_WriteBit(GPIOA,GPIO_Pin_6,Bit_RESET);

  GPIO_WriteBit(GPIOA,GPIO_Pin_7,Bit_RESET);

 while(1)

  {

  ADC1_data_read();

  ADC_data_filter();

  ADC_data_convert();

   put_s(ADC_volt);

   put_s("v");

   put_s("\n");

  ADC2_data_read();

  ADC_data_filter();

  ADC_data_convert();

   put_s(ADC_volt);

   put_s("v");

   put_s("\n");

  ADC3_data_read();

  ADC_data_filter();

  ADC_data_convert();

   put_s(ADC_volt);

   put_s("v");

   put_s("\n");

    Delay_MS(10000);

    Delay_MS(10000);

    Delay_MS(10000);

   put_s("\n");

  }

  }