Stylo 3D, Allumer une led au bout d'un temps donné.

Bonjour;
Je me présente étudiant en Terminale STI2D et notre projet et de réaliser un stylo 3D (Pour plus d'informations faites une recherche sur : [www.lestylo3d.com] c'est vraiment un projet passionnant). Nous sommes dans une phase de recherche de solutions et je suis face à quelques problèmes...
J'aimerais en fait allumer une led au bout d'un certains temps (1000h plus exactement) pour indiquer à l'utilisateur qu'une maintenance de la tète du stylo dois être réalisé.

"l'idée" :
- Dès la détection d'utilisation : mise en mémoire de la date.
- Toutes les secondes : mise à jour du compteur = date - date de départ
- Si compteur > au seuil ==> allumage LED.
- Si plus d'utilisation on enregistre plus compteur.

Premièrement pour détecter l'utilisation de la tète on m'avait dit d'utiliser un capteur de courant, seul bémol c'est que ce celui que je pensais utiliser est que pour du courant alternatif et j'ai du continu... on m'en a proposer un second celui-ci : [www.gotronic.fr] mais je n'arrive pas à savoir si il marche pour du continu ou pas. Ou bien si il existe vraiment des capteurs de courant pour du courant continu...

Secondo, je crois que j'ai un petit soucis de compréhension...
Mon but est au bout d'un certain temps d'utilisation une led s'allumer. J'ai donc une RTC qui va me faire un comptage du temps, mais elle va le faire en permanence en fait ? Et lorsque l'on détecte l'utilisation ça viendra lire les valeurs dans le module RTC. On soustrait et on accumules en mémoire.
En soit nous allons compter les impulsions de la RTC, et y incrémenter dans le compteur qui lorsqu'il atteint un seuil déclenche une action, qui sera ici "Allumer la LED".
Voila ce que j'avais compris mais j'arrive pas vraiment à réellement comprendre le principe... si quelqu'un pourrait m'expliquer ce serait vraiment sympa.

ps : Sinon il y a aussi ça mais je sais pas si dans mon cas ça marche : [www.maximintegrated.com]

merci à vous de votre patience, c'est un peu la cafouillage ^^

Petit up

salut
a mon humble avis,; au lieu d'utiliser un capteur de courant, mieux vaut faire le comptage des heures que quand le stylo(resistance + circuit) est alimenté.
tu peux le faire avec un PIC tout petit, style 16f84a , y a une eeprom pour sauvegarder tes données plus qu'il n'en faut.

http://fabrice.sincere.pagesperso-orange.fr/cm_electronique/projet_pic/aidememoire/eeprom84/eeprom.htm

si t'es pas bon en assembleur, tu peux faire du C

Si tu part sur un stylo a base arduino c'est pas super compliqué . Je te conseil un module rtc pour le temps et une carte sd soit par un port sd ou directement souder a l'arduino (puisqu'elle est pas sencé bouger meme une 128mo suffit)

Tu cree un fichier texte dessus . Puis tu demande a larduino de rajouter le temps prit par le rtc a celui de la sd. Puis de le rerecrir sur la sd des que la valeur change .

Ca permetra d"avoir un compteur a jour perpetuellement .
Pour allumer une led un simple if valeur sd =100 alors allumer led .(c'est un exemple grossier lol )


Sinon il me semble que les module rtc(type ds1307) ont une partie de stockage de donné (quelques byte de memoire morte) Ce qui te permetrais de ne pas s'encombrer de sd(cela doit marcher mais je n'ai pas encore utilisé cette fonction

Edited 1 time(s). Last edit at 03/17/2014 08:29PM by One-T.

oui possible mais c'est énorme juste pour un petit compteur,je trouve!

Merci à tous pour toutes vos réponses.

Alors déja oui je vais utiliser une RTC grove (Basé sur la RTC 1307) pour stocker nous allons utiliser les 56 Mo de Ram totalement suffisant disponible sur la mémoire internet de la RTC.
Aujourd'hui GROS CHANGEMENT de la part du prof (enfin pas si gros que ça ^^) on ne va plus utiliser un capteur de courant.

Nous allons utiliser un capteur ILS, qui lorsque l'on retirera le stylo de son socle le mettra en marche (Mais ça ce n'est pas ma partie) et qui déclenchera le comptage du temps avec la RTC grove(Par contre la si). Une fois reposer sa arrêtera le comptage et mettra en mémoire le temps d'utilisation dans la ram de la rtc. Voila les directives de mon prof j'avoue que je suis un peu perdu...
Enfin je comprends le principe mais le plus dur pour moi est de le réaliser étant totalement nul en électronique et programmation je suis vraiment perdu on va dire.. .

Merci de votre aide.

non non, non!!

si tu utilise ARDUINO, il y a un clock a l'interieur + de la memoire eeprom.

pourquoi uiliser une clock externe pour compter des secondes, si tu t'en fout des dates.... ! va pas mettre un super calculateur et une horlogie atomique pour un stylo !!

2 instructions pour faire tout ca et un programe "con!con!":

1/ utilise l'ecriture eeprom pour ecrire en memoire (ca reste quand c'est eteint) :
#include
EEPROM.write(addr, val);
adr -> 0 .. 512, 8bits

