j'ai la berlue, ou ces deux menus sont nouveau?

[juju]

bonjour

je traine depuis un mois sur le site, mais je viens de remarquer ces deux menus. j'avais jamais vue ou c'est une évolution?

ha les vieux retraité et leur carreaux en bois

[paaubert]

Salut Juju,
Ne confonds quand même pas le forum GW et mon site perso

Mais tu as raison ces deux menus sont nouveaux, pour les consommations électrique c'est grâce à Jean (encore lui) qui à fait un programme pour alimenter une base de données depuis un EnviR
http://www.currentcost.com/product-envir.html
Pour ce qui est du schéma de principe de mon chauffage, c'est grâce à toi, je connaissait déjà les sondes 1-wires, mais je ne savait pas trop comment les exploiter, c'est bientôt chose faite grâce à tes liens, je vais pouvoir les connecter sur un adaptateur USB et alimenter ma base de données avec LogTemp.

La page n'est pas terminée car je n'ai pas reçu l'adaptateur USB, mais j'ai déjà reçu les sondes, vu leur prix dérisoire je vais en mettre 20 à 25 pces.
Après sur le graphique il va avoir un mixte de mes données de la station météo, de l'EnviR pour la conso, et de LogTemp pour les sondes de températures, je vais pouvoir faire des calculs de puissance et de COP pour la PAC et les panneaux solaires.
Au final je pense que le truc sera plutôt sympa
http://www.boock.ch/meteo/pac/test_pac.php

voici quelques copie d'écran du programme de Jean.

envir.jpg

A+

[Micharnaud]

bon bouleau je suis intéressé par ces sondes ou les trouve t'on et comment on les adapte t'on merci de votre réponses
ok je Vien de trouver sur le forum merci et pour les sondes
http://www.amazon.fr/DS18B20-1-Wire-Dig ... ongueur+1m

[juju]

bonjour
c'est super enfin moi j'adore

vu leur prix dérisoire je vais en mettre 20 à 25 pces

petite précision:
il y a deux mode de fonctionnement:
- le mode parasite, ( deux fils) tu court-circuites deux pattes mais dans ce cas l'alim se fait grâce a l'adaptateur et je vais rechercher dans mes docs mais je crois que le total supporté est dans ce mode de 14 sondes par adaptateur

- le mode normal (trois fils)l ou tu alimente chaque sonde, dans ce cas le nombre est illimité

par contre réfléchit bien a la structure du réseau, lit le document de chez maxim, le mode étoile c'est quand tes branches ne sont pas trop longues (moi je suis en étoile, la plus longue branche fait une quinzaine de mètre
sinon le mode parallèle = nombre illimité et longueur importante

- tu peut faire un mix de sonde, température, pression, et plus encore.
j'utilise pour mon réseau du câble téléphone, torsadé c'est moins sensible aux parasites.

je te cherche le document qui va bien sur la consommation des sondes. Il faut prendre en considération le cas ou chaque sondes sont appelées en même temps
Cordialement.
Sinon si Jean programme, chez maxim il y a les sources et exemples plus librairie y compris en visual basic.

je te conseille de paramétrer chaque sonde pour avoir seulement deux decimales apres la virgule, le temps de conversion est beaucoup plus rapide

a ton service, et au service de ceux qui on besoin, je connait un peut ce systeme

[paaubert]

Salut,
je pense les mettre en mode normal avec une alim externe, je cherche encore comment la réaliser mais je vais trouver.

Normalement le branchement ne devrais pas me poser de problème pour les mettre toutes en parallèles.

Par contre moi j'ai acheté des sondes déjà montées dans un tube inox et étanche, un peu plus cher, mais moins de travail.
http://www.amazon.fr/Vktech-DS18b20-cap ... y_hi_img_y

A+

[juju]

re

je viens de retrouvé un post que j’avais fait sr un forum:

combien peut on mettre de sondes
il y a a mon sens deux façon de voir:
a) la limitation électrique
b) le temps de réponse.
pour ce qui est du temps de réponse tout dépend comment a été écrit le logiciel car il semble qu'il y ait deux méthode:
la première:
le programme va à la découverte (commande "search ROM") des sondes du réseau, puis à chaque DS18B20 trouvée lance une conversion, attend (750 ms) et lui demande le résultat. Si on a beaucoup de sondes, la collecte prend du temps (0,8 seconde par sonde), donc la limitation viendra de la partie logicielle.
parade: Si on suppose que le bus 1-wire ne contient que des DS18B20, on peut lancer l'ordre de conversion à toutes les sondes sur le bus ("skip ROM"), et ensuite collecter les températures de toutes les sondes sans attente

