Welcome, guest! Login / Register - Why register?

Paste

Pasted as C++ by ilar ( 7 years ago )
#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&#40;RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOC, ENABLE&#41;;
 //RCC_APB2PeriphClockCmd&#40;RCC_APB2Periph_GPIOC, ENABLE&#41;;

 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);
 }
}

 

Revise this Paste

Children: 94834
Your Name: Code Language: