Discussion :

[jimbo16]

Salut

J'aurais aimé savoir si c'est possible avec un microntroleur type 8051 de generer des impulsions (signal carré) et de pouvoir modifier la durée d'impulsion et la frequence, rapidement dans le fichier par variables. Afin de commander en sortie des transistors push pull pour avior de la puissance. Et si oui que faut il utiliser timer ? ou si vous avez une methode ou algo.

merci

[wwwwwwo]

Il y a énormément de manière de faire un oscillateur et ,si tu n'as pas besoin de controler simplement le rapport cyclique (ratio phase positive/négative), je te propose une base relativement économique, stable.

VitesseAngulaire = 0 (Stop) >-1<0 Marche "arrière" >0 <1 Run
(je ne sait pas si tu travailles en Hz ou par rapport à une autre référence)
C'est le nombre d'appels du noyau qui sert de référence temporelle... 96000 fois pas seconde, 1000 fois par seconde etc. Tu peux donc faire varier la fréquence soit en modifiant VitesseAngulaire soit en mettant une temporisation .

VarCos = 1
VarSin = 0

Do
VarSin = VarSin+VarCos*VitesseAngulaire
VarCos = VarCos-VarSin*VitesseAngulaire

Ici tu testes une des deux variables (différence de phase 90° comme d'hab.)

>0 ? -> OK

< 0 prout...

Loop

Vigule fixe VS float etc. comme vouvoul

hop.

[jimbo16]

Merci det a reponse mais je me suis mal exprimé en fait !! j'ai besoin de generer juste une impulsion a l appui d un bouton !!!

[wwwwwwo]

Un trigger temporisé donc. Un compteur, un timer effectivement, c'est pas les ressources qui manquent dans un mc... un état bas qui dure N impulsions de ton timer.

[jimbo16]

oui car le but est de faire une sorte de clef magnetique qui permetra de fournir a une bobine receptrice une certaine puissance ds le but d ouvrir une serrure donc il faut que j envoie une peche de courant assez forte pendant un temps tres court.


mais generer ca en assembleur me pose des soucis

[wwwwwwo]

Quels soucis ?

Je ne connais pas le contexte mais si tu fais de l'access-control avec une bécane qui doit gérer la BDD des E/S des individus c'est un problème différent que d'utiliser un contacteur interface entre ton BP et ta bobine...

Donc, où se situent les soucis ?

[jimbo16]

pour programmer le microcontroleur qui commande le pont en h qui lui donne la puissance. Je dois deja generer un signal carre par timer c est mon premier soucis en assembleur.

[wwwwwwo]

C'est donc pas un signal carré (pas de répétition, donc la forme n'étant pas liée au temps elle ne peut être carré mais un état bas sur une sortie. Il me semble qu'avec un MC (qui n'est absolument pas mon domaine de compétence si j'en possède un ) c'est plutôt le ba ba.... tu devrais trouver ça dans sa doc.

Quel est l'intérêt de passer par un MC pour faire ça, que fait l'automate derrière... ? La solution se trouve peut-être dans le contexte.

[jimbo16]

donc l impulsion carre va commander les transistors dans le but de transmetre par champ magnetique (bobine) la puissance a une autre bobine pour ouvrir la serrure. Donc les 2 bobines servent a echanger la puissance et le code car la bobine receptrice ou du moins le montage recepteur de dois pas contenir de piles.

[wwwwwwo]

Il me semble comprendre le principe (c'est aussi pour les lecteurs) :

Tu désires transmettre par induction plusieurs choses :

- De l'energie A pour alimenter la bobine de l'electro-aimant logé dans ta gâche electrique (ce qui revient à déplacer un (gros ) aimant devant ta bobine et ça c'est pas très sécurisé, d'où le code...).

- De l'energie B pour alimenter l'intelligence de la partie décodage du bloc récépteur et valider l'opération d'ouverture via code.

- Le code (donc une liaison série qui est le multiplexage de ton code).

Donc, pour transmettre de l'energie par induction (la transformer) il faut une variation de sens des electrons cad une tention alternative.

Problème de porteuse, j'imagine :

fréquence 1 pour transmission puissance à l'electroaimant et fournir l'alimentation au MC de décodage/validation client.

fréquence 2 porteuse du code.

Donc necessité (?) d'un MC pour traiter tout-ça (bof... à moins que j'ai loupé quelques marches...) cher la technologie et la concurrence devrait réagir vertement mais bon...).