mais alors arrive la limite électrique. Deux limites, celle de l' adaptateur et celle du bus USB
la limite électrique du bus:
le bus USB peut fournir 5Volts 500Ma
La consommation maximale d'une sonde DS18B20 est 1,5 mA pendant les écritures EPROM et les conversions.
si l'on soustrait ce que le bus donne déjà (souris)..... on peut connaitre ne nombres de sondes maxi avant d'avoir le message Windows: pic de consommation sur le port USB

la limite électrique de l'adaptateur:
sur le DS9490 on peut tirer jusqu'à 42 mA, mais il est conseillé de rester sous 25 mA. ce qui donne (Si on lance toutes les conversions de température en même temps) entre 17 (limite sûre) et 28 sondes (limite maxi).

toutes correction sera la bienvenue Alain/Juju

Bonjour Alain,

Tu peux demander une résolution sur 11bits au lieu de 12, c'est ce que je fais maintenant et cela fait passer le temps de conversion de 750ms à 375ms.
Tu peux aussi exploiter le mode "skip ROM" mais il faut alimenter ton réseau, ne pas utiliser le mode parasite.
Dans mon cas je ne l'utilise pas car les usagers peuvent avoir un réseau alimenté ou non.

le gros avantage du 1-wire est qu'une fois le bus en place, ajouter une sonde coûte très peu.
Je soude une prise RJ11 sur chaque sonde et j'utilise un "hub" RJ11, en fait un duplicateur de ports RJ11 : il suffit donc de brancher la nouvelle sonde sur le duplicateur.

La collecte 1-wire est plus fiable que la collecte M3, car tous les quelques jours, j'ai un souci sur la collecte

des liens

un site perso
http://solarihome.perso.sfr.fr/oneWire/

la doc maxim
http://www.maximintegrated.com/en/app-n ... mvp/id/148

[u]et pour rendre a César ce qui est a césar[/u]
petit programme en C en ligne de commande, permet de configurer les sonde car selon les distributeurs ellent ne sont pas toujours configurées de la même manière
difficile de vous diriger vers le forum car i faudrait lire plusieurs posts donc
le concepteur du programme est:
http://forum.apper-solaire.org/profile. ... ofile&u=97

son site de monitoring est ici
http://solarihome.perso.sfr.fr/

Mais ce qui nous intéresse je l'ai compilé en un seul paragraphe, on trouve le lien vers le prog et la source

Ci-dessous liens vers mon petit programme C pour manipuler les sondes.

Il utilise les drivers TMEX aussi.
Edition de liens statique donc il doit tourner sur tout PC avec les drivers installés.


L'exécutable (compilé par Visual C++ Express : gratuit), pas de virus a priori : c'est moi Solarihome, pas Alain qu'il l'ait compilé :

http://solarihome.perso.sfr.fr/oneWire/oneWire2.exe

Le programme permet :

1) D'afficher les ROM de tous devices présents sur le bus (option "search")

2) De configurer toutes les sondes DS18B20 à la résolution demandée (option "config" [<pr>])

3) D'afficher le ROM et la température de toutes les sondes DS18B20 présentes sur le bus

4) D'afficher le scratchpad de toutes les sondes DS18B20 présentes sur le bus (permet de vérifier ce qui se trouve dans l'EPROM)

C'est l'option 3 qui t'intéresse (fonction C cmdeTemp) :
- on reset le bus
- on envoie la commande "skip ROM" (tous les devices écoutent)
- on envoie la commande "convert T"
- on attend 750 ms
- puis on lit la température de toutes les sondes à fond
(la fonction C tousDS18B20 applique une fonction à tous les DS18B20 trouvés)
=> Toutes les sondes convertissent et sont lues en moins d'une seconde.

Le programme C est utilisé comme sous-process d'un script Python. Les résultats sont récupérés sur stdout.

Note : on peut facilement dériver un programme qui lit périodiquement des sondes choisies et écrits leur température dans un fichier.

Cordialement,
Thierry

[juju]

re la source de ce petit prog très pratique
Usage et copie libre, je ne projette pas de gagner le prix Turing avec. dit par l'auteur

