18F4550 et DS18B20 repond par 0xFF 0xFF (image resultat oscillo)

[inviteac751535]

Bonjour,

je programme un thermometre via la sonde tres sympathique DS18B20.
le PIC est un 18F4550 et le quartz 4Mhz (1cycle = 1us).
Je pense respecter la routine et le timing.
ci joint les codes main et ds18B20:

le main:

#include <p18f4550.h>
#include <delays.h>
#include <stdio.h>
#include "xlcd.h"
#include "project.h"   

#pragma config WDT = OFF	//watchdog OFF
#pragma config FOSC = HS

//definition des variables globales

unsigned char sondeT[5]={0xFF,0x07,0xFF,0x07};//sondeT[5]={0xFF,0x07,0xFF,0x07}
char temp1 [15] = "";//variable affichage temperature
char temp2 [15] = "";//variable affichage temperature

	
//*******************************************************************
//					Fonction Main									*
//*******************************************************************

void main (void)
{

ADCON0=0;
ADCON1=0x0f;
//initialisation hardware

//initialisation logicielle
LcdInit();


while(1) //boucle infinie du programme vide car uniquement interruptions
{
//sondes DS18B20
	Delay10TCYx(10);
	Sonde_Reset();
	Sonde_Write(0xcc);
	Delay10TCYx(10);
	Sonde_Write(0x44);	
	Delay10KTCYx(100);
	Sonde_Reset();
	Sonde_Write(0xcc);
	Delay10TCYx(10);
	Sonde_Write(0xbe);
	Delay10TCYx(10);
	Sonde_Readbyte(sondeT,0);//1er octet 
	Delay10TCYx(10);
	Sonde_Readbyte(sondeT,1);//2eme octet
	Delay10TCYx(10);
	Sonde_Reset();
	Temp_String (temp1,sondeT[0],sondeT[1]);//conversion temperature en chaine de caractere pour affichage sondeT[0],sondeT[1]
	SetDDRamAddr(0x80);//debut 1ere ligne
	putsXLCD(temp1);//affichage de l'heure
	while( BusyXLCD() );
	SetDDRamAddr(0xC0);//debut seconde ligne
	putsXLCD(temp2);//affichage de la temperature
	while( BusyXLCD() );
}//fin de la boucle

}//fin du main



//*******************************************************************
//					Fonctions d'Initialisation						*
//*******************************************************************

void LcdInit(void) // initalisation du LCD sur PORTD (D0-D6)
{
PORTD=0x00; 
TRISD=0x00;    
LATD=0x00;

OpenXLCD( FOUR_BIT & LINES_5X7 );
while( BusyXLCD() );
WriteCmdXLCD( FOUR_BIT & LINES_5X7 );
while( BusyXLCD() );
WriteCmdXLCD( DON & BLINK_OFF);
while( BusyXLCD() );
}

//*******************************************************************
//					Fonctions de temporisation						*
//					pour les fonctions LCD							*
//*******************************************************************

void DelayFor18TCY( void ) //50micro
{
Delay10TCYx(6);
return;
}
void DelayPORXLCD(void)//15ms
{
Delay1KTCYx(16); 
return;
}
void DelayXLCD(void)//5ms
{
Delay1KTCYx(6); 
return;
}

les routines DS18B20

//*************************************************
//reset pour demarrage 1 wire communication		  *
//*************************************************
	
void Sonde_Reset (void)
{
TRISAbits.TRISA0 = 0;
PORTAbits.RA0 = 0;
TRISAbits.TRISA1 = 0;
PORTAbits.RA1 = 0;
Delay10TCYx(50);
TRISAbits.TRISA0 = 1;
TRISAbits.TRISA1 = 1;
Delay10TCYx(50);
return;
}

//**************************************************
//ecriture d'octet de communication sur RA0 et RA1 *  
//**************************************************

