DS18B20 et Pic 18F458

[invitedb84cd39]

Bonsoir,

Je débute en électronique mais j'ai quelques bases.
J'utilise ISIS pour les simulation, et CCS pour la programation

Dans le cadre d'un projet je doit utiliser une sonde thermique, j'ai choisit la DS18B20 qui correspond très bien a mes besoins,
le pic quand a lui m'est +- imposé.

Le problème est que je n'arrive absolument pas a utiliser la sonde.
Cela fait déjà deux jours que je recherche une librairie qui serrait compatible avec mon pic.
J'ai effectué plusieurs tests, jusqu’à maintenant infructueux...

Si quelqu’un aurait une piste, un conseil, ou autre sa m'aiderait beaucoup
-----

[gcortex]

Bonjour et bienvenu,

effectivement le one wire est un protocole très exigeant

Il te faut une "application note"

soit par soft, soit en détournant l'usage de l'UART

je verrai si je peux te donner qqch à mon retour au bercail
au pire tu me le rappelles par MP.

[gcortex]

[invitedb84cd39]

Merci je vais déjà jeter un oeil à sa

[A voir en vidéo sur Futura]

[invitee13c535c]

Bonjour
Sur le site de microchip il y a des infos.
Perso je suis parti de leur exemple pour démarrer avec le 1Wire
http://www.microchip.com/stellent/id...pnote=en535817

[invitedb84cd39]

Encore merci,
J'ai réussit à lancer l'initialisation et demain je me lance dans la lecture de la température,

je pense que le plus dure est passée

[invite03481543]

Bonjour,

il faut bien prendre en compte que le traitement de ce genre de capteur est très lent (pas loin de la seconde pour le modèle 12 bits), donc il faut stopper toutes les interruptions lors du traitement sinon ça ne fonctionnera pas correctement, ou ne faire que lire le capteur (ce qui n'a pas vraiment d'intérêt à mon sens dans une appli).
Le One Wire à l'avantage de n'avoir qu'un fil mais aussi l'inconvénient de n'avoir qu'un fil.

Voici la routine en C que j'utilise sans problème avec MikroC:

/******************************************************************************/
/*                                               Mesure de la température                                                     */
/******************************************************************************/
unsigned int mesures_temp1()
{
          INTCON.T0IE = 0;
          // perform temperature reading
          Ow_Reset(&PORTH,0);           // onewire reset signal
          Ow_Write(&PORTH,0,0xCC);      // issue command SKIP_ROM
          Ow_Write(&PORTH,0,0x44);      // issue command CONVERT_T
          Delay_us(120);
          Ow_Reset(&PORTH,0);           // onewire reset signal
          Ow_Write(&PORTH,0,0xCC);      // issue command SKIP_ROM
          Ow_Write(&PORTH,0,0xBE);      // issue command READ_SCRATCHPAD
          Delay_ms(400);
          j1 = Ow_Read(&PORTH,0);       // Get temperature LSB
          temp1 = Ow_Read(&PORTH,0);    // Get temperature MSB
          temp1 <<= 8; temp1 += j1;     // Form the result
          INTCON.T0IE = 1;
          Delay_ms(50);
          return(temp1);
}


/******************************************************************************/
/*                 Affichage en mode texte (afficheur graphique 240x128) de la température              */
/******************************************************************************/
void Display_Temperature1_texte(unsigned int temp1write)
{
  char temp_whole1;
  unsigned int temp_fraction1;
// check if temperature is negative
  if (temp1write & 0x8000) {
     text1[0] = '-';
     temp1write = ~temp1write + 1;
     }
// extract temp_whole
  temp_whole1 = temp1write >> RES_SHIFT; // determine whole number
// convert temp_whole to characters
  text1[0] = temp_whole1/100  + 48;
  if(text1[0] == 48) text1[0] = '+';
  text1[1] = (temp_whole1/10)%10 + 48;    // extract tens digit
  text1[2] =  temp_whole1%10     + 48;    // extract ones digit
// extract temp_fraction and convert it to unsigned int
  temp_fraction1  = temp1write << (4-RES_SHIFT);   // determine fraction
  temp_fraction1 &= 0x000F;
  temp_fraction1 *= 625;
// convert temp_fraction to characters
  text1[4] =  temp_fraction1/1000    + 48;  // extract thousands digit
//  text[5] = (temp_fraction/100)%10 + 48;  // extract hundreds digit
//  text[6] = (temp_fraction/10)%10  + 48;  // extract tens digit
//  text[7] =  temp_fraction%10      + 48;  // extract ones digit
T6963C_write_text(text1, 13, 11, T6963C_ROM_MODE_XOR);
}

Comme le C est portable, tu peux l'importer dans ton code et faire les modifs mineures pour déclarer tes propres ports par exemple et ton timer.
@+

[gcortex]

Le One Wire à l'avantage de n'avoir qu'un fil mais aussi l'inconvénient de n'avoir qu'un fil.

Une telle complication juste pour avoir une auto-alimentation...

[invitedb84cd39]

Encore merci,

Il ne me manquait plus qu'a récupérer la température qui était correctement enregistrée dans la schatable.
Je teste avec votre version au plus vite