pour codé en 8 bits

une zone secondes 0-60
une minutes 0-60
une heure 0-100
une centaines heure 0-10

donc on utilisera 4 octet de 8bits

int adr_sec=0;
int adr_min=1;
int adr_heu=2;
inr adr_cen=3;


2/ utilise la fonction delay pour attendre 1secondes
delay(1000);

-----------
programme algo

boucle
  test si 1000h alors
    allume la diode
    if bouton remise a zero alors
        ecrit dans l'eeprom 0 0 0 0
    fin de si
  sinon 
     si contact utilisation alors
         incremente seconde;
         ecrie de l'eeprom les bonnes valeur
     fin de si
     attend 1 seconde
  fin de si
  
fin de boucle


---------------
#include EEPROM.h
int pin_led = 13; 
int pin_utilisation =12;  // ton contact ILS, qui donnera du + quand c'est ok
int pin_remise_a_zero =11; //(mettre interupteur entre + et pin 11 , on peut rajouter un pulldown(resistance 100ko à moins sur pin11))          
int adr_sec=0; // sec
int adr_min=1; // min
int adr_heu=2; // h
int adr_cen=3; // centaines h

byte sec,min,heu,cen;

void setup()
{
  pinMode(pin_led , OUTPUT);      // led
  pinMode(pin_utilisation , INTPUT);      // pin contact utilisation
  pinMode(pin_remise_a_zero , INTPUT);      // pin remise a zero
}

void loop()
{
  if (EEPROM.read(adr_cen)==10) // lit si 10x100h =1000h
  {
	digitalWrite(pin_led, HIGH);
	if (digitalRead(pin_remise_a_zero)==HIGH)
	{
		// remise a zero
	EEPROM.write(adr_sec,0);
	EEPROM.write(adr_min,0);
	EEPROM.write(adr_heu,0);
	EEPROM.write(adr_cen,0);
	}
  }
  else
  {
	if (digitalRead(pin_utilisation) ==HIGH) // si utilisation
	{
    	  sec=EEPROM.read(adr_sec)+1;
	  min=EEPROM.read(adr_min);
	  heu=EEPROM.read(adr_heu);
	  cen=EEPROM.read(adr_cen);

    	  if (sec==60) // + de 60s -> +1min
 	  {
		sec=0;
		min++;
	  }
    	  if (min==60) // + de 60min -> +1h
	  {
		min=0;
		heu++;
	  }
  	  if (heu==100)  // + de 100h -> +1centaine d'heure
	  {
		heu=0;
		cen++;
	  }

		// sauvegarde
	  EEPROM.write(adr_sec,sec);
	  EEPROM.write(adr_min,min);
	  EEPROM.write(adr_heu,heu);
	  EEPROM.write(adr_cen,cen);
	  delay(1000);                  //  1 sec
	}
   }
  
}