Code : Tout sélectionner

/*--------------------------------------------------------------------------
 * Programme qui opère sur un bus 1-wire connecté au PC
 * La gestion des erreurs 1-wire est basique (on abandonne si problème)
 * Options :
 * - temp : lit et écrit sur stdout les ROM id et températures
 * de toutes les DS18B20 trouvées : ROMid1 temperature1 ROMid2 temperature2...
 * - config <precision> : fixe la résolution EEPROM des sondes DS18B20 trouvées
 * - search : retourne le ROM id de tous les devices 1-wire trouvés sur le bus
 * - dump : rend le scratchpad des sondes DS18B20 trouvées sur le bus
 * Rend 0 si succès, 1 si échec
 *
 * Nécessite que les drivers Maxim/Dallas TMEX soient installés.
 *
 * Auteur : T.Streiff 01/2010
 * 27/01/10 : correction pour les températures négatives
 *
 * Compilateur :  Microsoft Visual C++ 2008 Express
 * --------------------------------------------------------------------------
 */


#include "iBTMEXCW.H"
#include <stdio.h>

// prototypes locaux
void fatal(char *);


#define DS18B20_FAMILY	0x28


// variables globales
uchar buffer[5120];			// buffer 1-wire
long session;				// session 1-wire
int rc;						// code retour générique


/*----------------------------------------------------------------------
 *  Ecrit le message d'erreur sur stderr
 */
typedef struct msg
{
	int  code;
	char *msg;
} msgT;

msgT mapping[] =
{
	{ -200, "invalid session" },
	{ -201, "session non trouvée" },
	{ -1, "port non initialise" },
	{ -2, "port non existant" },
	{ -3, "fonction non existante" },
	{ -12, "echec BCOM" },
	{ -13, "evenement BCOM" },
	{ 0, "" }
};

char *msgErr(code)
{
	msgT *m = mapping;
	while (m->code)
	{
		if (m->code == code)
			return m->msg;
		++m;
	}
	return "";
}

void erreur(char *texte)
{
	char* msg = msgErr(rc);
	fprintf(stderr, "Erreur, ");
	fprintf(stderr, texte);
	fprintf(stderr, " : (%d) %s\n", rc, msg);
}


/*----------------------------------------------------------------------
 *  Termine le programme
 */
void fin(int diag)
{
#if DEBUG
	char *msg;

	switch (diag)
	{
	case EXIT_SUCCESS: msg = "OK"; break;
	case EXIT_FAILURE: msg = "echec"; break;
	default: msg = "inconnu"; break;
	}
	fprintf(stderr, "Resultat : %s\n", msg);
#endif
	exit(diag);
}


/*----------------------------------------------------------------------
 *  Affiche l'usage sur stdout et quitte
 */
char* usageMsg[] =
{
	"Usage",
	"  search [alarm] : donne les ROM de tous les devices [en alarme] du bus",
	"  temp : donne ROM et temperatures des DS18B20 du bus",
	"  dump : donne ROM et scratchpad des DS18B20 du bus",
	"  config [<precision>] : configure la precision des DS18B20 du bus (12-bit par défaut)",
	NULL
};

void usage(void)
{
	char **p = usageMsg;
	while (*p)
	{
		fprintf(stderr, *p);
		fprintf(stderr, "\n");
		++p;
	}
	fin(EXIT_FAILURE);
}


/*----------------------------------------------------------------------
 *  Fait un reset du bus 1-wire
 */
void OWReset(void)
{
	rc = TMTouchReset(session);
	if ((rc != 1) && (rc != 2))
		fatal("TMTouchReset");
}


/*----------------------------------------------------------------------
 *  Fait un reset et un match ROM sur le device courant
 */
void OWAccess(void)
{
	if ((rc = TMAccess(session, buffer)) < 0)
		fatal("TMAccess");
}


/*----------------------------------------------------------------------
 *  Lance une recherche générale sur le bus 1-wire
 */
void OWFirst(void)
{
	if ((rc = TMFirst(session, buffer)) < 0)
		fatal("TMFirst");
}


/*----------------------------------------------------------------------
 *  Lance une recherche de devices en alarme sur le bus 1-wire
 */
void OWFirstAlarm(void)
{
	if ((rc = TMFirstAlarm(session, buffer)) < 0)
		fatal("TMFirstAlarm");
}