void Sonde_Write (int valeur)
{
TRISAbits.TRISA0 = 0;PORTAbits.RA0 = 0;
TRISAbits.TRISA1 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x01)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 1er bit
//*************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x02)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 2 bit
//************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x04)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 3 bit
//************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x08)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 4 bit
//*************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x10)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 5 bit
//*************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x20)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 6 bit
//***************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x40)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 7 bit
//*************************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop
_endasm//15us
if(valeur&0x80)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(5);
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);;//fin 8 bit

}

//*******************************************************
// fonction de lecture de la temperature sur RA0 ou RA1 *//on peut surement faire les deux en meme temps
//*******************************************************

unsigned char Sonde_Readbyte(char* buffer,unsigned char flag)
{
unsigned char valeur1=0;//byte sonde RA0
unsigned char valeur2=0;//byte sonde RA1

//lecture 1er bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x01;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x01;
}
Delay10TCYx(5);

//lecture 2eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x02;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x02;
}
Delay10TCYx(5);

//lecture 3eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x04;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x04;
}
Delay10TCYx(5);

//lecture 4eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x08;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x08;
}
Delay10TCYx(5);

//lecture 5eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x10;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x10;
}
Delay10TCYx(5);

//lecture 6eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x20;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x20;
}
Delay10TCYx(5);

//lecture 7eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x40;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x40;
}
Delay10TCYx(5);

//lecture 8eme bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop nop
_endasm//15us
if (PORTAbits.RA0)
{
valeur1=valeur1|0x80;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x80;
}
Delay10TCYx(5);
//***************test octet L ou H avec le flag 
if (flag)
{buffer[1]=valeur1;buffer[3]=valeur2;}
if (!flag)
{buffer[0]=valeur1;buffer[2]=valeur2;}
}
//******************************************************
//fonction de conversion octets L et H en string	   *
//******************************************************

void Temp_String (char * buffer,unsigned char byteL,unsigned char byteH)
{
	static unsigned int decimales;static unsigned char result;

	if((byteH&0xF8)==0xF8)
	{
		//la virgule
	decimales =(((0xFF-byteL)+1)&0x0F)*625;
	//les decimales
	result=(((0xFF-byteL)+1)>>4)|(((0xFF-byteH)&0x07)<<4);
	//digit2 = (((0xFF-byteH)&0x07)<<4);
	//result=digit|digit2;
	//en string
	//if (result>9)sprintf (buffer, "-%d.%3u C",result,decimales);
	//else sprintf (buffer, "-0%d.%3u C",result,decimales);
	buffer[0]=0x2D;
	buffer[1]=((result/10)+48);
	buffer[2]=((result-((buffer[1]-48)*10))+48);
	buffer[3]=0x2E;
	buffer[4]=((decimales/1000)+48);
	buffer[5]=(((decimales-((buffer[4]-48)*1000))/100)+48);
	buffer[6]=0x20;
	buffer[7]=0x43;
	}
	
	else
	{
	//la virgule
	decimales =(byteL&0x0F)*625;
	//les decimales
	//digit = (byteL>>4);
	//digit2 = ((byteH&0x07)<<4);
	result=(byteL>>4)|((byteH&0x07)<<4);
	//en string
	//if (result>9)sprintf (buffer, "+%d.%3u C",result,decimales);
	//else sprintf (buffer, "+0%d.%3u C",result,decimales);
	buffer[0]=0x2B;
	buffer[1]=((result/10)+48);
	buffer[2]=((result-((buffer[1]-48)*10))+48);
	buffer[3]=0x2E;
	buffer[4]=((decimales/1000)+48);
	buffer[5]=(((decimales-((buffer[4]-48)*1000))/100)+48);
	buffer[6]=0x20;
	buffer[7]=0x43;
	}
	
}

Donc sur les routines ds18B20 je peux gerer 2 sondes (sur RA0 et RA1) mais je ne gere que celle de RA0 pour le moment et c'est deja pas mal vu tous les deboires que ca m'apporte.

Je suis completement perdu car ca n'a pas l'air difficile d'autant que la simulation isis fonctionne tres bien.
Je vous ai joint aussi les captures de l'oscillo pour vous montrer que tout semble bon.
On dirait que la sonde ne comprends pas les ordres 0xcc et 0x44 mais elle repond a 0xcc et 0xBE...
Enfin c'est navrant...pourquoi??? j'ai 10 sondes ici j'ai essayer avec les 10 et c'est pareil.