Edited 4 time(s). Last edit at 03/20/2014 04:03AM by revolution07.

Bien joué solution plus complexe mais cela ezvite l'ajout d'un composant .j'avais pensé a la fonction millis pour compter les secondes

oui, y a pas si longtemps on aurai utilisé 1 ne555, quelques compteur 74lsxxx, 3 composants, et c'était jouer.
maintenant, faut un super calculateur pour faire clignoté une led!

Merci beaucoup pour l'aide et le programme je vais tester cette solution mon prof refusera surement mais on sait jamais ^^"

Par contre j'ai un problème avec cette ligne "EEPROM.read(adr_min,0);" arduino m'affiche "no matching function for call to EEPROMClass::read(int&, int)

J'ai rajouté Serial.begin(9600); pour pouvoir lire dans le serial port mais bien sur je suis tellement doué que je n'ai rien !

Merci

Edited 1 time(s). Last edit at 03/20/2014 03:56AM by SGRmetrage.

oups, me suis trompé! il est tard hier soir!!

c'est pas read, mais WRITE !!!

je vais rectifié!

serial begin, c'est pour ouvrir le port

donc tu l'ouvre ok, mais si tu veux y envoyé des données pour les lire sur ton pc, ben faut lui envoyer des données!

Serial.begin(9600);
Serial.println("secondes :");
Serial.println(EEPROM.read(adr_sec), DEC); // pour afficher les secondes

Serial.println("minutes:");
Serial.println(EEPROM.read(adr_min), DEC); // pour afficher les minutes

.....
(vais pas tout te faire quand meme!)

Ah ouiii merci pour la rectification j'était entrain de le changer quand j'ai vu votre message j'ai pu vérifier ce que je faisais

Bon comme vous pouvez le voir la programmation et moi ça fais deux...
J'ouvre le moniteur série et il m'affiche secondes = 105 , minutes = 255 et heures = 255
Je comprends pas trop pourquoi il reste bloqué sur ces valeurs..

Parler moi comme si j'étais un abrutis ^^ Merci du coup de pouce!

Edited 1 time(s). Last edit at 03/20/2014 04:47AM by SGRmetrage.

Quote
revolution07
oui, y a pas si longtemps on aurai utilisé 1 ne555, quelques compteur 74lsxxx, 3 composants, et c'était jouer.
maintenant, faut un super calculateur pour faire clignoté une led!

En lisant le titre, j'ai pensé la même chose : NE555 ! Dans le même temps un Pic ou un miniAT ne coute pas beaucoup plus cher et permet de simplifier les choses ... on a changé d'époque !

Et oui mais je suis bloqué avec soit cette solution sois la RTC !

Je vais continuer avec ce programme mais mon prof veut que j'utilise la RTC... Merci en tout qu'a pour le temps que vous avez pris pour écrire ce programme et pour les explications.

Voici mon programme avec la RTC qui marche bien

#include 
#include "DS1307.h"

DS1307 clock;//define a object of DS1307 class
void setup()
{
	Serial.begin(9600);
	clock.begin();
	clock.fillByYMD(2014,2,6);// 06 Fevrier,2014
	clock.fillByHMS(17,50,30);//13:53 30"
	clock.fillDayOfWeek(THU);//Jeudi
//	clock.setTime();//write time to the RTC chip
}
void loop()
{
	printTime();
}


/*--------------------------------------------------* 
 * Fonction: Affiche le temps sur le moniteur série *
 *--------------------------------------------------*/
void printTime()
{
	clock.getTime();
        
        Affiche_JOUR();
	Serial.print("	");        

        Affiche_JMA();
	Serial.println(" ");
       
        Affiche_HMS();
	Serial.print(" ");
        
        delay(500);
        
}

void Affiche_HMS()
    {
     Serial.print(clock.hour, DEC);
     Serial.print(":");
     Serial.print(clock.minute, DEC);
     Serial.print(":");
     Serial.print(clock.second, DEC);
    }