/*----------------------------------------------------------------------
 *  Continue une recherche en cours sur le bus 1-wire
 */
void OWNext(void)
{
	if ((rc = TMNext(session, buffer)) < 0)
		fatal("TMNext");
}


/*----------------------------------------------------------------------
 *  Continue une recherche en cours des devices en alarme sur le bus 1-wire
 */
void OWNextAlarm(void)
{
	if ((rc = TMNextAlarm(session, buffer)) < 0)
		fatal("TMNextAlarm");
}


/*----------------------------------------------------------------------
 *  Continue une recherche en cours sur le bus 1-wire
 */
void OWRom(short rom[])
{
	if ((rc = TMRom(session, buffer, rom)) < 0)
		fatal("TMRom");
}


/*----------------------------------------------------------------------
 *  Lit/écrit un octet sur le bus 1-wire
 */
short OWTouchByte(short byte)
{
	if ((rc = TMTouchByte(session, byte)) < 0)
		fatal("TMTouchByte");
	return rc;
}


/*----------------------------------------------------------------------
 *  Fixe le niveau du bus 1-wire
 */
short OWLevel(short operation, short levelMode, short primed)
{
	if ((rc = TMOneWireLevel(session, operation, levelMode, primed)) < 0)
		fatal("TMOneWireLevel");
	return rc;
}


/*----------------------------------------------------------------------
 *  Prépare une recherche de devices par famille
 */
void OWFamilySearchSetup(short family)
{
	if ((rc = TMFamilySearchSetup(session, buffer, family)) < 0)
		fatal("TMFamilySearchSetup");
}


/*----------------------------------------------------------------------
 *  Ouvre la session 1-wire
 */
void ouvreSession(void)
{
	short portNum, portType;
	int   preMsg;
	char  *msg;

	// récupère le port
	if (TMReadDefaultPort(&portNum, &portType) < 0)
	{
		rc = 0;
		fatal("TMReadDefaultPort : port par defaut non trouve");
	}

	// attend qu'il soit possible d'ouvrir la session
	preMsg = TRUE;
	for (;;)
	{
		rc = TMExtendedStartSession(portNum, portType, NULL);
		if (rc < 0)
		{
			fatal("TMExtendedStartSession");
		}
		if (rc > 0) break;
		if (preMsg)
		{
			fprintf(stderr, "Une autre application utilise le 1-wire...\n");
			preMsg = FALSE;
		}
	}
	session = rc;

	// setup du bus 1-wire
	rc = TMSetup(session);
	if (rc < 0)
		fatal("TMSetup");
	if (rc == 1) return;

	switch (rc)
	{
	case 0: msg = "echec du setup"; break;
	case 2: msg = "setup OK mais bus en court-circuit"; break;
	case 3: msg = "setup : le bus 1-wire n'existe pas"; break;
	case 4: msg = "TMSetup non supporte"; break;
	default: msg = "probleme setup inconnu"; break;
	};
	fatal(msg);
}


/*----------------------------------------------------------------------
 *  Ferme la session 1-wire
 */
void fermeSession(void)
{
	// ignore le retour
	TMEndSession(session);
}


/*----------------------------------------------------------------------
 *  Ecrit le message d'erreur sur stderr et quitte
 */
void fatal(char *texte)
{
	erreur(texte);
	fermeSession();
	fin(EXIT_FAILURE);
}


/*----------------------------------------------------------------------
 *  Ecrit le ROM courant dans un fichier (avec un espace derrière)
 */
void ecritRom(FILE *f)
{
	short rom[8];
	int   i;

	rom[0] = 0;
	OWRom(rom);
	for (i=7; i>=0; --i)
		fprintf(f, "%02x", rom[i]);
	fprintf(f, " ");
}


/*----------------------------------------------------------------------
 *  Attente de x ms
 */
void attente(ms)
{
	ulong t = GetTickCount() + ms;
	while (GetTickCount() < t)
		TMValidSession(session);
}


/*------------------------------------------------------------------------
 * Lit le scratchpad du DS18B20 courant
 */