Alors pourriez vous m'aider..SVP.

merci de me faire partager votre exoperience sur le sujet car si il y avait un moyen de savoir si la sonde fonctionne bien lors de la conversion...

0xcc_0x44.JPG0xCC_0XBE.JPGresultat xFF xFF.JPG
-----

[xberger]

Bonsoir,

J'ai l'impression en regardant tes chronogrammes que la durée du reset est courte par rapport à la durée des bits.
Normalement le reset fait 2x 480µs et le bit 60µs.

Je te conseille de d'utiliser des boucles dans tes fonctions par exemple pour Sonde_Write().

Cordialement

Xavier

[inviteac751535]

salut,

Je vais voir cela pour le reset, effectivement peut etre trop juste (480ms est le minimum).
En revanche je viens de revoir le dernier chronogramme de resultat et il es tevident que la sonde ne repond pas, la mise a 1 est faite par le programme car je redonne la ligne pour lire la sonde.
15us de mise a 0, puis 15 us pour lire la sonde, et ensuite 50us pour le prochain bit.

Pour les boucles ca sera plus propre au final mais pour l'instant ca marche et c'etait plus clair pour moi pour faire du bit a bit.

merci

mais bon pourquoi la sonde ne reponds pas...elle fourni juste un bit de prense lors de la 1ere moitie du reset.
aidez moi merci!!!

[xberger]

Bonjour,

Le branchement est-il correct ?
Vdd = Alimentation
DQ = 1-wire data avec une pull-up de 4.7k au vdd

Cordialement

Xavier

[A voir en vidéo sur Futura]

[inviteac751535]

salut,

et bien ecoute je me pose la question sur la R de pull up.
J'ai en fait 2 resutance en serie de 2.2K.
mais je n'ai pas de R de 4.7Kohm.

Pour le branchement je pense que c'est OK car la sonde repond present durant la phase de reset

[invite5637435c]

Bonjour,

quelle longueur vos sondes?

Par expérience je peux vous dire que pour 3m il faut un pull-up de 2.2K pour que ça fonctionne bien.
Votre code est lourd et bien compliqué pour faire une simple mesure de température.
Il faut utiliser des pointeurs.

[dome45]

Bonjour

Voici ma routine avec un PIC a 4 Mhz, une resistance 4.7 K, la sonde ( 1820 ) se trouve a plus de 10 metres.
Le 1820 renvoie la temperature sur 9 bits
Le 18B20 la renvoie par defaut sur 12 bits

;;  Routine -> 1820.inc
;;;;;;;;;;;;;;;;;;;;;;;;Variables
; VTempL
; VtempH
; DS_cmpt
; DS_Data
; DS_Bit
; DS_Error
;:::::::::::::::::::::::Routines
; Delay_10us
; Delay_100ms
;;;;;;;;;;;;;;;;;;;;;;;;Define
; #define DQ1	PORTA,0
; #define DQ2	PORTA,1
;;;;;;;;;;;;;;;;;;;;;;;;Macro
Pin_low1	macro
	BCF		DQ1
	BSF		STATUS, RP0
	BCF		DQ1
	BCF		STATUS, RP0
	endm
Pin_hz1	 macro
	BSF		STATUS, RP0
	BSF		DQ1
	BCF		STATUS, RP0
	endm

Pin_low2	macro
	BCF		DQ2
	BSF		STATUS, RP0
	BCF		DQ2
	BCF		STATUS, RP0
	endm
Pin_hz2	 macro
	BSF		STATUS, RP0
	BSF		DQ2
	BCF		STATUS, RP0
	endm
;************************************************************************
;				ReadTemp				*
;************************************************************************
Read_Temp1
	CLRF	VTempL
	CLRF	VTempH
	CALL	DS_Reset1
	BTFSC	DS_Error, 0		; =1?
	 GOTO	DSError1			; oui =1
	MOVLW	0xCC				; Skip ROM
	CALL	DS_Write1
	MOVLW	0x44				; demande conversion
	CALL	DS_Write1

	MOVLW	0x05
	CALL	Delay_100ms			; 500 ms
