cartes pour servo moteurs

  • Auteur de la discussion alex68
  • Date de début
A
alex68
Apprenti
17 Déc 2006
107
Alsace
  • Auteur de la discussion
  • #1
Bonjour a tous,
Je suis pas un fan des moteurs pas a pas pour une conversion d un tour ou d une fraiseuse tradissionnelle.... donc je suis a la recherche d une commande de servomoteurs...

J ai trouve quelaue chose de pas mal sur cnczone

http://www.cnczone.com/forums/showthread.php?t=14217

c est un allemand qui est l auteur de cette realisation ( ULI )
ce monsieur vous envoie les micros controleur contre une ou des bieres locales de votre region

Tout est explicite sur ce site

http://gsst.wikispaces.com/
 
D
Doctor_itchy
Compagnon
20 Avr 2007
5 219
Morlanwelz
haaa oui je connais bien se topic ^^

etant donner que je suis sur cnc zone aussi ^^


sinon il ont l'air d'etre tres tres bien ses petit controleur servo , y as une video qui montre les axe en mouvement ha ben y a pas ça dechire ^^


pour l'echange de biere j'avait pas lut ^^ c'est un avantage pour peu que tu est dans le bon pays :lol: ( moi ça va belgium power ^^ )
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
pas mal, je viens de faire un tour, c'est intéressant...
mais je me demande pourquoi tous ces projets sont à base d'AVR, alos qu'il eixste des PIC dédiés au contrôle des moteurs et qui possèdent en hardware des PWM pour brushless, entrée quadrature (si je me souviens bien) etc.
ces PIC tournent aux alentours de 5-6€/pce, mais ont des performances nettement meilleures et sont à mon sens plus facile à programmer...
je vais peut être consacrer de mn temps perdu cet été à faire un contrôleur brushless, et peut être même que ce sera au programme de mon master pro!
à suivre, donc :wink:
 
D
Doctor_itchy
Compagnon
20 Avr 2007
5 219
Morlanwelz
parçe que ELM est chinois et il as les composant AVR gratos :wink:

je le connais je suis rentrer en contact avec lui concernant sont projet de projecteur laser :wink:

(entant donner que ma grosse passion est le laser ^^ )
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
je me demmande pourquoi tout le monde utilise des microcontroleurs
c'est tellement plus simple avec des circuits logiques et analogiques!
le principe est simple
-un compteur differentiel
-un dac r2r
-un correcteur PID a ampli-op
-PWM
-mos de puissance
ce systeme a l'avantage de ne pas utiliser de composants programmable et d'avoir un temps de réponse beaucoup plus court qu'un micro cat il n'y a pas de temps de cycle
un 74hc193 est cappable de compter a des fréquence de 10mhz je peut dire que jammais une machine ne l'exploitera a 100%
 
D
Doctor_itchy
Compagnon
20 Avr 2007
5 219
Morlanwelz
oui mais tu me dira alors pourquoi les controleur de moteur industrielles des grosse cnc et ugv ont des microcontroleur par axe ?

style Mc68340 a 16mhz ( le cas de mes positec ! )

si on as un bon uc ça simplifie car c'est le uc qui fait tout et qui peu etre modifier afin d'ameliorer les perf du moteur !!!
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
si tu prend les siemens simodrive 611 c'est meme pas des microcontroleurs
c'est des puces speciales pour cete fonction
les datasheet sont introuvables

