#include "stm32f10x.h"
#include "stdio.h"

// Определить DHT11данные пины
#define DHT11_PIN   GPIO_Pin_0
#define DHT11_PORT  GPIOA

// Функция инициализации DHT11
void DHT11_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    // Включить часы GPIOA
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    // Конфигурация Вывод DHT11 — двухтактный выход.
    GPIO_InitStructure.GPIO_Pin = DHT11_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DHT11_PORT, &GPIO_InitStructure);
}

// Функция задержки, единица измерения — микросекунды.
void Delay_us(uint32_t nCount)
{
    uint32_t i;
    for(i=0; i<nCount; i++);
}

// Функция программной задержки, единица измерения — миллисекунды.
void Delay_ms(uint32_t nCount)
{
    uint32_t i;
    for(i=0; i<nCount*1000; i++);
}

// Чтение одного бита из DHT11
uint8_t DHT11_ReadBit(void)
{
    uint8_t retries = 0;
    
    while(GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_RESET)
    {
        if (retries++ > 100) return 0;
        Delay_us(1);
    }
    
    Delay_us(40);   // Задержка 40 мкс
    
    if (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_SET)
        retries = 100;  // флаг тайм-аута
    else
        retries = 0;

    while(GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_SET)
    {
        if (retries++ > 100) return 0;
        Delay_us(1);
    }

    return 1;
}

// Прочитайте байт из данных DHT11.
uint8_t DHT11_ReadByte(void)
{
    uint8_t i, temp = 0;
    
    for(i=0; i<8; i++)
    {
        temp <<= 1;
        temp |= DHT11_ReadBit();
    }
    
    return temp;
}

// Прочтите значение температуры и влажности DHT11.
uint8_t DHT11_ReadData(uint8_t* temperature, uint8_t* humidity)
{
    uint8_t data[5], checksum;

    // Хост переводит шину в низкий уровень минимум на 18 мс.
    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Pin = DHT11_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DHT11_PORT, &GPIO_InitStructure);

    GPIO_ResetBits(DHT11_PORT, DHT11_PIN);
    Delay_ms(20);
    GPIO_SetBits(DHT11_PORT, DHT11_PIN);
    Delay_us(30);

    // Установить в режим ввода
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(DHT11_PORT, &GPIO_InitStructure);
    
    // ждать DHT11 ответ
    if (GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_RESET)
    {
        while(GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_RESET);
        while(GPIO_ReadInputDataBit(DHT11_PORT, DHT11_PIN) == Bit_SET);
        
        // Чтение 5 байт данных
        for(uint8_t i=0; i<5; i++)
            data[i] = DHT11_ReadByte();
        
        // Чтение контрольной суммы
        checksum = DHT11_ReadByte();

        // 校验данные        if((data[0] + data[1] + data[2] + data[3]) != checksum)
            return 0;
        
        *humidity = data[0];
        *temperature = data[2];

        return 1;
    }
    else
    {
        return 0;
    }
}

// Инициализировать USART1
void USART1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    // Включите часы USART1 и GPIOA.
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

    // КонфигурацияUSART1 контакт
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;  // TX
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  // RX
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // КонфигурацияUSART1
    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_Init(USART1, &USART_InitStructure);

    // Включить USART1
    USART_Cmd(USART1, ENABLE);
}

// Отправка символов в USART1
void USART1_SendChar(char ch)
{
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    USART_SendData(USART1, (uint8_t)ch);
}

// Отправить строку в USART1
void USART1_SendString(const char* str)
{
    while(*str)
    {
        USART1_SendChar(*str++);
    }
}

int main(void)
{
    uint8_t temperature, humidity;

    // Инициализируйте DHT11 и USART1
    DHT11_Init();
    USART1_Init();

    while(1)
    {
        if (DHT11_ReadData(&temperature, &humidity))
        {
            // Отправка данных о температуре и влажности на последовательный порт
            char buffer[50];
            sprintf(buffer, "Temperature: %d°C, Humidity: %d%%\r\n", temperature, humidity);
            USART1_SendString(buffer);
        }

        Delay_ms(2000);  // Чтение данных раз в 2 секунды
    }
}

#include "stm32f10x.h"
#include "stdio.h"

