#include "stm32f10x.h"
#include "misc.h"
#include "stm32f10x_conf.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#define Shared (GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3)
#define _0 0b11000000
#define _1 0b11111001
#define _2 0b10100100
#define _3 0b10110000
#define _4 0b10011001
#define _5 0b10010010
#define _6 0b10000010
#define _7 0b11111000
#define _8 0b10000000
#define _9 0b10010000
#define _hyphen 0b10111111
#define _DP_mask 0b01111111
void Delay()
{
TIM3->CNT=0;
while(TIM3->CNT<500){};
}
//*********************************************************************************************
//function импульс сброса //
//argument маска порта //
//return 0 - устройство обнаружен, 1 - не обнаружено, 2 - к.з. на линии //
//*********************************************************************************************
uint8_t ds_reset_pulse(uint16_t PinMask)
{
uint16_t result;
if((GPIOC->IDR & PinMask)==0) return 2; //проверить линию на отсутствие замыкания
GPIOC->ODR &= ~PinMask; //потянуть шину к земле
TIM3->CNT=0;
while(TIM3->CNT<480){}; //ждать 480 микросекунд
GPIOC->ODR |= PinMask; //отпустить шину
while(TIM3->CNT<550){}; //ждать 70 микросекунд
result = GPIOC->IDR & PinMask; //прочитать шину
while(TIM3->CNT<960){}; //дождаться окончания инициализации
if(result) return 1; //датчик не обнаружен
return 0; //датчик обнаружен
}
//*********************************************************************************************
//function передача бита //
//argument значение передаваемого бита,маска порта //
//return none //
//*********************************************************************************************
void ds_write_bit(uint8_t bit,uint16_t PinMask)
{
TIM3->CNT=0;
GPIOC->ODR &= ~PinMask; //потянуть шину к земле
while(TIM3->CNT<2){}; //ждать 1 микросекунду
if(bit) GPIOC->ODR |= PinMask; //если передаем 1, то отпускаем шину
while(TIM3->CNT<60){}; //задержка 60 микросекунд
GPIOC->ODR |= PinMask; //отпускаем шину
}
//*********************************************************************************************
//function чтение бита //
//argument маска порта //
//return прочитанный бит //
//*********************************************************************************************
uint16_t ds_read_bit(uint16_t PinMask)
{
uint16_t result;
TIM3->CNT=0;
GPIOC->ODR &= ~PinMask; //потянуть шину к земле
while(TIM3->CNT<2){};
GPIOC->ODR |= PinMask; //отпускаем шину
while(TIM3->CNT<15){}; //задержка 15 микросекунд
result = GPIOC->IDR & PinMask; //прочитать шину
while(TIM3->CNT<60){}; //оставшееся время
return result; //возвратить результат
}
//*********************************************************************************************
//function запись байта //
//argument передаваемый байт,маска порта //
//return none //
//*********************************************************************************************
void ds_write_byte(uint8_t byte, uint16_t PinMask)
{
uint8_t i;
for(i=0;i<8;i++) ds_write_bit(byte&(1<<i), PinMask);
}
//*********************************************************************************************
//function чтение байта //
//argument маска порта //
//return прочитанный байт //
//*********************************************************************************************
uint8_t ds_read_byte(uint16_t PinMask)
{
uint8_t i,result = 0;
for(i=0;i<8;i++)
if(ds_read_bit(PinMask)) result |= 1<<i;
return result;
}
//*********************************************************************************************
//function пуск измерения температуры //
//argument номер пина порта 0..15 //
//return 0 - пуск выполнен, 1 - датчик не обнаружен, 2 - к.з. на линии //
//*********************************************************************************************
uint8_t ds_start_convert_single(uint8_t PinNumb)
{
uint8_t result;
result = ds_reset_pulse(1<<PinNumb); //послать импульс сброса
if(result) return result; //если ошибка - возвращаем ее код
ds_write_byte(0xCC,1<<PinNumb); //разрешить доступ к датчику не используя адрес
ds_write_byte(0x44,1<<PinNumb); //запустить преобразование
return 0;
}
//*********************************************************************************************
//function чтение памяти датчика //
//argument указатель на массив-приемник данных, номер пина порта 0..15 //
//return 0 - данные прочитаны, 1 - датчик не обнаружен, 2 - к.з. 3 - ошибка CRC //
//*********************************************************************************************
uint8_t ds_read_data_single(uint8_t *buff, uint8_t PinNumb)
{
uint8_t crc = 0;
uint8_t data;
uint8_t i,j;
uint8_t tmp;
tmp = ds_reset_pulse(1<<PinNumb); //послать импульс сброса
if(tmp) return tmp; //если ошибка - возвращаем ее код
ds_write_byte(0xCC,1<<PinNumb); //разрешить доступ к датчику не используя адрес
ds_write_byte(0xBE,1<<PinNumb); //запрос 9 байт памяти
//прочитать 8 байт и вычислить CRC
for( i=0; i<8; i++)
{
data = ds_read_byte(1<<PinNumb); //прочитать очередной байт
buff[i] = data; //сохранить его в массиве
//вычисление CRC - обрабатываем каждый бит принятого байта
for( j=0; j<8; j++)
{
tmp = (crc ^ data) & 0x01;
if (tmp==0x01) crc = crc ^ 0x18;
crc = (crc >> 1) & 0x7F;
if (tmp==0x01) crc = crc | 0x80;
data = data >> 1;
}
}
data = ds_read_byte(1<<PinNumb); //прочитать CRC датчика
if(crc==data) return 0; //если CRC совпали - значит ошибки нет
return 3; //CRC не совпали, ошибка принятых данных
}
//*********************************************************************************************
//function чтение температуры датчика //
//argument номер пина порта 0..15 //
//return 1280 - ошибка, иначе - результат измерения //
//*********************************************************************************************
signed int ds_read_temperature(uint8_t PinNumb)
{
signed char integer = 0;
signed char frac;
signed int result;
uint8_t buff[8];
//прочитать данные из датчика
if(ds_read_data_single(&buff;[0],PinNumb)) return 1280;
frac = buff[0] & 0x0f; //получить дробную часть
integer = (buff[0]>>4) | ((buff[1] & 0x0f)<<4); //получить целую часть
//если температура отрицательная
if(integer<0)
{
integer = 0 - integer - 1;
result = integer *10; //учитываем целую часть
frac = frac | 0xf0;
frac = 0 - frac ;
}
//если температура положительная
else result = integer *10; //учитываем целую часть
result = result + ((frac*10)/16); //учитываем дробную часть
return result;
}
void ds_init()
{
RCC->APB1ENR |= RCC_APB1ENR_TIM3EN; //подать тактирование на TIM3 /
TIM3->PSC = 8-1; //настроить делитель для формирования микросекунд
TIM3->ARR = 1000;
TIM3->CR1 = TIM_CR1_CEN;
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; //Разрешить тактирование порта /
GPIOC->CRL &= ~GPIO_CRL_MODE7; //Очистить биты MODE
GPIOC->CRL &= ~GPIO_CRL_CNF7; //Очистить биты CNF
GPIOC->CRL |= GPIO_CRL_MODE7_1 ; //Выход,частота 2MHz
GPIOC->CRL |= GPIO_CRL_CNF7_0; //Открытый сток общего назначения
GPIOC->ODR |= 1<<7 ; //отпустить шину
}
int main(void)
{
ds_init();
signed int tmp;
ds_start_convert_single(7); //запустить измерение температуры
Delay(); Delay(); //время для окончания преобразования
tmp = ds_read_temperature(7); //прочитать результат измерения
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOC, ENABLE);
//RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitTypeDef GPIO_Init_struct;
//GPIO_StructInit(&GPIO;_Init_struct);
GPIO_Init_struct.GPIO_Pin = 0x00FF;
GPIO_Init_struct.GPIO_Speed= GPIO_Speed_2MHz;
GPIO_Init_struct.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO;_Init_struct);
GPIO_Init_struct.GPIO_Pin = Shared;
GPIO_Init(GPIOC, &GPIO;_Init_struct);
while(1) {
GPIO_SetBits(GPIOC, GPIO_Pin_0);
GPIO_SetBits(GPIOA, _hyphen & _DP_mask);
Delay();
GPIO_ResetBits(GPIOC, 0xFF);
GPIO_ResetBits(GPIOA, 0xFF);
GPIO_SetBits(GPIOC, GPIO_Pin_1);
GPIO_SetBits(GPIOA, _2 & _DP_mask);
Delay();
GPIO_ResetBits(GPIOC, 0xFF);
GPIO_ResetBits(GPIOA, 0xFF);
GPIO_SetBits(GPIOC, GPIO_Pin_2);
GPIO_SetBits(GPIOA, _3);
Delay();
GPIO_ResetBits(GPIOC, 0xFF);
GPIO_ResetBits(GPIOA, 0xFF);
GPIO_SetBits(GPIOC, GPIO_Pin_3);
GPIO_SetBits(GPIOA, _4);
Delay();
GPIO_ResetBits(GPIOC, 0xFF);
GPIO_ResetBits(GPIOA, 0xFF);
}
}Add a code snippet to your website: www.paste.org