il y a aussi les ci lm628 629 qui sont specialement fait pour cette application mais hors de prix
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
simple??? non, regarde la taille du pcb et aussi la difficulté à trouver le compo foireux en cas de prob et la difficulté de modifier un design existant.
rajoutes à ça le cout des différents compos (10*50ct=5euros, le prix d'un 16F876) et le temps de routage de la carte et tu es fixé...
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
une panne sur une carte avec un UC => poubelle

la ou je travaillait avant on avait une aléseuse cnc des années 60 avec une commande general electric de l epoque c'etaient que du plaisir de depanner les carte
pas le moindre cpu que des portes logiques et analogiques
le pcb devait faire 200*150mm avec la commande des thyristors intégrées
c etait des moteurs a charbons (le brushless n'existait pas a l'époque)

les cartes etaient pas si complexes que ce il devait y avoir 8 ou 9 circuits intégrées
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
après, chacun ses gouts, mais si les µC sont si appréciés, c'est aussi parceque ils sont "universels", et leur mem flash permet de modifier le prog pr l'améliorer etc.
puis y'a la flemme qui s'est imposée, elle aussi :roll:
pour faire un dérivateur avec un PIC, tu rentre la formule dans ton prog et hop! tu compiles, mais en ana, il faut connaitre le circuit avec AOP...
pour des fonctions plus complexes tu te retrouvais à chercher si un circuit pouvait faire telle fonction existait, si oui son nom, référence etc. pour t'appercevoire que il est en rupture de stocks :?
perso la programmation des PIC a changé ma vie, et même sans un diplome élec je serais capable de faire un driver de PAP ou même de brushless!
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
si tu arrive a faire un driver brushless commandé en 0-5v sans capteur hall ca serait interessant
je suis actuellement en train de créer une carte servo
la partie compteur sera faite par un micro par contre le correcteur pid sera analogique avec des aop
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
brushless sans capteurs hall, pas de pb, mais avec capteur optiques!
il y a bien des systèmes de détection de "passage par 0" de l'intensité, mais tu es très limité en vitesse, c'est pas précis donc pas dutout adapté à cette utilisation!
par comtre, tu peur utiliser un seul capteur optique qui envoie une brève impulsion quant le moteur est dans une position très précise et utiliser la sortie encodeur pour déduire la position du rotor. il faut donc faire un petit réglage assez précis.
la partie PID en ana sera plus facile à régler et développer je pense, car il faut souvent prendre en compte les ressources processeur pour faire un PID numérique correct. mais avec un PIC 30F / 33F, pas trop de soucis avec les 40Mips 16bits :D
sinon je suis curieux de savoir comment tu vas faire le lien compteur num->PID ana :7grat:
sinon, bien sûr que ce sera du step/dir 5v en entrée (+série/CAN si ca me gratte) et que ca fera aussi les servos DC :wink:
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
compteur numerique qui sort la difference de position en un mot de 8bit par exemple de RB0 A RB7
puis un dac 8 bit suivi du correcteur pid

pour le brushless ca serait bien un systeme qui mesure la fcem de chaque enroulement

il faut le démmarer comme un pas a pas et une fois que le voltage BackEMF est assez important il faut passer en mode synchrone
mais la n'est pas vraiment le probleme
le provleme vas etre surtout qu'in faut un pic qui gere 6 pwm avec les temps morts pour pas exploser les mos des la mise sous tension
meme les dspic je croit pas qu'ils gerent 6pwm
 
O
Otatiaro
Compagnon
6 Mai 2007
1 043
Metz (57)
arnaud2 a dit:
compteur numerique qui sort la difference de position en un mot de 8bit par exemple de RB0 A RB7
puis un dac 8 bit suivi du correcteur pid

pour le brushless ca serait bien un systeme qui mesure la fcem de chaque enroulement

il faut le démmarer comme un pas a pas et une fois que le voltage BackEMF est assez important il faut passer en mode synchrone
mais la n'est pas vraiment le probleme
le provleme vas etre surtout qu'in faut un pic qui gere 6 pwm avec les temps morts pour pas exploser les mos des la mise sous tension
meme les dspic je croit pas qu'ils gerent 6pwm
Salut,

Certains en gèrent 8, en fait 4 en opposition, avec les réglages de temps morts pour éviter les shoot thru, et tout ce qu'il faut pour gérer un pas à pas ou un brushless sans aucun problème.

Les mêmes gèrent les encodeurs quadratures en "natif", suffit de le connecter, et de récupérer la valeur courante dans un registre 16 bits ... tout le filtrage, la gestion de sens, les interruptions, etc, sont déjà dans le hard du PIC.

Pour le PID, un PIC33F fait le cycle PID complet avec un précision de 16 bits en 7 cycles d'horloge (MIPS à 40MHz, je te laisse faire le %age d'occupation processeur ... ca laisse du temps pour faire autre chose).

Si tu veux le programme dans les grandes lignes, fais un tour sur le site de microchip, ils ont pas mal d'application notes qui parles de la commande de brushless sensorless, avec souvent des bouts de programme.