DS_Attente1
	MOVLW	0x01
	CALL	Delay_100ms			; 100 ms
	CALL	DS_Read1
	MOVLW	0xFF
	XORWF	DS_Data, w		; si DS_Data = W, resultat = 0		
	BTFSS	Zero				; =0?
	 GOTO	DS_Attente1		; OUI =0  
	
	CALL	DS_Reset1
	BTFSC	DS_Error, 0		; =1?
	 GOTO	DSError1			; oui =1
	MOVLW	0xCC				; Skip ROM
	CALL	DS_Write1
	MOVLW	0xBE				; Read Ccratchpad
	CALL	DS_Write1
	CALL	DS_Read1
	MOVWF	VTempL
	CALL	DS_Read1
	MOVWF	VTempH
	CALL	DS_Reset1
	RETURN
DSError1
	MOVLW	0x32		; +50
	MOVWF	VTemp1
	CLRF	DS_Error			
	RETURN
;************************************************************************
;	                      Reset/Presence	                            *
;************************************************************************
DS_Reset1
	Pin_hz1
	NOP
	BSF		DS_Error, 0		; Flag Erreur
	Pin_low1
	MOVLW	0x32				; 50
	call	Delay_10us			; attendre 500 µs
	Pin_hz1					; Haute impédance
	MOVLW	0x08
	call	Delay_10us			; attendre 80 µs
	BTFSC	DQ1				; DQ1 =1?
	 RETURN					; oui = 1  Erreur
	MOVLW	0x2A				; 43
	CALL	Delay_10us			; attendre 430 µs
	BCF		DS_Error, 0		; Reset OK  Flag Erreur remis a zero
	RETURN

;************************************************************************
;		                     Write                              *
;************************************************************************

DS_Write1
	MOVWF	DS_Data			; Lecture de W
	MOVLW	0x08
	MOVWF	DS_cmpt
WriteByte1
	BTFSS	DS_Data, 0		; =0?
	 CALL	Write1_0			; oui =0
	BTFSC	DS_Data, 0		; =1?
	 CALL	Write1_1			; bit=1
	RRF		DS_Data, F		; bit suivant
	DECFSZ	DS_cmpt, F		; =0?
	GOTO	WriteByte1	  		; non
	RETURN					; oui
Write1_0
	Pin_low1					; DQ1=0 ->Output
	MOVLW	0x06
	CALL	Delay_10us			; 60 µs
	Pin_hz1					; DQ1=1 -> Input  10 us
	RETURN
Write1_1
	Pin_low1					; DQ1=0 -> Output 4 us
	nop
	Pin_hz1					; DQ1=1	-> Input	
	MOVLW	0x06
	CALL	Delay_10us			; 60 µs
	RETURN

;************************************************************************
;		                     Read                               *
;************************************************************************
DS_Read1
	MOVLW	0x08
	MOVWF	DS_cmpt
	CLRF	DS_Data
DS_boucle1
	Pin_low1					; Output 
	NOP						; 4+1 µs
	NOP	
	Pin_hz1					; Input
	NOP						; 3+5 µs
	NOP
	NOP
	NOP
	NOP
	NOP
	RRF		DS_Data, F
	BCF		DS_Data, 7
	BTFSC	DQ1				; =1?
	BSF		DS_Data, 7		; oui =1
	MOVLW	0x06
	CALL	Delay_10us			; 60 us
	DECFSZ	DS_cmpt, F		; =0?
	GOTO	DS_boucle1		; non
	MOVFW	DS_Data
	RETURN					; oui

Bien gerer l'attente apres la demande de conversion 0x44 (La sonde doit renvoyer 0xFF -> 11111111)
@++

[invite5637435c]

Coté code c'est bien mieux c'est sur.

Par contre 4k7 à plus de 10m tu as beaucoup de chance, ou alors ton environnement n'est pas du tout pollué.

[inviteac751535]

bonjour,

