void clock_setup(void)

        rcc_clock_setup_in_hse_8mhz_out_24mhz();

       

        /* Enable GPIOA clock. */

        rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);

       

        // ... hodiny pre dalsie periferie ...

 

void delay_us(u16 time){

        // ...

 

u8 i=0;                         // vseobecne pocitadlo

u8 state=0x00;          // stav zbernice

u8 data=0x00;           // aktualne nacitane data

extern u8 ROM_NO[8];// ID buffer kniznice lib_1wire

 

int main(void)

        clock_setup();

        owInit();               // inicializacia a reset zbernice 1-wire

       

        // ------------------------------------------------------------

        // Nacitanie ID vsetkych zariadeni zbernice

        // ------------------------------------------------------------

        state=owFirst();

        if(state!=0){

                // ID prveho zariadenia je v buffri ROM_NO

                // ... spracovanie ID  ...

                do{

                        state=owNext();

                        if(state==0) break;

                        // ID nasledujuceho zariadenia je v buffri ROM_NO

                        // ... spracovanie ID  ...

                }while(state);

        }

       

        // Predpokladajme ze na zbernici mame pripojene len zariadenia

        // DS18x20 (teplomer typ B,S), spustime prevod teploty a nacitame data

        // posledneho senzoru zo zoznamu (ID zostalo v ROM_NO)

 

        owReset();

        owVerify();                             // aktualizacia ID

        owWriteStrong(0x44);    // spustenie prevodu, napajanie obvodu

        for(i=0; i<75; i++){    // 750 usec delay

                delay_us(10000);

        }

        owSetResistive();               // zbernica do standardneho modu

       

        owReset();                              // nacitanie dat zo senzoru po byte

        owVerify();

        owWriteByte(0xBE);              // citanie scratch pamete senzora

        for(i=0; i<9; i++){             // pamet ma 9 byte

                data=owReadByte();

                // aktualny byte je v premennej data

                // ... spracovanie dat

        }

       

        // ...

       

        return 0;

 

 

 

 

 

u8  ROM_NO[8];                  // lokalny buffer pre ID zariadenia

u8  crc8;                               // globalna hodnota CRC

int LastDiscrepancy;    // priznak konfliktu na zbernici pri vyhladavani ID

int LastFamilyDiscrepancy;

int LastDeviceFlag;

 

static u8 dscrc_table[] = {

        0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,

      157,195, 33,127,252,162, 64, 30, 95,  1,227,189, 62, 96,130,220,

       35,125,159,193, 66, 28,254,160,225,191, 93,  3,128,222, 60, 98,

      190,224,  2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,

       70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89,  7,

      219,133,103, 57,186,228,  6, 88, 25, 71,165,251,120, 38,196,154,

      101, 59,217,135,  4, 90,184,230,167,249, 27, 69,198,152,122, 36,

      248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91,  5,231,185,

      140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,

       17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,

      175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,

       50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,

      202,148,118, 40,171,245, 23, 73,  8, 86,180,234,105, 55,213,139,

       87,  9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,

      233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,

      116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};

 

 

void owInit(void)

        // Nastavenie 1-wire zbernice do resistive modu. Predpoklada pripojenie

        // zdroja hodin k periferii.

        gpio_set_mode(OW_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, OW_TERM);

        gpio_set(OW_PORT, OW_TERM);

        delay_us(10000);        // 10 msec delay na ustalenie stavu zbernice

        owReset();

 

u8 owFirst(void)

   // reset the search state

   LastDiscrepancy = 0;

   LastDeviceFlag = FALSE;

   LastFamilyDiscrepancy = 0;

 

   return owSearch();

 

u8 owNext(void)

   return owSearch();

 

u8 owSearch(void)

   int id_bit_number;

   int last_zero, rom_byte_number, search_result;

   int id_bit, cmp_id_bit;

   unsigned char rom_byte_mask, search_direction;

   // initialize for search

   id_bit_number = 1;

   last_zero = 0;

   rom_byte_number = 0;

   rom_byte_mask = 1;

   search_result = 0;

   crc8 = 0;

 

   // if the last call was not the last one

   if (!LastDeviceFlag)

   {

      // 1-Wire reset

      if (!owReset())

      {

         // reset the search

         LastDiscrepancy = 0;

         LastDeviceFlag = FALSE;

         LastFamilyDiscrepancy = 0;

         return FALSE;

      }

 

      // issue the search command

      owWriteByte(0xF0);  

 

      // loop to do the search

      do

      {

         // read a bit and its complement

         id_bit = owReadBit();

         cmp_id_bit = owReadBit();

 

         // check for no devices on 1-wire

         if ((id_bit == 1) && (cmp_id_bit == 1))

            break;

         else

         {

            // all devices coupled have 0 or 1

            if (id_bit != cmp_id_bit)

               search_direction = id_bit;  // bit write value for search

            else

            {

               // if this discrepancy if before the Last Discrepancy

               // on a previous next then pick the same as last time

               if (id_bit_number < LastDiscrepancy)

                  search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);

               else

                  // if equal to last pick 1, if not then pick 0

                  search_direction = (id_bit_number == LastDiscrepancy);

 

               // if 0 was picked then record its position in LastZero

               if (search_direction == 0)

               {

                  last_zero = id_bit_number;

 

                  // check for Last discrepancy in family

                  if (last_zero < 9)

                     LastFamilyDiscrepancy = last_zero;

               }

            }

 

            // set or clear the bit in the ROM byte rom_byte_number

            // with mask rom_byte_mask

            if (search_direction == 1)

              ROM_NO[rom_byte_number] |= rom_byte_mask;

            else

              ROM_NO[rom_byte_number] &= ~rom_byte_mask;

 

            // serial number search direction write bit

            owWriteBit(search_direction);

 

            // increment the byte counter id_bit_number

            // and shift the mask rom_byte_mask

            id_bit_number++;

            rom_byte_mask <<= 1;

 

            // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask

            if (rom_byte_mask == 0)

            {

                owCrc8(ROM_NO[rom_byte_number]);  // accumulate the CRC

                rom_byte_number++;

                rom_byte_mask = 1;

            }

         }

      }

      while(rom_byte_number < 8);  // loop until through all ROM bytes 0-7

 

      // if the search was successful then

      if (!((id_bit_number < 65) || (crc8 != 0)))

      {

         // search successful so set LastDiscrepancy,LastDeviceFlag,search_result

         LastDiscrepancy = last_zero;

 

         // check for last device

         if (LastDiscrepancy == 0)

            LastDeviceFlag = TRUE;

         

         search_result = TRUE;

      }

   }

 

   // if no device found then reset counters so next 'search' will be like a first

   if (!search_result || !ROM_NO[0])

   {

      LastDiscrepancy = 0;

      LastDeviceFlag = FALSE;

      LastFamilyDiscrepancy = 0;

      search_result = FALSE;

   }

 

   return search_result;

 