J'ai vu à une présentation microchip la différence entre la commande d'un moteur pas à pas "standard" (même en micropas 8 ou 16) et la commande en sinusoidal vrai ... c'est le jour et la nuit, il faut monter en micropas 128 ou 256 minimum pour avoir un semblant de ressemblance avec du micropas. Et un PIC33F fait tout ca sans problème ...

On peut même avec un peu d'imagination interpoler le sinusoidal pour adoucir encore la chose, dans ce cas le pas à pas tourne exactement comme un moteur DC, sans bruit, sans heurs ... c'est un pur bonheur.

Après ce qu'il faut, c'est quelqu'un qui ait un peu de temps pour dévolopper la carte, quelqu'un qui peut souder du TQFP100, qui sache faire un étage de puissance digne de ce nom, et on aurait tous des électronique pas chères et parfaites à mettre dans nos machines.

Mais ca c'est dans un monde parfait ... dans le monde réel, ceux qui font ce genre de carte la vende une fortune, et se gardent bien de donner leurs sources.

++

PS : désolé je suis d'humeur noire ce soir, mais toute la partie technique est vraie.
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
je suis resté un peu vague jusqu'à maintenant (pas le temps de +), merci otatiaro pour ces précisions:wink:
perso, si je le fais vraiment cette carte, le code sera sur sourceforge (si ya une section PIC, mcu etc) car c'est juste une modif de boulot de microchip, et si je veux la vendre, ce sera ds le genre
70€ carte montée testée
40€ kit
8€ pcb (pro bien sur, 2/4f 70µ sérigraphie, etc. etc.)
(pr donner un ordre d'idée)
fichiers du pcb gratuit, car je peux les vendre et me faire du 50-70% de marge et rester moins cher que le prototypage de 2-3cartes, pas de concurrence à craindre, ni de risque de se retrouver avec une centaine de cartes qui ne seront jamais vendues!
ca permettra aux gens de la modifier si p ex elle ne rentre pas dans leur armoire électrique, ils n'aiment pas les connecteurs, autres transistors...

le plus dur sera l'étage puissance et les EMF...
50V, 10A, PWM-> grand nombre d'harmoniques puissantes, c'est plustôt dûr à maitriser, j'ai trouvé un pdf de +50pages qui INTRODUIT les méthodes pour limiter les EMF... et c'est pas de la tarte!
franchement, certaines cartes sont un chef d'oeuvre de routage, car peu de logiciels sont vraiment performants pr les EMF (ils peuvent simuler mais router de façon ad hoc, pas entendu parlé), elles méritent autant d'attention que le prog lui même!

mais si ca se réalise, ya pas de raison que je fasse payer mes services à ceux qui m'aident volontier gratuitement ici, vous aurez bien sûr pcb kit etc au prix des pièces!
c'est en mon sens la moindre des choses :wink:
PS: un 30F3010 est suffisant! 5€ et soic28, que du bon!
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
pour un driver brushless redarde le CI tb6537 de toshiba il est disponible chez farnell pour 12€ en boitier dip18 et contient tout le nessesaire pour controler un brushless sans capteur il a juste besoin de quelques résistances et 2aop pour fonctionner
il est pilotable en pwm et permet d'inverser le sens

par contre pour la partie servo apres plusieurs recherches un correcteur pid n'est pas compliqué a faire je pense utiliser un pic 18f452 et programmer en C ca sera plus simple que l'asm
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
voila une regulation pid en C




//************************************************************************************
//** REGULATION PID
//**
//**
//**
//**
//**
//**
//**
//************************************************************************************


//Définir pour microcontrôleur
#define P18F4431
#define MX_EE
#define MX_EE_TYPE3
#define MX_EE_SIZE 256
#define MX_SPI
#define MX_SPI_D
#define MX_SPI_SDI 2
#define MX_SPI_SDO 1
#define MX_SPI_SCK 3
#define MX_UART
#define MX_UART_C
#define MX_UART_TX 6
#define MX_UART_RX 7
#define MX_I2C
#define MX_I2C_D
#define MX_I2C_SDA 2
#define MX_I2C_SCL 3
#define MX_PWM
#define MX_PWM_PORT portc
#define MX_PWM_TRIS trisc
#define MX_PWM_CNT 2
#define MX_PWM_1 2
#define MX_PWM_2 1

//Fonctions
#include <system.h>
#pragma CLOCK_FREQ 40000000

//Configuration de données

//Fonctions internes
#include "C:\Program Files\Matrix Multimedia\Flowcode V3\FCD\internals.h"

//Déclarations de fonction Macro
void FCM_pid();


//Déclarations de Variable
short FCV_INTEGRAT;
char FCV_KP;
char FCV_KD;
char FCV_KI;



//Définitions supplémentaires


//Implémentations Macro

void FCM_pid()
{
//regulation pid

//Définition des variables locales
short FCL_POSITION;
short FCL_CONSIGNE;
short FCL_ERREUR;
short FCL_VAL_PROPORTIONELLE;
short FCL_VAL_INTEGRALE;
short FCL_VAL_DERRIVE;
short FCL_OLDERR;
char FCL_PID;

//Boucle
//Boucle: Tant que1
while(1)
{
//Calcul
//Calcul:
// pid.erreur = pid.consigne - pid.position
FCL_ERREUR = FCL_CONSIGNE - FCL_POSITION ;


//Calcul
//Calcul:
// pid.val_proportionelle = pid.erreur * kp
FCL_VAL_PROPORTIONELLE = FCL_ERREUR * FCV_KP ;


//Calcul
//Calcul:
// pid.val_derrive = ( pid.erreur - pid.olderr ) * kd
FCL_VAL_DERRIVE = ( FCL_ERREUR - FCL_OLDERR ) * FCV_KD ;


//Calcul
//Calcul:
// integrat = integrat + pid.erreur
FCV_INTEGRAT = FCV_INTEGRAT + FCL_ERREUR ;


//Calcul
//Calcul:
// pid.val_integrale = integrat * ki
FCL_VAL_INTEGRALE = FCV_INTEGRAT * FCV_KI ;


//Calcul
//Calcul:
// pid.olderr = pid.erreur
FCL_OLDERR = FCL_ERREUR ;


//Calcul
//Calcul:
// pid.pid = pid.val_proportionelle + pid.val_integrale + pid.val_derrive
FCL_PID = FCL_VAL_PROPORTIONELLE + FCL_VAL_INTEGRALE + FCL_VAL_DERRIVE ;


if (( 1 ) == 0) break;
}


}

//Installation supplémentaire


void main()
{

//Initialisation
ansel0 = 0x00;
ansel1 = 0x00;


//Code d'initialisation d'Interruption



//Boucle
//Boucle: Tant que1
while( 1 )
{
//Interruption
//Interruption: Autorisé Débordement du TIMER0
t0con.T0CS=0;
t0con.T0SE=1;
t0con = (t0con & 0xF0) | 0x00;
intcon.GIE=1;
intcon.TMR0IE=1;


}


mainendloop: goto mainendloop;
}

void interrupt(void)
{
if (intcon & (1 << TMR0IF))
{
FCM_pid();
clear_bit(intcon, TMR0IF);
}

}
 
O
Otatiaro
Compagnon
6 Mai 2007
1 043
Metz (57)
Salut,

oublies pas de limiter ton integrateur ...

de plus, on fait souvent une fonction pidinit et une fonction pidstep, qui pour refaire ton programme donnerait :

pidinit();

while(true)
pisdtep();

comme ca on poeut rajouter d'autres traitements dans la boucle principale.

si je trouve un pc pour taper, je te donnerais un exemple de programme un peu plus joli (je suis sur mon qtek 9000 la).

mais sinon ton programme devrait marcher.

++
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
merci de tes conseil
le programme est loin d'etre fini
ca je l'ai faiten 2mn avec flowcode (un editeur graphique en C)
j aurais besoin de quelqueus conseil

pour le comptage rapide est ce que je dois le mettre dans la boucle du programme principale ou gerrer une 2 eme interruption rb4 a rb7 comme ca a chaque changement d'etat sur ces entrées j'incrémente ou je decrémente les compteurs (FCL_CONSIGNE correspondra au compteur des entrées step/dir et FCL_POSITION au compteur du codeur)?

pour regler les parametres KP KI et KD je pense attribuer ses valeurs au entées analogiques du pic comme ca ils pouront etres réglées par potentiometres ou alors mettre un lcd et des boutons mais ca utiliserai plus de ressources du micro reste a trouver le bon compromis

la plupart des cartes come celle de ELM ou UHU ser parametre par le port serie mais j'aime pas du tout cette methode
je préffere pouvoir regler lrs valeurs en temps réel
 
O
Otatiaro
Compagnon
6 Mai 2007
1 043
Metz (57)
Salut,

bon là j'ai un vrai clavier, mais pas trop le temps d'écrire un roman :wink:

tu as déjà fait de la programmation orientée objet ?

le C n'est pas orienté objet (c'est justement la différence entre C et C++), mais on peut reprendre pas mal des principes de l'objet en l'écrivant explicitement :