// функция声明
void ADC_Configuration(void);
void UART_Configuration(void);
void USART1_SendChar(char ch);

int main(void)
{
    // Инициализируйте АЦП и последовательный порт
    ADC_Configuration();
    UART_Configuration();

    while (1)
    {
        // Начать преобразование АЦП
        ADC_SoftwareStartConvCmd(ADC1, ENABLE);

        // преобразование ожидания завершено
        while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));

        // Чтение значения АЦП
        uint16_t adcValue = ADC_GetConversionValue(ADC1);

        // Преобразование значения АЦП в процент влажности
        float humidity = (float)adcValue / 4095 * 100;

        // Распечатать значение влажности в последовательный порт
        char buffer[20];
        sprintf(buffer, "Humidity: %.2f%%\r\n", humidity);
        for (int i = 0; buffer[i] != '\0'; i++)
        {
            USART1_SendChar(buffer[i]);
        }

        // задержаться на некоторое время
        for (int i = 0; i < 1000000; i++);
    }
}

// ADCКонфигурация
void ADC_Configuration(void)
{
    ADC_InitTypeDef ADC_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;

    // Включите тактовую частоту ADC1 и GPIOA.
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);

    // КонфигурацияGPIOA.1 — аналоговый вход.
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // ADCКонфигурация
    ADC_DeInit(ADC1);
    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStructure);

    // Канал 1 конфигурацииADC1 является каналом выборки.
    ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_55Cycles5);

    // Включить АЦП1
    ADC_Cmd(ADC1, ENABLE);

    // Калибровка АЦП
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1));
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1));
}

// последовательный порт Конфигурация
void UART_Configuration(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    // Включите часы USART1 и GPIOA.
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA,ДАВАТЬ ВОЗМОЖНОСТЬ);

    // КонфигурацияUSART1приколоть    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed ​​= GPIO_Speed_50 МГц;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // USARTКонфигурация
    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_Init(USART1, &USART_InitStructure);

    // Включить USART1
    USART_Cmd(USART1, ENABLE);
}

// Отправка символов в USART1
void USART1_SendChar(char ch)
{
    USART_SendData(USART1, (uint8_t)ch);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

#include "stm32f10x.h"
#include "i2c.h"
#include "delay.h"

#define BH1750_ADDRESS 0x23

void BH1750_Init()
{
    // Инициализируйте шину I2C
    I2C_Init();
}

void BH1750_Start()
{
    // Запуск измерения BH1750
    uint8_t cmd = 0x01; // Режим одиночного кадра с высоким разрешением
    I2C_Start();
    I2C_SendByte(BH1750_ADDRESS);
    I2C_WaitAck();
    I2C_SendByte(cmd);
    I2C_WaitAck();
    I2C_Stop();
}

uint16_t BH1750_Read()
{
    // Прочитайте результаты измерений BH1750
    uint16_t lux;
    I2C_Start();
    I2C_SendByte(BH1750_ADDRESS + 1); // Отправить команду чтения
    I2C_WaitAck();
    lux = I2C_ReceiveByte() << 8; // Прочитать старший байт
    I2C_Ack();
    lux |= I2C_ReceiveByte(); // Прочитать младший байт
    I2C_NAck();
    I2C_Stop();
    return lux;
}

void LED_Control(uint8_t state)
{
    // Управляющий светодиодный выключатель освещения
    if (state)
        GPIO_SetBits(GPIOA, GPIO_Pin_8); // Включите светодиод
    else
        GPIO_ResetBits(GPIOA, GPIO_Pin_8); // Выключить светодиод
}

int main(void)
{
    // Инициализируйте порт GPIO
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // Инициализируйте датчик BH1750
    BH1750_Init();

    while (1)
    {
        // Начать измерение
        BH1750_Start();

        // Измерение задержки завершено
        DelayMs(200);

        // Прочтите интенсивность света
        uint16_t lux = BH1750_Read();

        // Определить порог и управлять светодиодом
        if (lux > 1000)
            LED_Control(1); // Интенсивность света выше порога,Включите светодиод
        else
            LED_Control(0); // Интенсивность света ниже порога,Выключить светодиод
    }
}