mon cable ne fait que 30 cm pour le moment.
J'ai 2 resistances de 2.2 en serie...est ce suffisant.

Pour le code lourd je suis d'accord mais pour le moment je l'ai fait au plus detaille bit a bit pour essai mais ca ne marche pas...
Cependant la routine semble +/- fonctionner au vue des chronogrammes oscillo.
Mais j'ai l'impression que la sonde ne reconnait pas mes ordres cc 44 et BE?

J'ai lu dans la doc que l'on popuvait interroger la sonde apres le 0x44 pour savoir si la conversion etait finie...car j'utilise la meme alimentation (ce n'est pas une parasite).
Avez vous tester...ca pourrait etre un bon moyen de savoir si il comprend mes ordres de conversion.

merci

[dome45]

Bonsoir,

La question

bonjour,
J'ai lu dans la doc que l'on popuvait interroger la sonde apres le 0x44 pour savoir si la conversion etait finie.
Avez vous tester...ca pourrait etre un bon moyen de savoir si il comprend mes ordres de conversion.
merci

La reponse

Bien gerer l'attente apres la demande de conversion 0x44 (La sonde doit renvoyer 0xFF -> 11111111)

Interrogation de la sonde dans routine -> DS_Attente1

@++

[inviteac751535]

bonjour,

Cette histoire de simple sonde devient terrible et a s'arracher les cheveux....
Maintenant j'essai de lire la ROM avec 0x33h en command ROM et la pareil les 8 octets sont a 0xFF.
Je pense vraiment que ma sonde ne comprend pas mes commandes.
Tout comme "Bien gerer l'attente apres la demande de conversion 0x44 (La sonde doit renvoyer 0xFF -> 11111111)", j'ai d'office 0xff car lorsque je me remets en input la ligne passe a 1...donc ca veut dire que ma sonde ne repond pas.
Hors elle repond presente au reset...trop dure la.

[invite5637435c]

Tu ne serais pas en 3.3V par hasard?

Je regarde tes graphes et je vois que tu n'as que 3V pour tes créneaux....
C'est sensé fonctonner à 3V mais dans le doute tente en 5V pour voir si ça persiste, des fois que tu aurais des niveaux un peu juste.

[inviteac751535]

Bonsoir a tous,

Ca y est j'ai enfin trouve mon probleme et ce je dirai grace a Xberger et a Dome45.
En effet j'ai essaye tant bien que mal de mettre tout ceci en une boucle for (i=0;i<8;i++) mais a ma grande surprise meme la simulation de Isis ne fonctionnait plaus et ce en gradant les meme timings.
C'est alors que j'ai compris que le temps entre la mise a 0 de la ligne et le 1 de la commande doit etre tres precis de l'ordre de 5us.Le probleme avec la boucle for ou do-while c'est que c'est trop long ,surtout avec un 4Mhz ou chaque cycle est 1 us.
Donc j'ai garder ma routine d'ecriture en supprimmant pas mal de Nop.
ce qui donne

TRISAbits.TRISA0 = 0;PORTAbits.RA0 = 0;
TRISAbits.TRISA1 = 0;PORTAbits.RA1 = 0;
_asm
nop 
_endasm//3us
if(valeur&0x01)
{TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;}
Delay10TCYx(6);//60us
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
Delay10TCYx(1);//fin 1er bit

Et pour la lecture c'est pareil

//lecture 1er bit****************************************
TRISAbits.TRISA0 = 0;TRISAbits.TRISA1 = 0;
PORTAbits.RA0 = 0;PORTAbits.RA1 = 0;
_asm
nop nop //5us
_endasm//
TRISAbits.TRISA0 = 1;TRISAbits.TRISA1 = 1;
_asm
nop nop nop   //8us
_endasm//
if (PORTAbits.RA0)
{
valeur1=valeur1|0x01;
}
if (PORTAbits.RA1)
{
valeur2=valeur2|0x01;
}
Delay10TCYx(5);

donc voila une bonne epine du pied de sortie...
Un probleme aussi difficile a resoudre que la sonde est petite.
Riche en enseignement

Merci a tous et a bientot pour d'autres aventures