En objet, on ferait une classe PID comme ca (les méthodes sont bidons, mais c'est pour l'exemple) :

public class PID
{
public PID(int kp, int ki, int kd)
{
m_kp = kp;
m_kd = kd;
m_ki = ki;
m_position = 0;
m_lastdelta = 0;
m_lastint = 0;
}

public int Target
{
get
{
return m_target;
}
set
{
m_target = value;
m_lastdelta = 0;
m_lastint = 0;
}
}

public void UpdatePosition()
{
// mettre ici le code qui gère l'encodeur
}

public int Step(int timeElapsed)
{
// calcul le PID :

int erreur = m_target - m_position;
int derive = (erreur - m_lastdelta) / timeElapsed;
int integr = m_lastint + erreur * timeElapsed;

int result =
m_kp * erreur +
m_kd * derive +
m_ki * integr;

m_lastdelta = erreur;
m_lastint = integr;

return result;
}


private int m_kp; // coef kp
private int m_kd; // coef kd
private int m_kd; // coef kd
private int m_target; // la position voulue
private int m_position; // position actuelle
private int m_lastdelta; // dernière erreur de position
private int m_lastint; // dernière intégration de l'erreur
}

Voilà pour l'objet, dans les grandes lignes (désolé s'il y a des erreurs, j'ai pas de visual studio sous la main ...)

