Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Qui propgramme en C ou C++ PIC 16F877 ? 19.02.24 19:19
Bonjour à tous 73!
Dans le cadre du développement de mon coupleur d'antenne Lévy doté d'un gros CV Jennings motorisé par un moteur pas à pas et piloté à distance (le coupleur étant à l'extérieur du QRA), j'ai réalisé une interface et carte puissance plus affichage LCD me donnant la position du CV à base d'un PIC 16F877 pour le µ Contrôleur et une carte puissance avec un double pont en H L298N .
Tout fonctionne en simulation et en réel .
Ce que je voudrais c'est mettre en sommeil le µ Contrôleur de façon à l'alimenter avec une batterie de sauvegarde entre deux utilisations afin de garder en mémoire la position du CV et son affichage avec un réveil du µ Contrôleur dès que j'actionne la manette de pilotage du CV .
La consommation du PIC tombant à 2µA en sommeil contre plusieurs mA en fonction .
Quelqu'un a t'il déjà utilisé les fonctions Sleep() et Wake_Up() en C sur µContôleur PIC ?
Bien entendu j'enverrai le programme en C pour en discuter si je trouve la ou les bonnes personnes répondant à ma recherche .
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 10:23
Réponse partielle à la question
F4FIT a écrit:
Quelqu'un a t'il déjà utilisé les fonctions Sleep() et Wake_Up() en C
Quand j'ai des doutes, je pose la question à ChaGPT qui est très fort en code. Voici sa réponse :
En C sous Linux, vous pouvez utiliser les fonctions système sleep() et wakeup() pour suspendre l'exécution de votre programme pendant un certain temps puis le réveiller. Cependant, en réalité, il n'existe pas de fonction wakeup() dédiée comme celle que vous avez mentionnée. Au lieu de cela, vous devez utiliser un mécanisme de synchronisation tel que les signaux ou les threads pour réaliser cela.
Voici un exemple simple utilisant des signaux pour réveiller un processus après un certain temps de sommeil :
// Handler for the alarm signal void alarm_handler(int signum) { // Nothing to do here, just interrupting sleep }
int main() { // Registering the alarm handler for SIGALRM signal(SIGALRM, alarm_handler);
printf("Sleeping for 5 seconds...\n"); // Sleep for 5 seconds sleep(5);
printf("Woke up!\n");
return 0; }
Dans cet exemple, nous utilisons sleep(5) pour mettre le programme en pause pendant 5 secondes. Pendant ce temps, le programme ne fait rien d'autre. Une fois les 5 secondes écoulées, le programme se réveille automatiquement.
Remarquez que dans cet exemple, le programme se réveille automatiquement après le délai spécifié. Si vous souhaitez un réveil basé sur une condition particulière ou une interaction utilisateur, vous devrez utiliser d'autres mécanismes de synchronisation comme les threads.
Mon avis :
Le problème c'est que toi tu veux :
mettre en sommeil le µ Contrôleur entre deux utilisations
réveiller le µ Contrôleur dès que tu actionnes la manette de pilotage du CV .
sleep() ne va pas endormir le µ-contrôleur mais le thread et ça consommera toujours
Une piste : pendant que ton µ-contrôleur tourne, tu peux produire un shutdown(). Ensuite tu redémarreras le µ-contrôleur par un dispositif mécanique sur le CV.
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 11:53
Bonjour François !
Voici mon code en C qui fonctionne en réel . Je veux mettre le µ Contrôleur en sommeil pour que hors utilisation qu'il consomme moins pour avoir une sauvegarde grâce à une batterie , ce qui évitera qu'à chaque redémarrage , l'engin aille se réinitialiser en butée fin de course bas .
Mon code est sous "BoostC " avec l'ide SourceBoost .
Code:
#include <system.h> #include <flash.h> #ifdef _PIC16 #ifndef _PIC16F877 #warning "This code is configured for PIC16F877 or PIC18F452. If you use other targets you may need to reconfigure the project." #endif #elif _PIC18 #ifndef _PIC18F452 #warning "This code is configured for PIC16F877 or PIC18F452. If you use other targets you may need to reconfigure the project." #endif #endif
#define LCD_ARGS 2, /* Interface type: mode 0 = 8bit, 1 = 4bit(low nibble), 2 = 4bit(upper nibble) */ \ 1, /* Use busy signal: 1 = use busy, 0 = use time delays */\ PORTB, TRISB, /* Data port and data port tris register */ \ PORTB, TRISB, /* Control port and control port tris register */ \ 2, /* Bit number of control port is connected to RS */ \ 1, /* Bit number of control port is connected to RW */ \ 0 /* Bit number of control port is connected to Enable */
#include <lcd_driver.h> // include the LCD template code
unsigned int j; // N° sequence unsigned int rec; // N° sequence desengagement fin de course unsigned int speed = 1; // vitesse moteur (temps stepp milli secondes) unsigned int speed2 = 5; // vitesse moteur init (temps stepp milli secondes) unsigned int speed3 = 15; unsigned int back = 20; // Nbre cycles moteur Desengagement fin de course
void main() { //Configure port A //trisa = 0x00; adcon1 = 0b00011111;
//Configure port B //trisb = 0x00;
//Configure port C trisc = 0xFF;
//Configure port D trisd = 0x00;
//Configure port E trise = 0x00;
/////////////////////////////////////////
//Initialize port A porta = 0x00;
//Initialize port B //portb = 0x00;
//Initialize port C portc = 0x00;
//Initialize port D portd = 0x00;
//Initialize port E porte = 0x00;
lcd_setup(); lcd_gotoxy(0,0); lprintf( "F4FIT 10/20/24" ); lcd_gotoxy(0,1); lprintf( "Emmanuel Charp" ); delay_ms(500); lcd_clear(); lcd_gotoxy(4,0); lprintf( "STAND BY" ); delay_ms(100); //////////////////////////////INITIALISATION///////////////////////////////////////// /////////////////////Rotation jusq'a origine machine///////////////////////////////// if (portc==0) { while (portc==0) { { portd = 0b00001001; //sequence 3 stepp motor down lcd_gotoxy( 0,0 ); lprintf( "-INITIALISATION-" ); //Sens Trigo delay_ms(speed2); if (portc == 8) break; } { portd = 0b00000101; //sequence 2 stepp motor down lcd_gotoxy( 0,0 ); lprintf( "-INITIALISATION-" ); //Sens Trigo delay_ms(speed2); if (portc == 8) break; } { portd = 0b00000110; //sequence 2 stepp motor down lcd_gotoxy( 0,0 ); lprintf( "-INITIALISATION-" ); //Sens Trigo delay_ms(speed2); if (portc == 8) break; } { portd = 0b00001010; //sequence 1 stepp motor down lcd_gotoxy( 0,0 ); lprintf( "-INITIALISATION-" ); //Sens Trigo delay_ms(speed2); if (portc == 8) break; } }
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ while (portc==2) { //////////////////////////////////////////////////////////////////////////////// portd = 0b00001001; //sequence 3 stepp motor down j = j-1; lcd_gotoxy( 0,0 ); lprintf( "<-FREQUENCY DOWN" ); //Sens Trigo lcd_gotoxy(5,1); lprintf ("%d ",j) ; delay_ms(speed); if (portc==0) break;
if (portc==10) //Fin de course down { /////////////////////////////////////////////////////////////////////////////// delay_ms(10); // Temps d'arret avant inversion du sens de rotation // Desengagement fin de course Sens Horaire for(rec=0;rec<back;rec++) // { // portd = 0b00001010; //// delay_ms(speed); // // portd = 0b00000110; //// delay_ms(speed); // // sequences up 1 portd = 0b00000101; //// delay_ms(speed); // // portd = 0b00001001; //// delay_ms(speed); // // } portd = 0b00000000; // STOP Moteur ///////////////////////////////////////////////////////////////////// lcd_clear(); lcd_gotoxy( 0,0 ); lprintf( "STOP LIMIT LOW !" ); lcd_gotoxy( 0,1 ); lprintf( " INIT " ); j=0; break; } ///////////////////////////////////////////////////////////////////////////////////////// portd = 0b00000101; //sequence 2 stepp motor down j = j-1; lcd_gotoxy( 0,0 ); lprintf( "<-FREQUENCY DOWN" ); //Sens Trigo lcd_gotoxy(5,1); lprintf ("%d ",j) ; delay_ms(speed); if (portc==0) break; if (portc==10) { //Fin de course down //////////////////////////////////////////////////////////////////////////////////////// delay_ms(10); // Temps d'arret avant inversion du sens de rotation // Desengagement fin de course Sens Horaire for(rec=0;rec<back;rec++) // { // portd = 0b00001010; //// delay_ms(speed); // // portd = 0b00000110; //// delay_ms(speed); // // sequences up 2 portd = 0b00000101; //// delay_ms(speed); // // portd = 0b00001001; //// delay_ms(speed); // // } // portd = 0b00000000; // STOP Moteur //////////////////////////////////////////////////////////////////////////////////////// lcd_clear(); lcd_gotoxy( 0,0 ); lprintf( "STOP LIMIT LOW !" ); lcd_gotoxy( 0,1 ); lprintf( " INIT " ); j=0; break; } ////////////////////////////////////// portd = 0b00000110; //sequence 1 stepp motor down j = j-1; lcd_gotoxy( 0,0 ); lprintf( "<-FREQUENCY DOWN" ); //Sens Trigo lcd_gotoxy(5,1); lprintf ("%d ",j) ; delay_ms(speed); if (portc==0) break; if (portc==10) //Fin de course down { ///////////////////////////////////////////////////////////////////// delay_ms(10); // Temps d'arret avant inversion du sens de rotation // Desengagement fin de course Sens Horaire for(rec=0;rec<back;rec++) // { // portd = 0b00001010; //// delay_ms(speed); // // portd = 0b00000110; //// delay_ms(speed); // // sequences up 3 portd = 0b00000101; //// delay_ms(speed); // // portd = 0b00001001; //// delay_ms(speed); // // } // portd = 0b00000000; // STOP Moteur
///////////////////////////////////////////////////////////////////// lcd_clear(); lcd_gotoxy( 0,0 ); lprintf( "STOP LIMIT LOW !" ); lcd_gotoxy( 0,1 ); lprintf( " INIT " ); j=0; break; } ////////////////////////////////////// portd = 0b00001010; //sequence 0 stepp motor down HOME j = j-1; lcd_gotoxy( 0,0 ); lprintf( "<-FREQUENCY DOWN" ); //Sens Trigo lcd_gotoxy(5,1); lprintf ("%d ",j) ; delay_ms(speed); if (portc==0) break; if (portc==10) //Fin de course down { ///////////////////////////////////////////////////////////////////// delay_ms(10); // Temps d'arret avant inversion du sens de rotation // Desengagement fin de course Sens Horaire for(rec=0;rec<back;rec++) // { // portd = 0b00001010; //// delay_ms(speed); // // portd = 0b00000110; //// delay_ms(speed); // // sequences up 3 portd = 0b00000101; //// delay_ms(speed); // // portd = 0b00001001; //// delay_ms(speed); // // } // portd = 0b00000000; // Relachement Moteur ///////////////////////////////////////////////////////////////////// lcd_clear(); lcd_gotoxy( 0,0 ); lprintf( "STOP LIMIT LOW !" ); lcd_gotoxy( 0,1 ); lprintf( " INIT " ); j=0; break; } }
} }
}
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 12:32
Sinon je ne suis pas membre de la secte du "Chat, j'ai pété" d'autant qu'il me donne un code en C sous Linux avec des librairies d'entête .h qui ne sont pas celles de BoostC .
Tu x télécharger SourceBoostC 8.1 il est en version intégrale gratuite pour tous les µContrôleurs PIC Microship.
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 12:37
vue du simulateur de BoostC avec mon prog :
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 12:43
les boutons AV et AR simulent la manette actionnant le CV et les boutons FC AV et FC AR simule nt les fin de courses du CV (port C en entrée)
Les leds simulent la précession des pas du moteur (Port D en sortie)
L'afficheur indique la position du CV en nombre de pas (PORT B)
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 13:26
Voici l'engin : C'est TRES QRO!
Vincent
Messages : 172 Date d'inscription : 26/12/2020 Age : 43 Localisation : Achiet le Grand (62)
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 20.02.24 20:26
Bonjour, La dernière fois que j'ai programmé sur un PIC16F877 c'était il y a 23 ans, qu'est ce qui te bloque avec l'instruction SLEEP ? Quel compilateur C utilises-tu ?
D'un point de vu hardware tu as prévu de réveiller le micro comment ? Il y a plusieurs sources de réveil.
F4FIT aime ce message
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 21.02.24 0:17
Citation :
D'un point de vu hardware tu as prévu de réveiller le micro comment ? Il y a plusieurs sources de réveil.
Bonjour Vincent !
Donc sur le portc en entrée j'ai deux entrées qui vont sur une manette qui met soit au niveau haut un bit pour le sens horaire ou un autre bit pour le sens trigo du moteur .
Deux bits servent : un pour le fin de course haut et l'autre pour le fin de course bas .
Je voudrai pouvoir mettre le µContrôleur en sommeil (consommation minimale) dès que la manette est au neutre (relâchée) ce qui met tous les bits au niveau bas (pull down) de façon a pouvoir via une batterie maintenir le µContrôleur qui gardera la valeur des pas et me la restituera au moment du réveil du 16F877 dès que j'actionnerai à nouveau la manette soit en montée soit dans un sens ou un autre . en fait sommeil dès que portc == 0 et réveil dès que portc != de 0.
Le master reset (à la mise sous tension) lui par contre doit permettre la séquence d'initialisation (origine machine -fin de course AR ) pour donner le ZERO .
J'utilise SourceBoost C 8.1 (devenu version intégrale gratuite et téléchargeable) .
Mon code que j'ai publié plus haut est totalement fonctionnel tant sur le simulateur de SourceBoost que sur la carte que j'ai développé en réel et qui fonctionne mais sans la fonction de mise en sommeil du µC .
Merci d'avance!
Emmanuel F4FIT
PS si tu as besoin je peux t'envoyer le schémas de la carte mais tu devrais dans le code retrouver les ports concernés .C'est le port c qui doit être maître de la mise en sommeil et du réveil.
Port B ==> afficheur ( sortie) Port C ==> commande (entrée) Port D ==> Commande moteur pas à pas (sortie)
Vincent
Messages : 172 Date d'inscription : 26/12/2020 Age : 43 Localisation : Achiet le Grand (62)
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 21.02.24 22:07
Bonjour Emmanuel, Je veux bien voir le schéma stp.
Je vais avoir besoin de quelques explications car je vois que le code n'est pas *factorisé et il y a des instructions break; pour casser les boucles while. Je ne dis pas que c'est mal, c'est plutôt que ça rend bien plus complexe la lisibilité pour ceux qui n'ont pas fait le programme.
*factorisé c'est quand on a du code redondant, comme c'est le cas avec if (portc==10), on met ça dans une fonction, avec un nom compréhensible, qu'on appelle aux endroits dans le programme où c'est nécessaire. Ca rend le code plus lisible.
Dans mon boulot ce type de programme finit souvent en machine a état, c'est à dire qui a cette allure
Code:
while(1) { switch (portc) { case 0 : // faire des choses break;
case 1 : // faire d'autres choses break;
case 2 : // faire encore d'autres choses break;
default : sleep(); // dodo } }
Et pour sortir le micro du mode sommeil il faut une interruption par exemple.
As tu encore la possibilité d'échanger les ports B et C ? Le port B est interruptible (peut déclencher une interruption dès que la valeur en entrée change) ce qui est l'idéal pour un clavier/bouton et il permet de sortir le micro du mode sommeil !
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 18:01
Bonsoir Vincent ! Merci de t'impliquer dans ma recherche sur ce programme .
Je n'ai pas bâti ce programme avec des fonctions vu le nombre d'imbrications : affichage , comptage , surveillance de l'état du port C à chaque pas du moteur (j+1 ou j-1) dans les boucles while ...
Je connais les branchements inconditionnel "switch" case1 ...case2 ... Les "break" sont là pour sortir de la boucle donc bloquer et arrêter le moteur dans la position voulue quand je relâche la manette .
Le port A par contre je le garde en réserve pour une extension éventuelle et ultérieure du système vu qu'il donne accès aux entrées analogiques pour peut être y adjoindre une mesure du ROS .
Non je ne peux plus à présent changer les ports vu que j'ai réalisé les cartes qui fonctionnent en réel . Dans l'immédiat c'est la possibilité ou non de mise en sommeil du µC de façon qu'entre deux utilisations et avec une batterie alimenter simplement le µC en coupant l'alim de puissance avec un minimum de consommation maintenir dans le µC la valeur de "j" (compteur qui m'indique la position du CV ) sans que le système ne soit obligé dans le cas d'un master reset de reprendre la procédure d'initialisation en allant chercher le fin de course arrière "origine machine " pour faire son zéro.
Je ne vois pas sur ce forum le moyen de t'envoyer les schémas en pdf . Je vais essayer de voir si je peux te les envoyer sur ton email dans la mesure où il est spécifié ici .
Je te donne mon adresse mail: f4fit.36@gmail.com , revois moi ton mail pour que je puisse te faire parvenir les schémas en pdf.
Encore un grand merci .
Emmanuel F4FIT
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 18:46
Bon j'ai fait des copie d'écran :
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 18:51
Vincent
Messages : 172 Date d'inscription : 26/12/2020 Age : 43 Localisation : Achiet le Grand (62)
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 19:00
F4FIT a écrit:
Non je ne peux plus à présent changer les ports vu que j'ai réalisé les cartes qui fonctionnent en réel .
D'accord.
F4FIT a écrit:
Dans l'immédiat c'est la possibilité ou non de mise en sommeil du µC de façon qu'entre deux utilisations et avec une batterie alimenter simplement le µC en coupant l'alim de puissance avec un minimum de consommation maintenir dans le µC la valeur de "j" (compteur qui m'indique la position du CV ) sans que le système ne soit obligé dans le cas d'un master reset de reprendre la procédure d'initialisation en allant chercher le fin de course arrière "origine machine " pour faire son zéro. Je connais les branchements inconditionnel "switch" case1 ...case2 ... Les "break" sont là pour sortir de la boucle donc bloquer et arrêter le moteur dans la position voulue quand je relâche la manette .
Tu pourrais m'expliquer l'algorithme car dans l'immédiat je ne vois pas où endormir le micro. Parfois ce n'est pas possible selon l'algorithme qu'on choisi. Si par exemple on scrute un clavier en mode polling (une boucle qui lit un clavier pour détecter un changement) on ne peut pas endormir le micro sinon le clavier n'est simplement plus lu.
Les wake-up des micros, du moins tous ceux sur lesquels j'ai bossé, sont toujours liés à des interruptions. Sur ton micro l'arbre d'interruption capable de réveiller le micro (si tant est qu'on puisse l'endormir) est celui ci-dessous et si je te demandais si tu pouvais échanger les PORTB et PORTC c'est justement parce que le PORTB, au travers de l'interruption RBIE, peut déclencher un wake-up au moindre changement de valeur sur le PORTB.
Dit autrement j'allais te proposer, avant de savoir que le projet est réalisé, d'utiliser pleinement ce que le fabricant a écrit ici :
Il recommande de mettre tout ce qui est clavier/manette/bouton sur le PORTB car il est capable de déclencher une interruption si le micro détecte un changement de valeur sur le port.
ps : j'ai été trop long a écrire, je viens de voir tes schémas. Je regarde !
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 19:28
Effectivement sans interruption sur le port C je risque d'endormir le CPU pour l'éternité sans possibilité de réanimation (rire jaune ) vu qu'une fois endormi il ne "verra" aucune action en entrée ...
Ben voilà ça m'apprendra à ne pas avoir lu le datasheet du 16F877 ... Je me suis basé sur l'existence de plusieurs ports en pensant que tous feraient l'affaire et surtout par le fait que j'en avais un en fond de tiroir ...
Bon ben il consommera presque 3 mA en tournant comme un dingue dans le "while(1)" du prog au lieu de quelques µA en attendant sagement que je le réveille ...
Sinon il me reste que l'option du reset sauvage à chaque mise sous tension qui va aller chercher à l'initialisation le point zéro en perdant du temps et m'obligeant a chaque fois à refaire le réglage du coupleur ...
Télécharges SourceBoost 8.1 (il est gratuit et complet ) pour tous les PÏC 16 et 18 tu pourras faire tourner mon prog avec les simulations , les plugins sont intégrés dans l'IDE .
Sinon si tu as une autre idée sans avoir à refaire les circuits imprimés je suis preneur .
Encore merci
Emmanuel F4FIT
Vincent
Messages : 172 Date d'inscription : 26/12/2020 Age : 43 Localisation : Achiet le Grand (62)
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 19:46
F4FIT a écrit:
Sinon si tu as une autre idée sans avoir à refaire les circuits imprimés je suis preneur .
Malheureusement non J'ai regardé la broche RB0/INT car c'est une entrée capable de déclencher une interruption mais elle est aussi utilisée.
L'algo le plus direct que je vois (en considérant les possibilités de ce micro) serait quelque chose comme ça mais cela nécessiterait de refaire le design. Je suis désolé mais je ne vois pas d'autres solutions.
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 20:00
Effectivement , ramener sur la bonne broche du port B l'action de la manette ... Mais voilà la "bonne broche est prise . En plus la mise en sommeil devrait se faire après chaque break de sortie de boucle qui correspond à un pas moteur donc un j+1 ou j-1 suivant le sens de rotation...
Ben ça restera comme ça pendant un moment sinon je vais pas refaire de radio d'ici peu et ça fait plus d'un mois que j'ai pas remis les pieds sur l'air HI!
Un grand merci pour ta patience et ton attention et au plaisir d'une prochaine discussion .
PS: fais un petit tour sur ma page QRZ.COM tu verras mes constructions home made
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 20:06
As-tu mesuré le courant consommé après un sleep() ?
Dans mon précédent post, j'étais sous linux avec C "normal", pas sur un PICS
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 21:05
Citation :
As-tu mesuré le courant consommé après un sleep() ?
Bah non puisque il est impossible dans mon cas actuel de réaliser cette fonction .
Par contre j'ai lu dans certains post de développeur que ça passait de 2.7mA à 43 µA ce qui n'est pas négligeable pour une batterie de sauvegarde . Mais bon ... Ce qui est fait est fait ...
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 22.02.24 23:38
Dans ton cas, tu ne peux pas réveiller le PICS mais tu dois pouvoir mettre un sleep() dans ton code, même si, in finé, ça ne sert à rien.
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 23.02.24 0:37
Donc si je comprends bien, tu veux 1) Que je lui prenne la tension ,oups ! Son intensité en fonction 2) Que j'extrait le PIC de son support 3) Que je le mette sur la table d'opération (programmateur Galep4) 4) Que je le rende amnésique (effacement) 5) Que je le mette en coma artificiel irréversible par injection de la substance "sleep()" 6 Que je le remette dans sa chambre (support de la carte ) 7) Que je lui reprenne la tenson ..oups décidément , l'intensité Que je fasse la différentielle des deux (diastole systole) 9) Que je le lobotomise à nouveau (bon il sera déjà dans le comas) en l'effaçant 10) Que je lui rebourre le crâne avec ce qu'il savait déjà au début avec le risque que ce traitement de choc ne lui ai peut être fait pété une case!
Bon je viens de regarder un épisode du Dr House ... Tout s'explique!
Vincent
Messages : 172 Date d'inscription : 26/12/2020 Age : 43 Localisation : Achiet le Grand (62)
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 23.02.24 9:11
Bonjour, Je pense que François parlait de faire un test Sleep() juste pour faire une mesure de courant sur la batterie. Selon le résultat du test on peut parfois s'apercevoir que ça ne vaut pas le coup de faire un Sleep() du micro.
Je n'ai pas la référence du régulateur U1 mais si c'était par exemple un 7805 alors il aurait un quiescent current de l'ordre de 3mA voir un peu plus selon la référence exacte du composant. Mettre le micro en veille améliorerait les choses mais la batterie continuerait de voir une fuite de courant de 3mA environ.
RaDiMaN
Messages : 217 Date d'inscription : 12/02/2023
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 23.02.24 9:41
Bonjour,
Question stupide : Ya pas moyen de greffer au montage une eeprom pour enregistrer la position du moteur pas à pas. Puis faire du ON/OFF avec un truc simple externe ?
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 23.02.24 12:00
Vincent a écrit:
Bonjour, Je pense que François parlait de faire un test Sleep() juste pour faire une mesure de courant sur la batterie. Selon le résultat du test on peut parfois s'apercevoir que ça ne vaut pas le coup de faire un Sleep() du micro.
Je n'ai pas la référence du régulateur U1 mais si c'était par exemple un 7805 alors il aurait un quiescent current de l'ordre de 3mA voir un peu plus selon la référence exacte du composant. Mettre le micro en veille améliorerait les choses mais la batterie continuerait de voir une fuite de courant de 3mA environ.
Bonjour Vincent ,
Ma réponse à François était une boutade il faut la prendre avec sourire On se cause souvent par radio
Sinon pour ce qui est de la consommation intrinsèque du 7805 , j'avais prévu de réaliser l'ajout de la batterie de sauvegarde au travers d'un bypass à diodes sur la sortie du sus dit régulateur de façon à n'alimenter que le µC et non le reste .
De toute façon comme je l'ai expliqué c'est pour maintenir uniquement le µC une fois l'alim générale coupée donc l'entrée du régulateur hors tension et forcement hors consommation . J'ai à cet endroit des pistes assez longue sur ma carte pour moyennant un sectionnement y rajouter les diodes de bypass .
F4FIT
Messages : 62 Date d'inscription : 02/03/2021 Age : 64 Localisation : Azay le Ferron 36
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ? 23.02.24 12:17
Ya pas moyen de greffer au montage une eeprom pour enregistrer la position du moteur pas à pas. Puis faire du ON/OFF avec un truc simple externe ?
Bonjour ,
Non plus de place sur la carte pour ça , en plus j'aurais très bien pu mettre la valeur en eeprom du µC sans rajouter une externe ,mais cela ne répondrait pas au coté fonctionnel de l'appareil .
C'est bien beau de garder la valeur "J" en mémoire si à la remise sous tension on repasse par l'initialisation qui va me ramener le CV à la position d'origine et J à zéro .
C'est comme pour une imprimante , à l'allumage le chariot va aller s'initialiser sur la gauche au point zéro et moi je veux qu'à la remise sous tension le chariot qui est resté dans une position intermédiaire à la valeur "J " reprenne comme si il n'y avait pas eu d'arrêt afin de ne pas perdre de temps (ça tourne pas très vite et le CV fait 20 tours et le démulti à courroie X 4 donc 80 tours ) si je veux me recaler sur la même fréquence sans avoir a attendre et à refaire le réglage .
Contenu sponsorisé
Sujet: Re: Qui propgramme en C ou C++ PIC 16F877 ?
Accueil 
d'autant qu'il me donne un code en C sous Linux avec des librairies d'entête .h qui ne sont pas celles de BoostC .
vu qu'une fois endormi il ne "verra" aucune action en entrée ... 
Que je fasse la différentielle des deux (diastole systole) 
Calendrier