int litDS18B20(uchar *mem)
{
	int   i;
	uchar CRCByte;
	short CRC8;
                         
	// sélectionne la sonde courante
	OWAccess();
	if (rc == 0) return EXIT_FAILURE;
         
	// envoie la commande de lecture mémoire
	OWTouchByte(0xbe);
                              
	// lit les 8 octets de la mémoire et calcule le CRC
	CRC8 = 0;
	for (i=0; i<8; ++i)   
	{
		OWTouchByte(0x0ff);
		mem[i] = (uchar) rc;
		CRC8 = TMCRC(1, &mem[i], CRC8, 0);
	}
   
	// lit et contrôle le CRC
	OWTouchByte(0x0ff);
	CRCByte = (uchar) rc;
	if (TMCRC(1, &CRCByte, CRC8, 0) != 0)
	{
		rc = 0;
		erreur("CRC invalide en lisant un scratchpad");
		return EXIT_FAILURE;
	}

	// c'est OK
	return EXIT_SUCCESS;
}


/*----------------------------------------------------------------------
 *  Commande "search"
 *  écrit sur stdout tous les ROM des devices trouvés sur le bus 1-wire
 *  si alarm est vrai, sélectionne seulement les devices en alarme
 */
int cmdeSearch(int alarm)
{
	ouvreSession();
	OWReset();
	if (alarm) OWFirstAlarm(); else OWFirst();
	OWFirst();
	while (rc)
	{
		ecritRom(stdout);
		if (alarm) OWNextAlarm(); else OWNext();
	}
	fermeSession();
	return EXIT_SUCCESS;
}


/*----------------------------------------------------------------------
 *  Commande "config"
 *  configure la précision de tous les DS18B20 sur le bus 1-wire
 */
int cmdeConfig(int precision)
{
	int config;

	ouvreSession();

	// calcule l'octet de configuration selon la précision demandée
	switch (precision)
	{
	case 9:  config = 0x00; break;
	case 10: config = 0x20; break;
	case 11: config = 0x40; break;
	case 12: config = 0x60; break;
	default:
		rc = 0;
		fatal("precision invalide");
	}

	// écrit la configuration dans le scratchpad
	OWReset();
	OWTouchByte(0xcc);		// cmd "skip ROM"
	OWTouchByte(0x4e);		// cmd "write scratchpad"
	OWTouchByte(0);			// TH (remplissage)
	OWTouchByte(0);			// TL (remplissage)
	OWTouchByte(config);	// configuration

	// écrit le scratchpad dans l'EEPROM
	OWReset();
	OWTouchByte(0xcc);		// cmd "skip ROM"
	OWLevel(LEVEL_SET, LEVEL_STRONG_PULLUP, PRIMED_BYTE);	// active le strong pullup
	OWTouchByte(0x48);		// cmd "copy scratchpad"
	attente(10);			// attente 10 ms
	OWLevel(LEVEL_SET, LEVEL_NORMAL, PRIMED_NONE);		// retire le strong pullup

	fermeSession();
	return EXIT_SUCCESS;
}


/*----------------------------------------------------------------------
 *  Cherche tous les DS18B20 sur le bus et exécute la fonction pour chacun
 */
void tousDS18B20(void (*fn)())
{
	short rom[8];

	// initialise la recherche
	OWFamilySearchSetup(DS18B20_FAMILY);
	for (;;)
	{
		// cherche le DS18B20 suivant et teste s'il en reste
		OWNext();
		if (rc == 0) break;

		// s'assure que c'est bien un DS18B20
		rom[0] = 0;
		OWRom(rom);
		if (rom[0] != DS18B20_FAMILY) break;

		// appelle la fonction à appliquer sur le DS18B20 courant
		(*fn)();
	}
}


/*----------------------------------------------------------------------
 *  Affiche le scratchpad du DS18B20 courant
 */
void dumpDS18B20(void)
{
	uchar mem[8];
	int   i;

	// lit le scratchpad
	if (litDS18B20(mem) != EXIT_SUCCESS)
		return;

	// affiche le ROM et le scratchpad
	ecritRom(stdout);
	for (i=0; i<8; ++i)
		printf("%02x ", mem[i]);
	puts("");
}


/*----------------------------------------------------------------------
 *  Commande "dump"
 *  Affiche le scratchpad de tous les DS18B20 sur le bus 1-wire
 */
int cmdeDump(void)
{
	// applique la fonction de dump à tous les DS18B20 trouvés
	ouvreSession();

	tousDS18B20(dumpDS18B20);

	fermeSession();
	return EXIT_SUCCESS;
}


/*----------------------------------------------------------------------
 *  Affiche le température du DS18B20 courant
 */
