CH11-NE555

主板原理图

扩展模块原理图引脚表

引脚序号	主板引脚	扩展版模块引脚
1	5v
2	PB6	LD2
3	GND	GND
4	PB7	LD1
5	==PB1==（ADC_IN9）	ADC(PR1)
6	GND	GND
7	==PB0==（TIM3 CHANNEL3）	PLUS(PR2)
8	PA8
9	VDD_NODE	3V3
10	PB4

CubeMX配置

MDK配置

下载线配置

ADC配置

NE555配置

NE555配置NVIC

回调函数

Timer配置

Timer的NVIC配置

SPI配置1

由于SPI配置后只有三个引脚被配置，但数据通信时还有一个Lora通信SPI1_NSS对映的PA4需要配置为低电平

SPI配置2

OLED引脚配置

GPIO引脚配置

RTC配置

USART_DMA配置

USART参数配置

USART中断配置(IDLE)

NVIC配置

时钟树配置

生成文件配置1

生成文件配置2

MDK代码编写

ADC

unsigned short int ADC_PR1_Read(void)
{
	extern ADC_HandleTypeDef hadc;
	
	HAL_ADC_Start(&hadc);//启动ADC转换
	
	return HAL_ADC_GetValue(&hadc);//获取AD值
}

NE555

function.c

变量定义：

1 2	unsigned char ne555_ele_flag=0;//NE555的状态标志位 unsigned int ne555_time_save[3];//NE555的每个状态的时间

初始化：

void NE555_Init（void）
{
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_3);//首先需要初始化    
}

中断回调函数

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM3)//判断是否是NE555的定时器中断
	{
		if(ne555_ele_flag == 0)//进入第一个时期，高电平时期
		{
			ne555_time_save[0] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);//高电平捕获，记录此时的值
			__HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_FALLING);//设置成下降沿捕获
			ne555_ele_flag++;
		}
		else if(ne555_ele_flag == 1//进入第二个时期，低电平时期
		{
			ne555_time_save[1] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);//低电平捕获，记录此时的值
			__HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_RISING);//设置上升沿捕获
			ne555_ele_flag++;
		}
		else if(ne555_ele_flag == 2)//进入第三个时期，捕获周期结束的时间
		{
			ne555_time_save[2] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);//捕获周期结束的时刻=再次高电平捕获，记录此时的值		
			ne555_ele_flag++;
		}
	}
}

main.c

int main(void)
{
	extern unsigned char ne555_ele_flag;//NE555的状态标志位
	extern unsigned int ne555_time_save[3];//NE555的每个状态的时间
	unsigned int ne555_high_time;//高电平的时间
	unsigned int ne555_low_time;//低电平的时间
	unsigned int ne555_period_time;//周期
    while(1)
    {
        if(zsdz_ne555_state==3)
		{
            high_time = zsdz_ne555_timer[1]- zsdz_ne555_timer[0];       //计算高电平时间
            low_time=		zsdz_ne555_timer[2]- zsdz_ne555_timer[1];	//计算低电平时间
            period_time=	zsdz_ne555_timer[2]- zsdz_ne555_timer[0];     //计算周期

            printf("period_time=%d\r\n",1000000/period_time);			//计算周期
            zsdz_ne555_state = 0; //标志位清零
            __HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_RISING);		//设置成上升沿捕获	
		}
    }
}

function.c

#include "function.h"
#include "stdio.h"
#include "string.h"
#include "gpio.h"
#include "oled.h"
#include "lora.h"

extern UART_HandleTypeDef huart2;
extern DMA_HandleTypeDef hdma_usart2_rx;
extern DMA_HandleTypeDef hdma_usart2_tx;
extern TIM_HandleTypeDef htim7;
extern RTC_HandleTypeDef hrtc;
extern I2C_HandleTypeDef hi2c3;
extern SPI_HandleTypeDef hspi1;
extern ADC_HandleTypeDef hadc;
extern TIM_HandleTypeDef htim3;

unsigned char flag_num=0;

unsigned char ne555_ele_flag=0;
unsigned int ne555_time_save[3];

#define IDLE_RX_BUFFER_LEN 100
unsigned char idle_sec_len;
unsigned char idle_sec_flag;
unsigned char IDLE_rx_buffer[IDLE_RX_BUFFER_LEN];
static unsigned char oled_3_pub[16];
int *rx_num;