u8 owVerify()

   unsigned char rom_backup[8];

   int i,rslt,ld_backup,ldf_backup,lfd_backup;

 

   // keep a backup copy of the current state

   for (i = 0; i < 8; i++)

      rom_backup[i] = ROM_NO[i];

   ld_backup = LastDiscrepancy;

   ldf_backup = LastDeviceFlag;

   lfd_backup = LastFamilyDiscrepancy;

 

   // set search to find the same device

   LastDiscrepancy = 64;

   LastDeviceFlag = FALSE;

 

   if (owSearch())

   {

      // check if same device found

      rslt = TRUE;

      for (i = 0; i < 8; i++)

      {

         if (rom_backup[i] != ROM_NO[i])

         {

            rslt = FALSE;

            break;

         }

      }

   }

   else

     rslt = FALSE;

 

   // restore the search state

   for (i = 0; i < 8; i++)

      ROM_NO[i] = rom_backup[i];

   LastDiscrepancy = ld_backup;

   LastDeviceFlag = ldf_backup;

   LastFamilyDiscrepancy = lfd_backup;

 

   // return the result of the verify

   return rslt;

 

void owTargetSetup(u8 family_code)

   u8 i;

 

   // set the search state to find SearchFamily type devices

   ROM_NO[0] = family_code;

   for (i = 1; i < 8; i++){

      ROM_NO[i] = 0;

   }

   LastDiscrepancy = 64;

   LastFamilyDiscrepancy = 0;

   LastDeviceFlag = FALSE;

 

 