void tempDS18B20(void)
{
	uchar mem[8];
	float temperature;
	int   msk;
	short temp;

	// lit le scratchpad
	if (litDS18B20(mem) != EXIT_SUCCESS)
		return;

	// affiche le ROM
	ecritRom(stdout);

	// calcule la température selon la précision configurée
	// masque les bits non significatifs (le DS ne précise pas qu'ils sont à 0)
	switch (mem[4] & 0x60)
	{
	case 0x00: msk = 0x0f8; break;
	case 0x20: msk = 0x0fc; break;
	case 0x40: msk = 0x0fe; break;
	case 0x60: msk = 0x0ff; break;
	default: break; // ne peut pas arriver
   	}
   	temp = mem[1] << 8 | (mem[0] & msk);
	temperature = (float)(temp * 0.0625);

	// affiche la température
	printf("%f\n", temperature);
}


/*----------------------------------------------------------------------
 *  Commande "temp"
 *  lit la température de tous les DS18B20 sur le bus 1-wire
 */
int cmdeTemp(void)
{
	ouvreSession();

	// envoie une commande Convert T à tous les DS18B20
	// en activant le strong pullup pendant 750 ms
	OWReset();
	OWTouchByte(0xcc);	// cmd "skip ROM"
	OWLevel(LEVEL_SET, LEVEL_STRONG_PULLUP, PRIMED_BYTE);// active le strong pullup
	OWTouchByte(0x44);	// cmd "convert T"
	attente(750);		// attente 750 ms
	OWLevel(LEVEL_SET, LEVEL_NORMAL, PRIMED_NONE);		// retire le strong pullup

	// lit la température de tous les DS18B20 trouvés
	tousDS18B20(tempDS18B20);
	
	fermeSession();
	return EXIT_SUCCESS;
}


/*----------------------------------------------------------------------
 *  Tout commence ici...
 */
void main(int argc, char **argv)
{
	int precision;
	int alarm;

	// vérifie les arguments et appelle la bonne fonction
	if (argc == 1)
		usage();

	// search
	if (strcmp(argv[1], "search") == 0)
	{
		if (argc == 2)
			alarm = FALSE;
		else
		{
			if ((argc != 3) || strcmp(argv[2], "alarm") != 0)
				usage();
			alarm = TRUE;
		}
		fin(cmdeSearch(alarm));
	}

	// config <precision>
	if (strcmp(argv[1], "config") == 0)
	{
		if (argc == 2)
			precision = 12;
		else
		{
			if ((argc != 3) || (sscanf(argv[2], "%d", &precision) != 1))
				usage();
			if ((precision < 9) || (precision > 12))
			{
				rc = 0;
				fatal("la precision doit etre entre 9 et 12 bits");
			}
		}
		fin(cmdeConfig(precision));
	}

	// temp
	if (strcmp(argv[1], "temp") == 0)
	{
		if (argc != 2)
			usage();
		fin(cmdeTemp());
	}

	// dump
	if (strcmp(argv[1], "dump") == 0)
	{
		if (argc != 2)
			usage();
		fin(cmdeDump());
	}

	// erreur si autre chose
	usage();
}

[paaubert]

Voilà, j'ai reçu mes sondes, j'en ai déjà mis 11 en mode parasite et ça fonctionne nickel,alimentation de ma BDD avec Logtemp.
Reprise sur le schéma des valeurs de la station météo, des compteurs électriques et des sondes (gros job) enfin pour moi, j'ai pas mal transpiré, mais mon PC n'est pas aussi inondé que celui de Juju

http://www.boock.ch/meteo/pac/test_pac.php

Petite question, tu configures comment la résolution des sondes ?

A+

[juju]

bonjour

en réponse a la question ci dessus je prend deux décimales comme précision: 21.12° c'est déjà beaucoup et dans ce cas la conversion est très rapide et peut gourmande en ressource
je ne suis plus sur, de mémoire il existe deux drivers possible chez maxim:
les drivers timex et l'autre.. souvient plus du nom
mais toujours de mémoire avec l'install des pilotes, il se crée un répertoire, et la y a un utilitaire de test, la version JAVA je crois que l'utilitaire permet justement de configurer la résolution des sondes.
Je n'ai pas logtemp sous la main,mais je me demande si en fouillant dans les options il n'y a pas l'utilitaire de configuration
( tout ça oux XP SP3)

11bits c'est précis et environ 300milli secondes de temps de conversion
Alain