/* ALL Init */
void ALL_Init(void)
{
	IDLE_RX_Init();
	OLED_f_Init(100);
	HAL_TIM_Base_Start_IT(&htim7);
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_3);
}
/* LORA */
unsigned char SPI_WriteRead(unsigned char addr,unsigned char mess)
{
	unsigned char tx[2],rx[2];
	tx[0]=addr;
	tx[1]=mess;
	HAL_GPIO_WritePin(LAYER2_GPIO_Port, SPI1_NSS_Pin, GPIO_PIN_RESET);
	
	HAL_SPI_TransmitReceive(&hspi1,tx,rx,2,0xff);
	
	HAL_GPIO_WritePin(LAYER2_GPIO_Port, SPI1_NSS_Pin, GPIO_PIN_SET);
	
	return rx[1];
}
/* IDEL */
void IDLE_RX_Init(void)
{
	__HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
	HAL_UART_Receive_DMA(&huart2,IDLE_rx_buffer,IDLE_RX_BUFFER_LEN);
}

void IDLE_RX_EXTI(void)
{
	if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE)==SET)
	{
		HAL_UART_DMAStop(&huart2);
		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		
		idle_sec_flag=1;
		idle_sec_len=IDLE_RX_BUFFER_LEN-__HAL_DMA_GET_COUNTER(&hdma_usart2_rx);
	}
}

void IDLE_RX_DEAL(void)
{
	if(idle_sec_flag==1)
	{
		
		if(idle_sec_len==3)
		{
			rx_num=rx_translate(IDLE_rx_buffer);	
			
			sprintf((char *)oled_3_pub,"result:%d%c%d=%d",rx_num[0],rx_num[1],rx_num[2],rx_num[3]);
			OLED_ShowString(2,oled_3_pub);
		}
		HAL_UART_Receive_DMA(&huart2,IDLE_rx_buffer,IDLE_RX_BUFFER_LEN);
		idle_sec_flag=0;
		idle_sec_len=0;
	}
}



/* OLED */
void OLED_f_Init(unsigned char in_time)
{
	HAL_GPIO_WritePin(OLED_PWR_GPIO_Port, OLED_PWR_Pin, GPIO_PIN_RESET);
	OLED_Clear();
	OLED_Init();
	HAL_Delay(in_time);
}

void OLED_Write(unsigned char addr,unsigned char mess)
{
	unsigned char pub[2];
	pub[0]=addr;
	pub[1]=mess;
	HAL_I2C_Master_Transmit(&hi2c3,0x78,pub,2,0xff);
}


unsigned char *RTC_Read(void)
{
	static unsigned char rtc_read_data[7];
	
	RTC_TimeTypeDef rtc_time_data;
	RTC_DateTypeDef rtc_date_data;
	
	HAL_RTC_GetTime(&hrtc,&rtc_time_data,RTC_FORMAT_BIN);
	HAL_RTC_GetDate(&hrtc,&rtc_date_data,RTC_FORMAT_BIN);
	
	rtc_read_data[0]=rtc_date_data.Year;
	rtc_read_data[1]=rtc_date_data.Month;
	rtc_read_data[2]=rtc_date_data.WeekDay;
	rtc_read_data[3]=rtc_date_data.Date;
	
	rtc_read_data[4]=rtc_time_data.Hours;
	rtc_read_data[5]=rtc_time_data.Minutes;
	rtc_read_data[6]=rtc_time_data.Seconds;
	
	
	return rtc_read_data;
}

//float* ADC_Read(void)
//{
//	unsigned short int data[2];
//	
//	static float adc_value[3];
//	for(char a=0;a<2;a++)
//	{
//		HAL_ADC_Start(&hadc);//打开ADC转换器
//		HAL_ADC_PollForConversion(&hadc,0XFFFFFF);//等待一定时间，时间越长越精确
//		data[a]=HAL_ADC_GetValue(&hadc);//读取ADC转换的值
//		adc_value[a]=(float)data[a]*3.3/4095;//
//	}
//	HAL_ADC_Stop(&hadc);
//	
//	adc_value[2]=adc_value[0];
//	adc_value[0]=adc_value[1];
//	adc_value[1]=adc_value[2];
//	
//	return adc_value;
//}

int *rx_translate(unsigned char* mss)
{
	static int flag_num[4];
	flag_num[0]=mss[0]-48;
	flag_num[1]=mss[1];              
	flag_num[2]=mss[2]-48;
	if(flag_num[1] == 43)
	{
		flag_num[3]=flag_num[0]+flag_num[2];
	}
	if(flag_num[1] == 45)
	{
		flag_num[3]=flag_num[0]-flag_num[2];
	}
	
	return flag_num;
}