void owFamilySkipSetup(void)

   // set the Last discrepancy to last family discrepancy

   LastDiscrepancy = LastFamilyDiscrepancy;

   LastFamilyDiscrepancy = 0;

 

   // check for end of list

   if (LastDiscrepancy == 0)

      LastDeviceFlag = TRUE;

 

void owSetRom(u8 *array){

        u8 i=0;

        for(i=0; i<8; i++){

                ROM_NO[i]=array[i];

        }

 

 

u8 owCrc8(u8 value)

   crc8 = dscrc_table[crc8 ^ value];

   return crc8;

 

 

u8 owReset(void)

        u8 state=0;

       

        gpio_clear(OW_PORT, OW_TERM);   // master Tx reset pulse 480usec min.

        delay_us(480);

        gpio_set(OW_PORT, OW_TERM);

       

        delay_us(80);                                   // wait 20usec + 60usec presence pulse

        state = GPIO_IDR(OW_PORT);

        delay_us(400);                                  // master Rx 80usec + 400usec minimum

 

        if((state & OW_TERM)==OW_TERM)

        {

                return FALSE;

        }

        else{

                return TRUE;

        }

 

void owWriteByte(u8 byte_value)

        u8 i=0;

        for(i=0; i<8; i++){             // LSB first

                owWriteBit(byte_value>>i);

        }

 

void owWriteBit(u8 bit_value)

   switch(bit_value & 0x01){

                case 0x00:

                        gpio_clear(OW_PORT, OW_TERM);

                        delay_us(60);

                        gpio_set(OW_PORT, OW_TERM);

                        break;

                       

                case 0x01:

                        gpio_clear(OW_PORT, OW_TERM);

                        delay_us(5);

                        gpio_set(OW_PORT, OW_TERM);

                        delay_us(55);

                        break;

   }

   delay_us(10);

 

u8 owReadBit(void)

        u8 state=0x00;

       

        gpio_clear(OW_PORT, OW_TERM);

        delay_us(5);                                    // doba citacieho pulzu

        gpio_set(OW_PORT, OW_TERM);

        delay_us(5);                                    // oneskorenie pre ustalenie slave

        state = GPIO_IDR(OW_PORT);

        delay_us(50);

 

        if((state & OW_TERM)==OW_TERM){

                return 1;

        }

        else{

                return 0;

        }

 

u8 owReadByte(void){

        u8 value=0x00;

        u8 i=0;

        for(i=0; i<8; i++){             // LSB first

                value |= (owReadBit()<<i);

        }

        return value;

 

void owSetStrong(void){

        gpio_set_mode(OW_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, OW_TERM);

 

void owSetResistive(void){

        gpio_set_mode(OW_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, OW_TERM);

 

void owWriteStrong(u8 byte_value){

        u8 i=0;

        for(i=0; i<8; i++){

                owWriteBit(byte_value>>i);

        }

        gpio_set_mode(OW_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, OW_TERM);

 

 

 

 

 

extern void delay_us(u16 time);

void owInit(void);                              // konfiguracia portu pre 1-wire

u8   owReset(void);                             // reset zbernice a kontrola pritomnosti zariadeni

u8   owFirst(void);                             // nacitanie ID prveho zariadenia

u8   owNext(void);                              // iteracia zoznamu zariadeni

u8   owVerify(void);                    // kontrola existencia ID zariadenia

void owTargetSetup(u8 fcode);   // nastavenie podmnoziny vyhladavanych zariadeni

void owFamilySkipSetup(void);   // zrusenie selektivneho vyhladavania

void owSetRom(u8 *array);               // nastavenie ID konkretneho zariadenia

 

void owSetStrong(void);                 // napajanie zariadenie v parazite power mode

void owSetResistive(void);              // pull-upp mod zbernice

void owWriteByte(u8 value);             // zapis byte na zbernicu

void owWriteStrong(u8 value);   // zapis byte a prepnutie do strong modu

u8   owReadByte(void);                  // nacitanie byte zo zbernice

 

u8   owSearch(void);                    // interny vyhladavaci algoritmus

void owWriteBit(u8 bit_value);  // zapis jedneho bite

u8   owReadBit(void);                   // nacitanie bite

u8   owCrc8(u8 value);                  // vypocet/kontrola CRC ID zariadenia