(pour info, c'est du code C# que j'ai écrit).


Comment reprendre les mêmes grandes lignes en C :

On commence par décrire une structure avec les champs :

struct PID
{
int m_kp; // coef kp
int m_kd; // coef kd
int m_kd; // coef kd
int m_target; // la position voulue
int m_position; // position actuelle
int m_lastdelta; // dernière erreur de position
int m_lastint; // dernière intégration de l'erreur
}

et ensuite on définit les "méthodes" en explicitant "this" :

void PIDConstructor(PID this, int kp, int ki, int kd)
{
this.m_kp = kp;
this.m_kd = kd;
this.m_ki = ki;
this.m_position = 0;
this.m_lastdelta = 0;
this.m_lastint = 0;
}

int PIDStep(PID this, int timeElapsed)
{
// je réécrit pas tout le code, mais suffit de mettre this. devant les noms de variables ...
}

etc ...

Par contre je te conseille vivement de passer la structure PID par référence et pas par valeur (en fait c'est même obligé) pour des raisons de perfs (et parce que sinon le PID ne se met jamais à jour, c'est la copie qui est mise à jour ...).


Gros avantage de cette méthode ... tu peux très simplement utiliser la sortie d'un PID comme étant l'entrée d'un autre PID, et les imbriquer comme ca (ca permet de faire de l'asservissement de position ET de vitesse ET d'accélération ...).

Bien entendu, c'est un premier jet et il faudrait affiner tout ca, mais l'idée est là.

Et après ta boucle principale devient :

main()
{
PID my_pid;
PIDConstructor(my_pid, 1, 2, 3);

// ici tu lance un timer

while(true)
{
PIDUpdatePosition(my_pid);
int timeElapsed = timer.value;
timer.value = 0;
mavaleurdePWM = PIDStep(my_pid, timeElapsed);

// et ici tu met n'importe quel code pour faire autre chose, gérer un écran LCD, un clavier, s'en fout ... c'est le principe d'un micro OS en temps partagé.

}
}

Si j'ai un peu de temps (et de courage) je ferais le programme C pour PIC33, il me faudrait juste un étage de puissance basique et un moteur avec encodeur pour faire les tests (j'ai une carte Explorer 16 et un ICD2).

++

[EDIT] j'ai dis une betise, j'ai des moteurs avec encodeurs qui vienne de mes années robotique, il me faudrait donc juste un étage de puissance pas trop dégueu genre L6203. Si quelqu'un a ca en stock ... une fois que ca marche, un petit coup de protel pour faire le pcb, un coup de fil à euro-circuit pour faire quelques exemplaire, qq1 qui les soude, les programme, et hop c'est parti ...
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
pour l'etage de puissance je compte faire un pont en h a transistors mosfet avec driver + une sortie en +-10v pouvant driver un variateur externe du genre altivar