void LAYER_SWITCH(unsigned char layer_choose,unsigned char layer_turn)
{
	if(layer_choose==1)
	{
		if(0==layer_turn)
			HAL_GPIO_WritePin(GPIOA,LAYER1_Pin, GPIO_PIN_RESET);
		if(1==layer_turn)
			HAL_GPIO_WritePin(GPIOA,LAYER1_Pin, GPIO_PIN_SET);
		if(2==layer_turn)
			HAL_GPIO_TogglePin(GPIOA,LAYER1_Pin);
	}
	if(layer_choose==2)
	{
		if(0==layer_turn)
			HAL_GPIO_WritePin(GPIOA,LAYER2_Pin, GPIO_PIN_RESET);
		if(1==layer_turn)
			HAL_GPIO_WritePin(GPIOA,LAYER2_Pin, GPIO_PIN_SET);
		if(2==layer_turn)
			HAL_GPIO_TogglePin(GPIOA,LAYER2_Pin);
	}
}




unsigned short int ADC_PR1_Read(void)
{
	extern ADC_HandleTypeDef hadc;
	
	HAL_ADC_Start(&hadc);
	
	return HAL_ADC_GetValue(&hadc);
	
}
/*****************************************************/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin == USER_KEY_Pin)
	{
		//LAYER_SWITCH(2,2);
		flag_num=1;
	}		
}	
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	static int time_flag=0;
	if(htim7.Instance == TIM7)
	{
		if(++time_flag>1000)
		{
			time_flag=0;
			flag_num=1;
		}
	}
}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM3)
	{
		if(ne555_ele_flag == 0)
		{
			ne555_time_save[0] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);
			__HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_FALLING);
			ne555_ele_flag++;
		}
		else if(ne555_ele_flag == 1)
		{
			ne555_time_save[1] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);
			__HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_RISING);
			ne555_ele_flag++;
		}
		else if(ne555_ele_flag == 2)
		{
			ne555_time_save[2] = HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_3);
			//__HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_RISING);
			ne555_ele_flag++;
		}
	}
}



int fputc(int ch,FILE *f)
{
	HAL_UART_Transmit(&huart2,(uint8_t *)&ch,1,0xffff);
	//while(__HAL_UART_GET_IT(&huart2,UART_IT_TC)==RESET){}
	return ch;
}

function.h

#ifndef __FUNCTION_H__
#define __FUNCTION_H__

int *rx_translate(unsigned char* mss);

void IDLE_RX_Init(void);
void IDLE_RX_EXTI(void);
void IDLE_RX_DEAL(void);



void OLED_f_Init(unsigned char in_time);
void OLED_Write(unsigned char addr,unsigned char mess);
	
unsigned char *RTC_Read(void);

unsigned char SPI_WriteRead(unsigned char addr,unsigned char mess);

void LAYER_SWITCH(unsigned char layer_choose,unsigned char layer_turn);

//float* ADC_Read(void);

unsigned short int ADC_PR1_Read(void);

void ALL_Init(void);

#endif

main.c

#include "function.h"
#include "stdio.h"
#include "string.h"
#include "oled.h"
#include "lora.h"

int main(void)
{
  ALL_Init();
	float adc_read;
	extern unsigned char ne555_ele_flag;
	extern unsigned int ne555_time_save[3];
	unsigned int ne555_high_time;
	unsigned int ne555_low_time;
	unsigned int ne555_period_time;
   while (1)
  {
	  adc_read=(float)ADC_PR1_Read()*3.3/4095;
	  
	  printf("\r\n ADC1=%.2f \r\n",adc_read);
	  HAL_Delay(1000);
	  if(ne555_ele_flag == 3)
	  {
		  ne555_ele_flag=0;
		  ne555_high_time=ne555_time_save[1]-ne555_time_save[0];
		  ne555_low_time=ne555_time_save[2]-ne555_time_save[1];
		  ne555_period_time=ne555_time_save[2]-ne555_time_save[0];
		  printf("\r\n NE555=%d \r\n",1000000/ne555_period_time);
		  __HAL_TIM_SET_CAPTUREPOLARITY(&htim3,TIM_CHANNEL_3,TIM_INPUTCHANNELPOLARITY_RISING);
	  }
   }
}