void Affiche_JOUR()
    {
   	switch (clock.dayOfWeek)// Friendly printout the weekday
	     {
		case MON:
		  Serial.print("LUNDI ");
		  break;
		case TUE:
		  Serial.print("MARDI ");
		  break;
		case WED:
		  Serial.print("MERCREDI ");
		  break;
		case THU:
		  Serial.print("JEUDI ");
		  break;
		case FRI:
		  Serial.print("VENDREDI ");
		  break;
		case SAT:
		  Serial.print("SAMEDI ");
		  break;
		case SUN:
		  Serial.print("DIMANCHE ");
		  break;
             }
    }
    
void Affiche_JMA()	
    {
     Serial.print(clock.dayOfMonth, DEC);
     Serial.print("/");
     Serial.print(clock.month, DEC);
     Serial.print("/");
     Serial.print(clock.year+2000, DEC);
     Serial.print(" ");

    }

Notre soucis est ici de stocker les informations sur la Ram donc plus exactement :

Quote

Nous allons utiliser un capteur ILS, qui lorsque l'on retirera le stylo de son socle le mettra en marche (Mais ça ce n'est pas ma partie) et qui déclenchera le comptage du temps avec la RTC grove(Par contre la si). Une fois reposer sa arrêtera le comptage et mettra en mémoire le temps d'utilisation dans la ram de la rtc. Voila les directives de mon prof j'avoue que je suis un peu perdu...

Je pense qu'apres c'est bien trop se compliquer la vie . Si ta besoin du rtc ok

Mais dans ton programme cela ne sert strictement a riende connaitre la date les heures etc .

Tu peux seulement te servir des secondes voir des minutes . Tout le reste est superflux

Je dois attendre 1000h donc oui à la fin tout va ètre converti en seconde c'est plus simple mais de base j'ai besoin des minutes et des heures. Merci de la remarque !

Je pense qu'il serait plus simple de stocker le comptage du temps dans l'EEPROM d'arduino,

Mais la question que je me pose étant donné que écrire dans l'EEPROM est limité à 100 000 fois cela va t-il être suffisant ? Ou alors il vaut mieux que je stocke dans la mémoire RAM de la RTC même si cela est plus compliqué.

Bonjour;
Petit up j'ai toujours besoin d'aide et oui

Donc voila le programme que j'ai fait pour faire fonctionner la RTC :

#include 
#include "DS1307.h"

DS1307 clock;//define a object of DS1307 class
void setup()
{
	Serial.begin(9600);
	clock.begin();
	clock.fillByYMD(2014,2,6);// 06 Fevrier,2014
	clock.fillByHMS(17,50,30);//13:53 30"
	clock.fillDayOfWeek(THU);//Jeudi
//	clock.setTime();//write time to the RTC chip
}
void loop()
{
	printTime();
}


/*--------------------------------------------------* 
 * Fonction: Affiche le temps sur le moniteur série *
 *--------------------------------------------------*/
void printTime()
{
	clock.getTime();
        
        Affiche_JOUR();
	Serial.print("	");        

        Affiche_JMA();
	Serial.println(" ");
       
        Affiche_HMS();
	Serial.print(" ");
        
        delay(500);
        
}

void Affiche_HMS()
    {
     Serial.print(clock.hour, DEC);
     Serial.print(":");
     Serial.print(clock.minute, DEC);
     Serial.print(":");
     Serial.print(clock.second, DEC);
    }

void Affiche_JOUR()
    {
   	switch (clock.dayOfWeek)// Friendly printout the weekday
	     {
		case MON:
		  Serial.print("LUNDI ");
		  break;
		case TUE:
		  Serial.print("MARDI ");
		  break;
		case WED:
		  Serial.print("MERCREDI ");
		  break;
		case THU:
		  Serial.print("JEUDI ");
		  break;
		case FRI:
		  Serial.print("VENDREDI ");
		  break;
		case SAT:
		  Serial.print("SAMEDI ");
		  break;
		case SUN:
		  Serial.print("DIMANCHE ");
		  break;
             }
    }
    