j'ai dans un coin la formule pour calculer le cop ( ça reste quand meme un coop theorique. Il faut environ un hiver de mesure pour adapter... et oui comme les loi d'eau.
temp entrée d'eau
temp sortie d'eau
débit d'eau
consommation électrique

Pour chauffer 1 litre d'eau de 1°C, il faut : 1.16 wh
Pour augmenter 1000 litres d'eau de 20°C, il faut :
1000 x 20 x 1.16 = 23200 wh = 23.2 Kwh
en eau pure, après en eau glicollée faut voir la doc de la PAC souvent il y a la courbe de perte de rendement

je peut chercher tout ça mais j'ai u merdier pas possible: excuses je viens de déménager!!

[juju]

re
sinon (sous XP 32)
avec le petit code:
http://solarihome.perso.sfr.fr/oneWire/oneWire2.exe
en ligne de commande:
oneWire2 config precision
attention , j'ai toujours configuré mes sondes une par une

oneWire2 temp > temp.txt dirige vers temp.txt en écrassant a chaque fois
oneWire2 temp >> temp.txt dirige vers temp.txt en mode append
oneWire2 search > toto.txt retourne le ROM id de tous les DS1820B

edit trouvé sur un autre site:

Tout comme sous Vista, par défaut la commande Exécuter n'apparaît pas dans le menu Démarrer de Windows 7.
Il faut taper Exécuter dans Rechercher pour y accéder ou utiliser le raccourci WIN + R

Si l'on veux faire apparaître cette commande de manière permanente dans le menu Démarrer :

- Clic-droit sur la Barre des tâches, puis sélectionner Propriétés.
- Dans l'onglet Menu Démarrer, cliquer sur Personnaliser et cocher Commande Exécuter, puis sur OK et Appliquer.

La commande Exécuter sera dorénavant affichée dans le menu Démarrer (sous Aide et Support).

[juju]

re

je viens de retrouver ça sur un cahier.
Impossible de savoir sur quel forum j'avais noté ccette formule basique, je me souvient quelle faisait partie d'une longue discutions

Le débit du circulateur est estimé par rapport au COP à 7/35°