Moi j'ai choisit la sonde carde j'avait besoin :

- d'un minimum de précision (0,5° ou 0.225°),
- une sonde pas cher,
- un range de 100 -> 120 max,
- et je penses la monter sur une prise jack comme sa branchement facile et rapide.

Et puis c'est toujours instructif d’apprendre

[invitedb84cd39]

Voila mon code,
Il y a juste un bug pour la simulation (sur proteus) j'ai été obligé de lire deux fois le contenu de la scratpad.

main.c :

#include <main.h>
#include <lcd.c>
#include <OneWire.h>

//#define LCD_DATA_PORT getenv("SFR:PORTD")
#define DEGREE_SYM 0xdf


int1 sondeOK = 0 ;
int i;
float tempeAff;
static long TempeRead;

void main()
{
   lcd_init();
   lcd_putc("\fPret...");
   sondeOK = OW_reset();
   if (sondeOK == 0){
         
      /*CONFIGURATION DS18B20*/
      OW_Write_Byte(DS_SKIP_ROM);
      OW_Write_Byte(DS_CONF);
      OW_Write_Byte(DS_TMP_H);
      OW_Write_Byte(DS_TMP_L);
      OW_Write_Byte(DS_ACCU);      
      OW_reset();
      
      /*INITIALISATION*/
      OW_Write_Byte(DS_SKIP_ROM);
      OW_Write_Byte(DS_CP_SCRAT);
      OW_reset();
      
      while(1){
         /* PRISE TEMPERATURE*/
         OW_Write_Byte(DS_SKIP_ROM);
         OW_Write_Byte(DS_CONVERT_T);
         
         WaitForConversion();
         output_low(PIN_B4);
         OW_reset();
         
         OW_Write_Byte(DS_SKIP_ROM);      
         OW_Write_Byte(DS_READ_SCRATCHPAD);      
         delay_ms(100);   
         DEBUG_Read_Byte();
         
         OW_Write_Byte(DS_SKIP_ROM);
         OW_Write_Byte(DS_READ_SCRATCHPAD);
         delay_ms(100);   
         tempeRead = OW_Read_Byte();
         
         tempeAff = tempeRead * 0.0625;
         printf(lcd_putc,"\f%3.1f %cC", tempeAff, DEGREE_SYM);
      };      
   }
   lcd_putc("\fNo Sonde");
}

OneWire.h :

#define DS_SKIP_ROM 0xcc
#define DS_CONVERT_T 0x44
#define DS_READ_SCRATCHPAD 0xbe
#define DS_CONF 0x4e
#define DS_TMP_H 0xff
#define DS_TMP_L 0xff
#define DS_ACCU 0x00     //00->9   7f->12  
#define DS_CP_SCRAT 0x48

#define DS_IN PIN_B0   //Sonde sur B0



int OW_reset(){
   int1 pres = 0 ; //1 -> sonde ok // 0 -> pas ok

   set_tris_b(0b00000000);
   output_low(DS_IN);
   delay_us(500);   
      //output_high(PIN_B4);   
   set_tris_b(0b00000001);
   delay_us(70);      
      //output_low(PIN_B4);      
   pres = input(DS_IN);
   delay_us(410);      
      //output_high(PIN_B4);   
   return pres;
}

void OW_Write_Byte(char WByte){
   int bit;
   
   for ( bit = 1; bit <= 8; ++bit ){
      output_low(DS_IN);
      //output_low(PIN_B4);
      delay_us (6);
      output_bit (DS_IN,shift_right (&WByte, 1, 0)); //decale droite 1 bit
      delay_us (54);
      output_float (DS_IN);
      delay_us (10);         // recovery time between slots
      //output_high(PIN_B4);
   }    
}

void WaitForConversion(void){
    while (TRUE){
       output_low (DS_IN);
       delay_us (5);
       output_float (DS_IN);
       delay_us (5);
       if (input (DS_IN) == 1 ){ // sample bit
           break;
       }
       delay_us ( 55 );         // includes recovery time between slots
    }
}

long OW_Read_Byte(){
   static long OctIn = 0;
   int bit;
      
    for (bit = 1; bit <= 16; ++bit){
       output_low (DS_IN);
       //output_low(PIN_B4);
       delay_us (6);
       //output_high(PIN_B4);
       output_float (DS_IN);
       delay_us (9);
       shift_right ( &OctIn, 2, input(DS_IN));   // sample bit
       delay_us ( 55 );         // includes recovery time between slots
       }
    OW_Reset(); 
    return OctIn;
}

void DEBUG_Read_Byte(){
   static long OctIn = 0;
   int bit;
   
   //iDataIn = 0;
    for (bit = 1; bit <= 2; ++bit){
       output_low (DS_IN);
       //output_low(PIN_B4);
       delay_us (6);
       //output_high(PIN_B4);
       output_float (DS_IN);
       delay_us (9);
       shift_right ( &OctIn, 2, input(DS_IN));   // sample bit
       delay_us ( 55 );         // includes recovery time between slots
       }
    OW_Reset(); 
}