moi je suis pas programmeur je sait juste "bricoler" en microcontroleurs par contre tout ce qui est electronique de puissance c'est pas un probleme

au lieu d'utiliser la pwm sur le micro je sort la valeur sur un port (8bit) pour permettre plus de flexibilité
 
O
Otatiaro
Compagnon
6 Mai 2007
1 043
Metz (57)
Salut,

Je dois avoir des drivers de pont en H en stock ... faut juse que je les retrouve.

Vu que visiblement t'habites pas loin, si ca te dit, passes un soir en prendre quelques uns ...

++
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
je dois aussi avoir encore quelques IR2184 et des mos irf3710 (100v 45a)
avec ca je pense qu'il y a moyen de faire quelque chose

le prob c'est que j ai plus de programmateur de pic
j en avai un qui marchait sur le port parralele mai sur mon noveau pc j en ai pas
il faudra que je me fasse un jdm usb avec un ft232
 
O
Otatiaro
Compagnon
6 Mai 2007
1 043
Metz (57)
Salut,

j'en ai un sur port série qui ne me sert plus à rien ...

si ca peut te dépanner ...

msn otatiaro@hotmail.com

++
 
M
MaX-MoD
Compagnon
17 Avr 2007
2 306
Annecy (74)
eh bien, l'aventure commence :)
par contre flowcode a son propre compilo PIC?
ca fait un petit bail que je n'ai plus fait de C18 mais ca n'y ressemble pas dans les déclartions...
pour les drivers de mos/brushless, je sais qu'il y a plein de compo triple pont en H ou hexa contrôleur MOS, mais j'avias déjà croisé des bobines de 2500 contrôleurs MOS 600V à moins de 200$ sur ebay...
l'idéal est de trouver un controleur mos assez courant et pas chère... pas évident!
en tout cas, il faut un µC.
les 18F ne possèdent pas d'unité de calcul "un cycle d'instruction" ni d'entrée quadrature, mais à vue d'oeuil on peur espérer plus de 2000pas/s sans trop de soucis.
pour passer à la vitesse supérieurs, il faut taper dans les 30/33F, à peine plus chères mais un chouya plus compliqués à programmer.
mais là, les perfs s'envolent, et MACH3 avec ses 44Khz n'arrivera pas à saturer le contrôleur!
un 30F2010 à 4€ est 'suffisant'.
regardez les spec, il n'y a peut-être que la ram qui est un peu short mais le programme n'a pas de 100aines de variables et ne fait pas 10 000 lignes de code avec 20Ko de données à embarquer dc ca devrait passer sans soucis!
les 33F sont à mon avis hors course, les 10mips de plus étant inutiles et surtout ils sont 2x plus chères et plus en boitiers TQFP64 (pour les plus petits) :?

µC recommandés par microchip pour les motreurs AC:
http://www.microchip.com/stellent/idcpl ... m=en026692
 
A
arnaud2
Ouvrier
15 Déc 2006
421
moselle 57
j ai fait une simulation avec un pic 18f4431 ca tient la route jusqu'a 25000pas par secondeavec un quartz a 40mhz
je joint le fichier C de la noubelle version mais j arrive pas a le compiler en hex il faudra trover le bug

je met le detail du programme

-interruption sur timer0 qui lance le calcul des variable pid
a la fin du calcul on inscrit le résultat sous forme d'un mot de 8bit sur le port c
-interruption sur le port rb4 a rb7 qui incrémente ou decrémente les 2 compteurs (16bit) pour la consigne et la position
-programme principale lectur des convertisseurs a/d qui correspondent au coeficient kp ki et kd

modifications a venir
-indication de défauts (difference consigne /position trop grande)
-prise d'orrigine Voir la pièce jointe servo.zip
 
E
elliott
Compagnon
5 Nov 2006
905
MaX-MoD a dit:
par contre flowcode a son propre compilo PIC?
Il ne suppotre pas les dsPIC à ma connaissance
pour un compilo il faut se tourner vers le C30 de Microchip
par ex.

il est vrai que les dsPIC sont vraiment adapté à ce type de tâche
 
Haut