void Affiche_JMA()	
    {
     Serial.print(clock.dayOfMonth, DEC);
     Serial.print("/");
     Serial.print(clock.month, DEC);
     Serial.print("/");
     Serial.print(clock.year+2000, DEC);
     Serial.print(" ");

    }

Nous allons utiliser un capteur ILS, qui lorsque l'on retirera le stylo de son socle le mettra en marche (Mais ça ce n'est pas ma partie) et qui déclenchera le comptage du temps avec la RTC grove(C'est donc ça que je veux réaliser). Une fois reposer, le comptage s'arrètera et mettra en mémoire le temps d'utilisation dans la ram de la rtc(Mon prof m'a parlé de stocker de l'EEPROM d'arduino car c'est plus simple mais ce qui m'embète c'est tout de mème la limitation de 100 000 écritures). Voila les directives de mon prof j'avoue que je suis un peu perdu dans la réalisation de cette seconde partie..


Dans l'hypothèse ou j'utiliserais l'EEPROM je pense partir de ce programme :

#include 

// the current address in the EEPROM (i.e. which byte
// we're going to write to next)
int addr = 0;

void setup()
{
}

void loop()
{
  // need to divide by 4 because analog inputs range from
  // 0 to 1023 and each byte of the EEPROM can only hold a
  // value from 0 to 255.
  int val = analogRead(0) / 4;
  
  // write the value to the appropriate byte of the EEPROM.
  // these values will remain there when the board is
  // turned off.
  EEPROM.write(addr, val);
  
  // advance to the next address.  there are 512 bytes in 
  // the EEPROM, so go back to 0 when we hit 512.
  addr = addr + 1;
  if (addr == 512)
    addr = 0;
  
  delay(100);
}

Vous allez me prendre pour un abrutis mais dois-je le remplir de cette manière ?
"EEPROM.write(clock.hour,hour);
EEPROM.write(clock.minute,minu);
EEPROM.write(clock.second,sec);"

J'ai beaucoup de mal justement dans la programmation.. je tâtonne donc pour essayer .
Merci d'avance de votre aide et du temps que vous prenez pour répondre à mes messages(qui doivent parfois vous rendre dingue), pour les explications et j'en passe! Merci infiniment.

Edited 1 time(s). Last edit at 03/26/2014 01:39PM by SGRmetrage.

Je bloque sur cette partie de mon programmme :

// Sauvegarde
   EEPROM.write(clock_hour,hour);
   EEPROM.write(clock_minute,minu);
   EEPROM.write(clock_second,sec);

  // advance to the next address.  there are 512 bytes in 
  // the EEPROM, so go back to 0 when we hit 512.
  clock_hour = clock_hour + 1;
  if (clock_hour == 512)
    clock_hour = 0;
  
  delay(100);

Je comprends pas la partie

// advance to the next address.  there are 512 bytes in 
  // the EEPROM, so go back to 0 when we hit 512.
  clock_hour = clock_hour + 1;
  if (clock_hour == 512)
    clock_hour = 0;
  
  delay(100);

Enfaite je suis réellement totalement perdu... je comprends vraiment plus..

Bonsoir;
Alors voila quelques avancées cette semaine, des idées un peu de programmation ^^"

J'ai déja repris mon programme de la RTC, j'y ai ajouté un bouton qui lorsque l'on appuis dessus fais le calcul du nombre d'heures, de minutes et de secondes et converti tout en secondes et affiche le total sur el moniteur série.
Voila la bète :

#include 

#include 
#include "DS1307.h"

double SEC;
const int buttonPin = A2;
int buttonState = 0;  



DS1307 clock;//define a object of DS1307 class
void setup()
{
	Serial.begin(9600);
	clock.begin();
	clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
	clock.fillByHMS(17,50,30);//13:53 30"
	clock.fillDayOfWeek(THU);//Jeudi
  	clock.setTime();//write time to the RTC chip
}
void loop()
{
	printTime();
        calcul_SEC();
        buttonState = digitalRead(buttonPin);
}


/*--------------------------------------------------* 
 * Fonction: Affiche le temps sur le moniteur série *
 *--------------------------------------------------*/
void printTime()
{
	clock.getTime();
        
        Affiche_JOUR();
	Serial.print("	");        

        Affiche_JMA();
	Serial.println(" ");
       
        Affiche_HMS();
	Serial.println(" ");
        
        delay(500);
        
}

void Affiche_HMS()
    {
     Serial.print(clock.hour, DEC);
     Serial.print(":");
     Serial.print(clock.minute, DEC);
     Serial.print(":");
     Serial.print(clock.second, DEC);
    }

void Affiche_JOUR()
    {
   	switch (clock.dayOfWeek)// Friendly printout the weekday
	     {
		case MON:
		  Serial.print("LUNDI ");
		  break;
		case TUE:
		  Serial.print("MARDI ");
		  break;
		case WED:
		  Serial.print("MERCREDI ");
		  break;
		case THU:
		  Serial.print("JEUDI ");
		  break;
		case FRI:
		  Serial.print("VENDREDI ");
		  break;
		case SAT:
		  Serial.print("SAMEDI ");
		  break;
		case SUN:
		  Serial.print("DIMANCHE ");
		  break;
             }
    }
    
void Affiche_JMA()	
    {
     Serial.print(clock.dayOfMonth, DEC);
     Serial.print("/");
     Serial.print(clock.month, DEC);
     Serial.print("/");
     Serial.print(clock.year+2000, DEC);
     Serial.print(" ");
    }
    
 void calcul_SEC()
     {
    buttonState = digitalRead ( buttonPin ) ; 
     if (buttonState == HIGH) 
     {
       SEC= ((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
       Serial.println(SEC);
     
     }
     }

Il faudrait donc que lorsque j'appuie sur le bouton il stocke le temps en seconde dans l'EEPROM. En fait plus précisément nous allons utiliser un capteur ILS, qui lorsque l'on retirera le stylo de son socle le mettra en marche (Mais ça ce n'est pas ma partie) et qui déclenchera le comptage du temps avec la RTC grove(C'est donc ça que je veux réaliser). Une fois reposer, le comptage s’arrêtera et mettra en mémoire le temps d'utilisation dans la ram de la rtc.
Pour le moment le capteur ILS est remplacé par le bouton, il faudrait donc lorsque j'appuie que ça stocke en mémoire sur l'EEPROM et à chaque nouvelle utilisation que ça face un cumule du temps... je sais pas si vous arrivez à me suivre.

Voila le programme de l'EEPROM que j'ai commencé à remplir mais je sais pas trop comment..

/*
 * EEPROM Write
 *
 * Stores values read from analog input 0 into the EEPROM.
 * These values will stay in the EEPROM when the board is
 * turned off and may be retrieved later by another sketch.
 */
#include 

int clock_hour=0;
int clock_minute=0;
int clock_second=0;

byte sec,minu,hour;

/* the current address in the EEPROM (i.e. which byte
 we're going to write to next)*/

void setup()
{
}

void loop()
{
  // need to divide by 4 because analog inputs range from
  // 0 to 1023 and each byte of the EEPROM can only hold a
  // value from 0 to 255.
  int val = analogRead(0) / 4;
  
  // write the value to the appropriate byte of the EEPROM.
  // these values will remain there when the board is
  // turned off.
   
   // Sauvegarde
   EEPROM.write(clock_hour,hour);
   EEPROM.write(clock_minute,minu);
   EEPROM.write(clock_second,sec);

  // advance to the next address.  there are 512 bytes in 
  // the EEPROM, so go back to 0 when we hit 512.
addr = addr + 1;
  if (addr == 512)
    addr = 0;
  
  delay(100);
}

Merci d'avance pour votre patience et votre aide.