改一下错User\main.c(552): error: #159: declaration is incompatible with previous "Delay" (declared at line 332)
#include "stm32f10x.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_adc.h"
#include "stm32f10x_tim.h"
#include "stm32f10x_i2c.h"
#include "stm32f10x_rtc.h"
#include "stm32f10x_pwr.h"
#include "stm32f10x_bkp.h"
// ??????
#define KEY_SET_PIN GPIO_Pin_11
#define KEY_SET_PORT GPIOB
#define KEY_ADJ_PIN GPIO_Pin_1
#define KEY_ADJ_PORT GPIOB
#define LED_ALARM_PIN GPIO_Pin_13
#define LED_ALARM_PORT GPIOB
#define DHT11_PIN GPIO_Pin_0
#define DHT11_PORT GPIOA
#define LIGHT_SENSOR_PIN GPIO_Pin_1
#define LIGHT_SENSOR_PORT GPIOA
#define PWM_PIN GPIO_Pin_2
#define PWM_PORT GPIOA
#define OLED_SCL_PIN GPIO_Pin_8
#define OLED_SDA_PIN GPIO_Pin_9
#define OLED_I2C_PORT GPIOB
// OLED??
#define OLED_I2C I2C1
#define OLED_ADDRESS 0x3C
#define OLED_WIDTH 128
#define OLED_HEIGHT 64
// DHT11??
#define DHT11_TIMEOUT 10000
// ????
volatile uint8_t set_mode = 0; // 0:?? 1:???? 2:????
volatile uint16_t light_value = 0;
volatile uint8_t temperature = 0;
volatile uint8_t humidity = 0;
volatile uint8_t turbidity = 0; // ?????(0-100)
// ????
void System_Init(void);
void GPIO_Config(void);
void ADC_Config(void);
void TIM_Config(void);
void RTC_Config(void);
void RTC_SetTime(uint8_t hour, uint8_t min, uint8_t sec);
void RTC_GetTime(uint8_t *hour, uint8_t *min, uint8_t *sec);
void Key_Scan(void);
void Update_Display(void);
void Process_Control(void);
uint8_t DHT11_Read(void);
void OLED_Init(void);
void OLED_WriteCommand(uint8_t cmd);
void OLED_WriteData(uint8_t data);
void OLED_SetCursor(uint8_t x, uint8_t y);
void OLED_Clear(void);
void OLED_PrintChar(char ch);
void OLED_PrintString(char *str);
void OLED_UpdateScreen(void);
// ???? (6x8??)
const uint8_t Font6x8[95][6] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // space
{0x00, 0x00, 0x5F, 0x00, 0x00, 0x00}, // !
// ??????,?????????
{0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00}, // A
{0x7F, 0x49, 0x49, 0x49, 0x36, 0x00}, // B
{0x3E, 0x41, 0x41, 0x41, 0x22, 0x00}, // C
{0x7F, 0x41, 0x41, 0x22, 0x1C, 0x00}, // D
{0x7F, 0x49, 0x49, 0x49, 0x41, 0x00}, // E
{0x7F, 0x09, 0x09, 0x09, 0x01, 0x00}, // F
{0x3E, 0x41, 0x49, 0x49, 0x7A, 0x00}, // G
{0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00}, // H
{0x00, 0x41, 0x7F, 0x41, 0x00, 0x00}, // I
{0x20, 0x40, 0x41, 0x3F, 0x01, 0x00}, // J
{0x7F, 0x08, 0x14, 0x22, 0x41, 0x00}, // K
{0x7F, 0x40, 0x40, 0x40, 0x40, 0x00}, // L
{0x7F, 0x02, 0x0C, 0x02, 0x7F, 0x00}, // M
{0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00}, // N
{0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00}, // O
{0x7F, 0x09, 0x09, 0x09, 0x06, 0x00}, // P
{0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00}, // Q
{0x7F, 0x09, 0x19, 0x29, 0x46, 0x00}, // R
{0x46, 0x49, 0x49, 0x49, 0x31, 0x00}, // S
{0x01, 0x01, 0x7F, 0x01, 0x01, 0x00}, // T
{0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00}, // U
{0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00}, // V
{0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00}, // W
{0x63, 0x14, 0x08, 0x14, 0x63, 0x00}, // X
{0x07, 0x08, 0x70, 0x08, 0x07, 0x00}, // Y
{0x61, 0x51, 0x49, 0x45, 0x43, 0x00}, // Z
// ??0-9
{0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00}, // 0
{0x00, 0x42, 0x7F, 0x40, 0x00, 0x00}, // 1
{0x42, 0x61, 0x51, 0x49, 0x46, 0x00}, // 2
{0x21, 0x41, 0x45, 0x4B, 0x31, 0x00}, // 3
{0x18, 0x14, 0x12, 0x7F, 0x10, 0x00}, // 4
{0x27, 0x45, 0x45, 0x45, 0x39, 0x00}, // 5
{0x3C, 0x4A, 0x49, 0x49, 0x30, 0x00}, // 6
{0x01, 0x71, 0x09, 0x05, 0x03, 0x00}, // 7
{0x36, 0x49, 0x49, 0x49, 0x36, 0x00}, // 8
{0x06, 0x49, 0x49, 0x29, 0x1E, 0x00} // 9
};
// ?????
uint8_t OLED_Buffer[OLED_WIDTH * OLED_HEIGHT / 8] = {0};
int main(void) {
System_Init();
GPIO_Config();
ADC_Config();
TIM_Config();
RTC_Config();
OLED_Init();
// ???RTC??(????)
RTC_SetTime(15, 30, 0);
while(1) {
// ??DHT11?????
if(DHT11_Read() == 0) {
// ????,???temperature?humidity???
}
// ??????
light_value = ADC_GetConversionValue(ADC1);
// ???????(??????????)
turbidity = (light_value > 3000) ? 20 : (light_value > 2000 ? 50 : 80);
// ????
Key_Scan();
// ??OLED??
Update_Display();
// ??????
Process_Control();
// ??500ms
for(volatile int i=0; i<500000; i++);
}
}
// ?????
void System_Init(void) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |
RCC_APB2Periph_AFIO | RCC_APB2Periph_ADC1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 | RCC_APB1Periph_PWR |
RCC_APB1Periph_BKP | RCC_APB1Periph_I2C1, ENABLE);
}
// GPIO??
void GPIO_Config(void) {
GPIO_InitTypeDef GPIO_InitStructure;
// ???? (PB11, PB1)
GPIO_InitStructure.GPIO_Pin = KEY_SET_PIN | KEY_ADJ_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(KEY_SET_PORT, &GPIO_InitStructure);
// LED??? (PB13)
GPIO_InitStructure.GPIO_Pin = LED_ALARM_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(LED_ALARM_PORT, &GPIO_InitStructure);
// ????? (PA1)
GPIO_InitStructure.GPIO_Pin = LIGHT_SENSOR_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(LIGHT_SENSOR_PORT, &GPIO_InitStructure);
// PWM?? (PA2)
GPIO_InitStructure.GPIO_Pin = PWM_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(PWM_PORT, &GPIO_InitStructure);
// OLED I2C (PB8-SCL, PB9-SDA)
GPIO_InitStructure.GPIO_Pin = OLED_SCL_PIN | OLED_SDA_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(OLED_I2C_PORT, &GPIO_InitStructure);
// DHT11??? (PA0)
GPIO_InitStructure.GPIO_Pin = DHT11_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(DHT11_PORT, &GPIO_InitStructure);
}
// ADC??(?????)
void ADC_Config(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_55Cycles5);
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
}
// TIM??(PWM??)
void TIM_Config(void) {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
// ??????? (1kHz PWM)
TIM_TimeBaseStructure.TIM_Period = 999; // ARR
TIM_TimeBaseStructure.TIM_Prescaler = 71; // 72MHz/(72*1000) = 1kHz
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
// PWM????
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0; // ?????0
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC3Init(TIM2, &TIM_OCInitStructure); // ??3??PA2
TIM_Cmd(TIM2, ENABLE);
TIM_CtrlPWMOutputs(TIM2, ENABLE);
}
// RTC??
void RTC_Config(void) {
// ??PWR?BKP??
PWR_BackupAccessCmd(ENABLE);
BKP_DeInit();
// ??LSE??
RCC_LSEConfig(RCC_LSE_ON);
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);
// ??LSE??RTC???
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_RTCCLKCmd(ENABLE);
// ??RTC?????
RTC_WaitForSynchro();
RTC_WaitForLastTask();
// ??RTC?? (1Hz)
RTC_SetPrescaler(32767); // 32.768kHz / 32768 = 1Hz
RTC_WaitForLastTask();
}
// ??RTC??
void RTC_SetTime(uint8_t hour, uint8_t min, uint8_t sec) {
uint32_t counter = sec + min*60 + hour*3600;
// ?????
RTC_WriteProtectionCmd(DISABLE);
RTC_WaitForLastTask();
RTC_SetCounter(counter);
RTC_WaitForLastTask();
// ?????
RTC_WriteProtectionCmd(ENABLE);
}
// ??RTC??
void RTC_GetTime(uint8_t *hour, uint8_t *min, uint8_t *sec) {
uint32_t counter = RTC_GetCounter();
*sec = counter % 60;
*min = (counter / 60) % 60;
*hour = (counter / 3600) % 24;
}
// ????
void Key_Scan(void) {
static uint8_t key_set_last = 1;
static uint8_t key_adj_last = 1;
uint8_t key_set = GPIO_ReadInputDataBit(KEY_SET_PORT, KEY_SET_PIN);
uint8_t key_adj = GPIO_ReadInputDataBit(KEY_ADJ_PORT, KEY_ADJ_PIN);
// ?????
if(key_set == 0 && key_set_last == 1) {
set_mode = (set_mode + 1) % 3; // ??????
}
key_set_last = key_set;
// ?????(??????)
if(set_mode > 0 && key_adj == 0 && key_adj_last == 1) {
uint8_t h, m, s;
RTC_GetTime(&h, &m, &s);
if(set_mode == 1) { // ????
h = (h + 1) % 24;
} else if(set_mode == 2) { // ????
m = (m + 1) % 60;
}
RTC_SetTime(h, m, s);
}
key_adj_last = key_adj;
}
// DHT11????
uint8_t DHT11_Read(void) {
uint8_t data[5] = {0};
uint8_t i, j;
// ????????
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = DHT11_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(DHT11_PORT, &GPIO_InitStructure);
// ??18ms
GPIO_ResetBits(DHT11_PORT, DHT11_PIN);
Delay(18000);
// ??20-40us
GPIO_SetBits(DHT11_PORT, DHT11_PIN);
Delay(30);
// ???????
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(DHT11_PORT, &GPIO_InitStructure);
// ??DHT11??
if (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) != 0) return 1;
while (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == 0);
while (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) != 0);
// ??40???
for (i = 0; i < 5; i++) {
for (j = 0; j < 8; j++) {
while (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == 0);
Delay(40);
if (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) != 0) {
data[i] |= (1 << (7 - j));
while (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) != 0);
}
}
}
// ????
if (data[4] == (data[0] + data[1] + data[2] + data[3])) {
humidity = data[0];
temperature = data[2];
return 0; // ??
}
return 1; // ??
}
// OLED???
void OLED_Init(void) {
// I2C???
I2C_InitTypeDef I2C_InitStructure;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = 0x00;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = 100000; // 100kHz
I2C_Init(OLED_I2C, &I2C_InitStructure);
I2C_Cmd(OLED_I2C, ENABLE);
// OLED?????
OLED_WriteCommand(0xAE); // ????
OLED_WriteCommand(0xD5); // ????????
OLED_WriteCommand(0x80);
OLED_WriteCommand(0xA8); // ??????
OLED_WriteCommand(0x3F);
OLED_WriteCommand(0xD3); // ??????
OLED_WriteCommand(0x00);
OLED_WriteCommand(0x40); // ???????
OLED_WriteCommand(0x8D); // ?????
OLED_WriteCommand(0x14);
OLED_WriteCommand(0x20); // ????????
OLED_WriteCommand(0x00); // ??????
OLED_WriteCommand(0xA1); // ??????
OLED_WriteCommand(0xC8); // ??????
OLED_WriteCommand(0xDA); // ??COM??????
OLED_WriteCommand(0x12);
OLED_WriteCommand(0x81); // ?????
OLED_WriteCommand(0xCF);
OLED_WriteCommand(0xD9); // ???????
OLED_WriteCommand(0xF1);
OLED_WriteCommand(0xDB); // ??VCOMH????
OLED_WriteCommand(0x40);
OLED_WriteCommand(0xA4); // ??????
OLED_WriteCommand(0xA6); // ??????
OLED_WriteCommand(0xAF); // ????
OLED_Clear();
OLED_UpdateScreen();
}
// OLED???
void OLED_WriteCommand(uint8_t cmd) {
I2C_GenerateSTART(OLED_I2C, ENABLE);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(OLED_I2C, OLED_ADDRESS, I2C_Direction_Transmitter);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
I2C_SendData(OLED_I2C, 0x00); // ????: Co=0, D/C=0
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_SendData(OLED_I2C, cmd);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_GenerateSTOP(OLED_I2C, ENABLE);
}
// OLED???
void OLED_WriteData(uint8_t data) {
I2C_GenerateSTART(OLED_I2C, ENABLE);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(OLED_I2C, OLED_ADDRESS, I2C_Direction_Transmitter);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
I2C_SendData(OLED_I2C, 0x40); // ????: Co=0, D/C=1
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_SendData(OLED_I2C, data);
while(!I2C_CheckEvent(OLED_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_GenerateSTOP(OLED_I2C, ENABLE);
}
// ??????
void OLED_SetCursor(uint8_t x, uint8_t y) {
OLED_WriteCommand(0xB0 + y); // ?????
OLED_WriteCommand(x & 0xF); // ??????
OLED_WriteCommand(0x10 | (x >> 4)); // ??????
}
// ??
void OLED_Clear(void) {
for(uint16_t i=0; i<sizeof(OLED_Buffer); i++) {
OLED_Buffer[i] = 0x00;
}
}
// ????
void OLED_PrintChar(char ch) {
if(ch < 32 || ch > 126) return; // ????????
uint8_t c = ch - 32;
for(uint8_t i=0; i<6; i++) {
OLED_WriteData(Font6x8[c][i]);
}
}
// ?????
void OLED_PrintString(char *str) {
while(*str) {
OLED_PrintChar(*str++);
}
}
// ??????
void OLED_UpdateScreen(void) {
for(uint8_t page=0; page<8; page++) {
OLED_SetCursor(0, page);
for(uint8_t col=0; col<128; col++) {
OLED_WriteData(OLED_Buffer[page*128 + col]);
}
}
}
// ??????
void Update_Display(void) {
char buf[20];
uint8_t hour, min, sec;
RTC_GetTime(&hour, &min, &sec);
OLED_Clear();
OLED_SetCursor(0, 0);
// ????
sprintf(buf, "Time: %02d:%02d:%02d", hour, min, sec);
OLED_PrintString(buf);
// ????
OLED_SetCursor(0, 1);
sprintf(buf, "Temp: %d C", temperature);
OLED_PrintString(buf);
// ????
OLED_SetCursor(0, 2);
sprintf(buf, "Light: %d", light_value);
OLED_PrintString(buf);
// ????
OLED_SetCursor(0, 3);
sprintf(buf, "Turbidity: %d%%", turbidity);
OLED_PrintString(buf);
// ??????
if(set_mode > 0) {
OLED_SetCursor(0, 4);
if(set_mode == 1) OLED_PrintString("Set Hour");
else if(set_mode == 2) OLED_PrintString("Set Minute");
}
OLED_UpdateScreen();
}
// ??????
void Process_Control(void) {
uint8_t hour, min, sec;
RTC_GetTime(&hour, &min, &sec);
// ?????????
if(light_value < 1000) {
GPIO_WriteBit(LED_ALARM_PORT, LED_ALARM_PIN,
(sec % 2) ? Bit_SET : Bit_RESET); // 1Hz??
} else {
GPIO_WriteBit(LED_ALARM_PORT, LED_ALARM_PIN, Bit_RESET);
}
// ????
if(light_value < 1000 || hour >= 20) { // ???????8??
if(hour >= 20) {
TIM_SetCompare3(TIM2, 800); // ???? (80%???)
} else {
TIM_SetCompare3(TIM2, 300); // ???? (30%???)
}
} else {
TIM_SetCompare3(TIM2, 0); // ????
}
}
// ??????(????????????)
void Delay(uint32_t nCount) {
for(; nCount != 0; nCount--);
}
扫一扫
1849
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