Ton signal carré (il est donc bien question de train d'impulsions et non pas d'un bistable, d'où l'intérêt de préciser de quoi vous parlez les gars) est la repésentation de ton code :

A vitesse constante (duty-cycle 50%) le train d'impulsions à toujours la même durée mais c'est le nombre d'états bas qui changent (l'inverse du code sur papier).

= -> durée d'une impulsion, ici silence
~ -> Signal correspondant à état bas

Pour 8 bits:
========
~~=~==~ -> 105

Ben mon petit algo du début devrait marcher et te fournir tes deux porteuses.

Tu l'utilises comme un automate (une procédure si tu préfères) et plusieurs moteurs (fichiers contexte).

Un moteur fréquence pour transmission énergie

Un moteur pour transmission code, contenant la constante de fréquence si Bit à un dans code ou 0 (Stop) si bit à 0) :

Biip = 1 pas de biip = 0

Tu devrais t'en tirer avec 8 lignes de code et des moteurs ultra simples (code clients j'imagine mais y'a moyen de pousser-ça avec des demis-clés réparties (si t'embarque du MC autant le fatiguer un peu ).

Tu relèves les erreurs dans tout ça et je retourne à ma copie àprès correction/optimisation.

[jimbo16]

me semble comprendre le principe (c'est aussi pour les lecteurs) :

Tu désires transmettre par induction plusieurs choses :

- De l'energie A pour alimenter la bobine de l'electro-aimant logé dans ta gâche electrique (ce qui revient à déplacer un (gros ) aimant devant ta bobine et ça c'est pas très sécurisé, d'où le code...).



presque je vais transmettre a une bobine et son entrefert qui va a son tour alimenter le microcontroleur et donner la puissance pour charger un condensateur qui lui pourra tirer 2s mon relais. Donc ca ca fonctionne reste a faire le programme.





- De l'energie B pour alimenter l'intelligence de la partie décodage du bloc récépteur et valider l'opération d'ouverture via code.

- Le code (donc une liaison série qui est le multiplexage de ton code).




oui le code je ne sais pas encore mais un truck tout con sur 8 bit histoire de pouvoir diferencier les clefs.


Donc, pour transmettre de l'energie par induction (la transformer) il faut une variation de sens des electrons cad une tention alternative.


oui donc pour avoir assez de puissance il faut fournir une petite peche de courant sur pas tres long a une frequence de 100 KHz par la .

Problème de porteuse, j'imagine :

fréquence 1 pour transmission puissance à l'electroaimant et fournir l'alimentation au MC de décodage/validation client.

fréquence 2 porteuse du code.

Donc necessité (?) d'un MC pour traiter tout-ça (bof... à moins que j'ai loupé quelques marches...) cher la technologie et la concurrence devrait réagir vertement mais bon...).

Ton signal carré (il est donc bien question de train d'impulsions et non pas d'un bistable, d'où l'intérêt de préciser de quoi vous parlez les gars) est la repésentation de ton code :


oui c est ca !!!!!



A vitesse constante (duty-cycle 50%) le train d'impulsions à toujours la même durée mais c'est le nombre d'états bas qui changent (l'inverse du code sur papier).

= -> durée d'une impulsion, ici silence
~ -> Signal correspondant à état bas

Pour 8 bits:
========
~~=~==~ -> 105

Ben mon petit algo du début devrait marcher et te fournir tes deux porteuses.

Tu l'utilises comme un automate (une procédure si tu préfères) et plusieurs moteurs (fichiers contexte).

Un moteur fréquence pour transmission énergie

Un moteur pour transmission code, contenant la constante de fréquence si Bit à un dans code ou 0 (Stop) si bit à 0) :

Biip = 1 pas de biip = 0

Tu devrais t'en tirer avec 8 lignes de code et des moteurs ultra simples (code clients j'imagine mais y'a moyen de pousser-ça avec des demis-clés réparties (si t'embarque du MC autant le fatiguer un peu ).