Débit en m3/h = COP / (deltaT° x 1.163 / puissance consommé kWh
Formule simplifiée du COP immédiat :
COPi = débit x deltaT° x 1.163 / puissance consommée kWh

[paaubert]

Merci, je connais bien cette formule, c'est mon job

P= débit*deltaT
il faut prendre en cas la chaleur massique du liquide, mais comme c'est de l'eau
le résultat est en calorie, donc * 1.163 pour l'avoir en Watts.

A+

[juju]

bonsoir
je viens de passer sur ton site.
ça s’étoffe a une vitesse!
par contre je ne comprend pas quelque chose:
- sur le graph panneaux solaire on trouve le delta entrée/sortie panneaux. OK
- sur le graph solaire, on trouve la radiation solaire en W/M2 OK aussi
question?
As tu prévu un graphique de production solaire journalière, afin de savoir combien tu as produit.
peut être a tu des compteurs spécifique comme on trouve a Paris pour les immeubles qui font payer l'eau chaude a leur locataire.
une PT100 sur l'entrée
une PT100 sur la sortie
un compteur a eau a impulsion
un boitier electronique.
Devant le prix d'un tel outil, lorsque j'avais mon installation solaire je calculais la production comme çi dessous.La production était calculée a l'entrée de l’échangeur du ballon d'eau chaude, ainsi qu'a l'entrée du stock, et lors de l'injection directe dans le circuit chauffage ainsi les pertes en lignes n’étaient pas comptées.
ce qui compliquait les choses c'est que les débits n’étaient pas identique dans chaque branche, je devait espionner mon automate pour savoir quel électrovanne était enclenchée!!. bref une mécanique complexe. Mais une fois installée.ç tourne seul.
pour ceux qui passe par ici voila comment j’estimais ma production solaire thermique.
Cette discutions n'aurais pas de sens si je n'indiquait pas au lecteur ma méthode. j’espère quelle était a peu près juste.
si une personne en tire quelque chose, et bien tant mieux, j'aurais rendu un peu ce que l'on me donne ici, même si on est est peu loin de la météo.

La puissance est par définition l'énergie divisé par le temps.
Ou l'énergie est la puissance multipliée par le temps.
La puissance est W ou kW.
L'énergie en Wh ou kWh (qui signifie Watt x heure et non Watt par heure)

Si 100 litres d'eau passent avec un delta T de 10°C, ça représente une énergie (en Wh ou kWh) :
100 (litre) x 1,16 (Wh/litre/°C) x 10 (°C) = 1160 Wh

Si cette énergie est passée pendant 1 seconde (parce que le débit est de 100 litres/seconde), alors la puissance est :
1160 (Wh) / 1 = 1160 W

Si la même énergie est passée pendant 10 secondes (parce que le débit est de 10 litres/seconde), la puissance est :
1160 (Wh) / 10 = 116 W

j'utilisais ces formules...

Exemple :
Si j'ai un débit de 400 litres/heure et je mesure un delta T de 15°C.

Pour calculer la puissance :
En 1 heure, l'énergie collectée serait :
400 litres x 1,16 x 15 = 6960 Wh (ce qui veut dire une puissance de 6960 W pendant 1 heure)
donc la puissance instantanée est de 6960 W

Pour l'énergie :
Comme je ne fais des mesures que toutes les minutes, je cumule toutes les minutes la puissance de la dernière minute x 1 minute
Comme on veut des Wh, il faut multiplier par 1/60 (une minute exprimée en heure)
Imaginons qu'on ait la 1ère minute un delta T de 10, la 2ème de 15, puis la 3ème de 10.
La 1ère minute et la 3ème minute, la puissance est de 400 x 1,16 x 10 = 4640 W
La 2ème minute, la puissance est de 6960 W

La 1ère minute, l'énergie est de 4640 / 60 = 77,33 Wh
La 2ème minute, c'est 6960 / 60 = 116 Wh
La 3ème minute, c'est 77,33 Wh comme la 1ère minute

Donc pour les 3 minutes, l'énergie est la somme des 3 nombres, soit environ 271 Wh

Voilà, c'est pas compliqué... juste je ne suis pas sûr de bien expliquer.

enfin tout cela pour animer mon installation.
Pour vérifier que les données envoyées sur le net étaient correcte j'avais écrit une macro de comptage d’énergie dans mon automate.
tout en bas de la page.
http://alain-solaire.pagesperso-orange.fr/aide.html
Hors sujet
La j'ai déménagé, je repart a zéro, j’espère me refaire une petite installation, mais cette fois ci en capteur plan, vue qu'ici le soleil est généreux et ne descend pas trop bas sur l'horizon l'hiver.
Mais je suis en ville orienté sud est avec des masque a partir de 14H sinon j'ai une petite possibilité pour 4m2 orienté ouest a 45° au sol pour faire un compromis chauffage/ecs.
Mais pour l'instant ma priorité c'est la lutte: soucis de santé depuis 2007. et j'ai des doses de morphine importantes: donc beaucoup de mal a me concentrer, mais bon ça va s'arranger juste d la patience

[paaubert]

As tu prévu un graphique de production solaire journalière, afin de savoir combien tu as produit.

Pour ça j'ai un compteur de puissance qui en effet mesure le débit et le delta-t, mais il n'y a rien de prévu pour reprendre ces données et si apparement ton calcul me semble correct, c'est trop complexe (pour moi) de calculer ça en PHP.

Voilà le compteur d’énergie que j'ai mis sur les conduites des capteurs solaire et de ma PAC, quand j'ai construit, je n'avais pas encore pensé reprendre ça sur un PC

https://sensus.com/documents/10157/4062 ... E_0002.pdf

il y en a à vendre sur Ebay
http://www.ebay.fr/itm/SENSUS-POLLUCOM- ... 3f2b4ef2bc

Il me semble l'avoir payé à l'époque autour des 80 euros.

A+

[paaubert]

J'ai réfléchi à ton idée de calculer l’énergie accumulée, c'est effectivement simple en créant une vue dans la bdd qui calcul pour chaque enregistrement la puissance pendant ce laps de temps.
Mais, gros problème :

Quand il y production de chaleur, pas de soucis, le calcul se fait correctement, mais quand le delta-t passe par exemple en dessous de 5°C, la pompe s'arrête et il n'y a plus de production MAIS, car il y a toujours un mais, les tubes vont rester un bon moment avec une différence de température, et là le calcul va continuer d'accumuler de la puissance alors qu'il n'y en a plus.

Me suis-je bien fait comprendre

A+