Tu relèves les erreurs dans tout ça et je retourne à ma copie àprès correction/optimisation.


donc t as super bien compris !!! je vais deja essayer de faire un signal carre donc mais pas evident pour moi je ne maitrise pas l assembleur ou pas trpo du moins
c est pour cela que je voulais des conseils !! merci donc

[wwwwwwo]

Ne confond pas signal carré et train de bits pour le code.
C'est pour cela que le test >0 dans mon algo transforme la variation Sinus|Cosinus en états bistables. Mais là tu as besoin de transmettre ton code via une fonction sinus (pas cosinus !) sinon pas d'induction dans ta bobine (en tout cas pas bien jolie la gueule du signal en sortie, pas besoin de sortir le scope pour te dire ça ) avec anti-rebond et tout le tas de fumier donné avec

Donc :

Un Sinus à 100K (premier moteur qui utilise mon algo)

Un Sinus à ? Hz (porteuse ou impulsion directe selon tes critères de sécu) pour les tests de fenêtres en réception et/ou démultiplexage du code.

c'est là qu'est déplacé le test >0...

Moteur code :

RAZ via de Sinus
RA1 Cosinus
RAx VitesseAngulaire si bit code = 1
sinon
RAZ VitesseAngulaire si bit code = 0

en reception: (je ne connais pas ton format de start/stop bit, ni le systeme de croisement d'erreurs)

Si Tension = 1
Pas de tension 0

hop

[jimbo16]

oui j'ai confondu c bien une trame !!

bon je vais relir tes postes en prenant le temps car pour le moment je ne comprends pas tout ! voir meme presque rien !!! surtout pour traduire ca en assembleur

[wwwwwwo]

Je vais essayer d'être le plus générique possible :

ASM 32 bits (peu importe) pour l'exemple histoire d'encourager mes contemporains.

- Lecture du moteur (fichier d'init) et stokage dans la EEPROM (j'imagine, où là ou vous avez prévu de loger de manière durable vos infos clients). Ce moteur contient donc le code client (voir la demi-clé sécuritaire pour le XOR qui permet d'éviter les scans accès).

- Le reste de la EEPROM est initialisé avec les moteurs [porteuse energie] et ["porteuse" code] (soit les deux VitesseAngulaire Energie et Code client -> tu pourrais aussi prévoir une date de validité pour les accès restreints etc. enfin penser à la durée de ton produit et le(s) service(s) qui te fera(ient) gagner plus d'argent que tes concurrents te permettant ainsi de mieux te positionner durablement sur ce marché (aux puces)).

Pour VitesseAngulaire, il est calculé en fonction des quartz utilisés et d'une nombre d'itératrions par seconde de l'automate (par exemple 100 000/sec -> VitesseAngulaire porteuse energie = 1/100 000 -> si Hz = 200KHz 2/100 000 et, bien-sûr, si = 250 HZ 1/25 000 000 etc.)

- Lancement automate par approche du boitier/clé (Là, t'as ta bidouille avec un bilame magnétique ou un truc équivalent... pour éviter au client l'appui sur un composant source de pannes , tu vas pas gagner ta vie avec la maintenance...)
_________________________________________________________

Load moteur:

Tu as un offset (dans l'EEPROM) datas par moteur et une struture d'offsets (donc codée en dur) pour les datas Vitesses angulaire et stokage de tes variables dans la RAM (plus sauvegarde adresse de base RAM pour stockage contexte moteurs).
(prévoir des structures suffisement importantes pour pouvoir faire de l'update moteur par simple passage devant une borne de MAJ et faire évoluer le produit sans ré-écrire le code toutes les 5 minutes)

Dans ta RAM :

Data_1 (en 32 bits adresses DWord -> offset = *4 (Bytes))
Data_2
...
Data_N

Toutes ces Datas sont initialisées au lancement par copie EEPROM -> RAM comme d'hab.

Dans ton EEPROM, structure d'offsets :

Taille structures = Offset Data_N (N*4)

0*4 (Data_1)
1*4 (Data_2)
...
N*4 (Data_N)

Tu as stoké ton adresse de base des datas et pour les atteindre tu sautes à l'adresse de base relative par:

ID_Moteur (0 ~ M ici 1 0 Porteuse Energie 1 "Porteuse" code client)

Contenu Data_2 = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

(Dessine tes tables et tout deviendra limpide).
_________________________________________________________

Automate :

VarSin et VarCos sont devenus Data_A et Data_B
VitesseAngulaire Data_C

Data_D = ID Moteur courant

(les Variables A B et C pointent vers des structures de data différentes vu que l'adresse de base (qui sert au calcul) change en fonction de ID Moteur courant..):

Contenu Data_2 = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

Contenu Data_A = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

ensuite un tour d'automate :

Data_A = Data_A+Data_B*Data_C
Data_C = Data_B-Data_A*Data_C

-> Tu balance la purée en sortie vers ton montage de puissance push-pull...

L'automate ignore donc le contexte de travail mais il fait son boulot sagement ce qui permet de multiplier les moteurs, pratiquer des MAJ simples et développer des services rémunérateurs.

Je ne connais pas (L)tes besoins energétiques mais il est peut-être possible de loger un simple aimant permanent dans ton boitier (la FEM nécessaire pour soulever ton EA étant à quelque chose prêt équivalente à la dépense d'energie du client (autant utiliser l'enrgie du client en plus de son argent ) pour positioner sa clé devant ton capteur passif...)

Pour le chèque tu fais comme d'hab (tu as mon numéro en Suisse ).

Si je suis pas assez clair, n'hésites pas.

[wwwwwwo]

C'est dingue la propension à l'absorption de l'ascii de certains lieu, Alcatraz n'est pas loin...
Donc, pour ceux qui sont intéressés pour maquetter du traitement du signal (audio) en temps réel (s'initier avec les principaux algo de manière ludique et interactive) avec un excellent outil http://www.mtu-net.ru/syncmodular/

Plusieurs s’étant mesuré à cet exercice, Doc Sync est cependant le seul qui est obtenu ,suite à ce travail, l’appel et l’embauche par la firme bienconnue et a participé à la refonte de Reactor.

Je conseille la lecture de la doc très bien faite (et digeste pour le coup). De plus cet outil peut être facilement détourné pour ce fabriquer des automates dans le genre » JAM-Stations ».

Les filtres, générateurs et autres facéties seront bientôt moins impressionants… et très facilement portables en ASM.

[jimbo16]

Je vais essayer d'être le plus générique possible :

ASM 32 bits (peu importe) pour l'exemple histoire d'encourager mes contemporains.

- Lecture du moteur (fichier d'init) et stokage dans la EEPROM (j'imagine, où là ou vous avez prévu de loger de manière durable vos infos clients). Ce moteur contient donc le code client (voir la demi-clé sécuritaire pour le XOR qui permet d'éviter les scans accès).

- Le reste de la EEPROM est initialisé avec les moteurs [porteuse energie] et ["porteuse" code] (soit les deux VitesseAngulaire Energie et Code client -> tu pourrais aussi prévoir une date de validité pour les accès restreints etc. enfin penser à la durée de ton produit et le(s) service(s) qui te fera(ient) gagner plus d'argent que tes concurrents te permettant ainsi de mieux te positionner durablement sur ce marché (aux puces)).

Pour VitesseAngulaire, il est calculé en fonction des quartz utilisés et d'une nombre d'itératrions par seconde de l'automate (par exemple 100 000/sec -> VitesseAngulaire porteuse energie = 1/100 000 -> si Hz = 200KHz 2/100 000 et, bien-sûr, si = 250 HZ 1/25 000 000 etc.)

- Lancement automate par approche du boitier/clé (Là, t'as ta bidouille avec un bilame magnétique ou un truc équivalent... pour éviter au client l'appui sur un composant source de pannes , tu vas pas gagner ta vie avec la maintenance...)
_________________________________________________________

Load moteur:

Tu as un offset (dans l'EEPROM) datas par moteur et une struture d'offsets (donc codée en dur) pour les datas Vitesses angulaire et stokage de tes variables dans la RAM (plus sauvegarde adresse de base RAM pour stockage contexte moteurs).
(prévoir des structures suffisement importantes pour pouvoir faire de l'update moteur par simple passage devant une borne de MAJ et faire évoluer le produit sans ré-écrire le code toutes les 5 minutes)

Dans ta RAM :

Data_1 (en 32 bits adresses DWord -> offset = *4 (Bytes))
Data_2
...
Data_N

Toutes ces Datas sont initialisées au lancement par copie EEPROM -> RAM comme d'hab.

Dans ton EEPROM, structure d'offsets :

Taille structures = Offset Data_N (N*4)

0*4 (Data_1)
1*4 (Data_2)
...
N*4 (Data_N)

Tu as stoké ton adresse de base des datas et pour les atteindre tu sautes à l'adresse de base relative par:

ID_Moteur (0 ~ M ici 1 0 Porteuse Energie 1 "Porteuse" code client)

Contenu Data_2 = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

(Dessine tes tables et tout deviendra limpide).
_________________________________________________________

Automate :

VarSin et VarCos sont devenus Data_A et Data_B
VitesseAngulaire Data_C

Data_D = ID Moteur courant

(les Variables A B et C pointent vers des structures de data différentes vu que l'adresse de base (qui sert au calcul) change en fonction de ID Moteur courant..):

Contenu Data_2 = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

Contenu Data_A = D$AdresseDeBase+(TailleStructure*ID_Moteur)+Data_2

ensuite un tour d'automate :

Data_A = Data_A+Data_B*Data_C
Data_C = Data_B-Data_A*Data_C

-> Tu balance la purée en sortie vers ton montage de puissance push-pull...

L'automate ignore donc le contexte de travail mais il fait son boulot sagement ce qui permet de multiplier les moteurs, pratiquer des MAJ simples et développer des services rémunérateurs.

Je ne connais pas (L)tes besoins energétiques mais il est peut-être possible de loger un simple aimant permanent dans ton boitier (la FEM nécessaire pour soulever ton EA étant à quelque chose prêt équivalente à la dépense d'energie du client (autant utiliser l'enrgie du client en plus de son argent ) pour positioner sa clé devant ton capteur passif...)

Pour le chèque tu fais comme d'hab (tu as mon numéro en Suisse ).

Si je suis pas assez clair, n'hésites pas.

des que je travaillerai alors car etant etudiant je ne pense pas que se soit necessaire douvrir un compte expres !!!


Merci pour tes renseignement ! ma partie elctronique est finie et fonctionne, jarrive a une distance de 4 mm entre chaque bobinne sur des ferrite de 25 x 12 x 7 donc assez petit.

Je me lance cette fois dans l'assembleur et je vais commencer par generer le signal carré qui arrive sur mon transistor pour le commander par pression sur un bouton.

J'utiliserai tes précieuse info pour la suite avec le codage


merdi

[wwwwwwo]

De rien, on est sur un forum !

Bon courage pour la suite (je persiste à penser qu'un signal carré n'est pas le plus approprié pour une transformation : Les pertes sont très importantes par rapport à une forme sinusoïdale... et plus complexe à générer...).

@+

[jimbo16]

Si j'impose une sinus sur mon transistor le temps pour passer l'énergie triple d'une bobinne a l'autre. Je n'ai donc pas trop le choix.

Générer un signal carré pendant 2 s est vraiment compliqué ??

[wwwwwwo]

Pour t'éviter des lourdeurs de code, il suffit de faire un test > 0 (sur la sortie cos par exemple) et envoyer ta valeur Max ou Min. De plus, le fait d'utiliser le même automate générateur pour porteuse vobulation etc. te permet de limiter les bugs et de pouvoir faire des updates facilement (y compris sur la borne de rechargement...).

[jimbo16]

Pour t'éviter des lourdeurs de code, il suffit de faire un test > 0 (sur la sortie cos par exemple) et envoyer ta valeur Max ou Min. De plus, le fait d'utiliser le même automate générateur pour porteuse vobulation etc. te permet de limiter les bugs et de pouvoir faire des updates facilement (y compris sur la borne de rechargement...).

mais je ne peux pas regler ma frequence ni le rapport cyclique aussi ?