bonjour tout le monde
je m'intéresse de plus en plus aux microcontroleur c'est pourquoi j'en cherche un petit simple a programmer
je bricole un peut en c++ et en basic
et je c'est aussi programmer des automates de type tsx17 ou 37
je cherche un Uc pas trop cher avec une dizaine d'E,S
que pouvez vous me conseiller
merci de votre aide
Beaucoup de débutant commence avec un pic16f84a, tres facile a programmer, le programmateur est facile a construire... 13 E/S, 4 interruptions,
Ton C++ ne te servira a rien, le basic peut-être un peu, mais le mieux sera de se mettre alors a l'assembleur.
Regarde les cours de bigonoff tu en apprendras beaucoup:
http://bigonoff.org/
Le 68HC908 devrait répondre à tes désirs, pas cher et très simple.
L'environnement de programmation (ASM, C, C++) est gratuit
regarde www.68hc08.net
th.
Bonjour à tous !
En effet, je te conseilles aussi le PIC16F84A pour débuter !
Ce microcontroleur se programme vraiment très facilement en assembleur, et on a pas besoin de le maîtriser à 100% pour pouvoir concevoir de très bons montages et applications !!
Cependant, si tu es réfractaire à l'assembleur, il existe de nombreux compilateurs basic ou C sur le net en version démo, ou alors ,je peux te conseiller le compilateur SDCC libre (sous licence GPL) http://sdcc.sourceforge.net/
Bonne continuation
@+
merci de tout vos reponce
dans un 1er temp je vais lire a longue doc sur les pic de http://bigonoff.org/
a combien peut me revenire la platine de programation ainsi que le pic PIC16F84A
je vien de trouver un programmateur pour le pic
http://mac1.ifrance.com/picprog/index.htm
j'ai deja la moitier des composant pour le monter
et sur conrad le pic coute dans le 7 a 8 €
il me reste a aprendre le language de programation
http://www.selectronic.fr/soussousfa...5&ssfam_ref=13
Le 16F628 est compatible pin à pin avec le 16F84, est moins cher, a plus de mémoire et est plus performant.
A toi de faire ton choix.
Chez Lextronic tu trouveras des compilateurs C, Basic et Pascal gratuits limités à 2K de mémoire.
Gérard.
Les gouts et les couleurs ...
Comme vous, je me suis mis il n'y a pas longtemps aux PIC (16F84 puis 16F877) et comme je ne voulais pas faire de programmation "compliquée", j'ai choisi le Basic (PicBAsic PRO) mais il ne fait pas les virgules flotantes, ni les calculs en 16/32 bits.
Pour une utilisation simple (gestion LCD, gestion entrée sortie, interuption ...), il est vraiment super.
La, j'ai choisi le C qui fait naturellement ce que le Basic ne faisait pas mais est moins simple.
Ex de gestion LCD sous Basic
Le même en CDEFINE LCD_DREG PORTB 'Selection du port B
DEFINE LCD_DBIT 4 'Selection de RB4 à RB7
DEFINE LCD_RSREG PORTB 'RS sur port B
DEFINE LCD_RSBIT 2 'RS sur RD1 (a voir)
DEFINE LCD_EREG PORTB
DEFINE LCD_EBIT 0 'E sur RD0
DEFINE LCD_BITS 4 'Mode 4 bits
DEFINE LCD_LINES 2 '2 lignes
PAUSE 1000
LCDOUT $FE, 1
LCDOUT "compteur LCD"
PAUSE 1000
alors, c'est quoi le plus simple ?void Efface_LCD(void);
void Ligne_LCD(char cLigne, char cPosition);
void Efface_LigneLCD(char cEff);
void wr_Lcd(unsigned char cVar,unsigned char cLcd_RS);
void Ini_Lcd(void);
void Tempo(char ti); // tempo
void Message_Lcd(const char* texte); // fonction de transfert, d'un message vers lcd
void Ini_Lcd(void)
{
// **** initialisation LCD *****
PORTC= 0;
Lcd_RS=0;
for(cL=0;cL<2;cL++) {TMR0=1; while(TMR0 != 0);} //32ms afficheur
pins=0x30;
Tempo(189); // 4,3ms E inclus
Tempo(254); // 150µs
pins=0x20;
Tempo(254); // 150µs
//**** initialisation paramètres LCD ****************************** ****
wr_Lcd(0x28,0); // Mode 4 bits 2 lignes
wr_Lcd(1,0); // Efface l'affichage initialisation DD-ram
wr_Lcd(0x0C,0); // Affichage des caractères de gauche à droite et curseur se déplace
wr_Lcd(6,0); // Déplacement vers la droite
}
void wr_Lcd(unsigned char cVar,unsigned char cLcd_RS)
{
char b3;
Lcd_RS=cLcd_RS;
b3=cVar & 0xF0; // envoi 4 bit poids fort
pins=pins & 4; // copie du bit lcd_E
pins=pins | b3;
Tempo(255);
pins=pins & 4; // envoi 4 bits poids faible
b3=(cVar<<4);
pins=pins | b3;
Lcd_E;
if((cVar>2) && (Lcd_RS==0)) TMR0=255; // tempo 86µs
else TMR0=228; // tempo 1,7ms
while(TMR0 != 0);
}
void Tempo(char ti)
{
Lcd_E;
TMR0=ti;
while(TMR0 != 0);
}
void Ligne_LCD(char cLigne, char cPosition)
{
if(cLigne==1) wr_Lcd(0x80+cPosition,0); // afficheur ligne 1
else if (cLigne==2) wr_Lcd(0xC0+cPosition,0); // afficheur ligne 2
}
void Efface_LigneLCD(char cEff)
{
if(cEff==1)
{
wr_Lcd(0x80,0); // set DDRAM passe 1 ere ligne
for(cL=0;cL<=15;cL++)wr_Lcd(0x 20,1); // affiche des espaces
}
if(cEff==2)
{
wr_Lcd(0xC0,0); // set DDRAM passe 2 eme ligne
for(cL=0;cL<=15;cL++)wr_Lcd(0x 20,1); // affiche des espaces
}
}
Dernière modification par Fred-ql ; 26/05/2006 à 22h42.
J'ai acheté Proton+ (compilateur Basic), il connait les variables à virgule flottante, à 32 bit.
La gestion LCD est aussi simple que ce que tu viens d'écrire ci-dessus (en Basic).
Pour mon usage perso et amateur, c'est largement suffisant.
Je ne recherche ni la performance ni l'optimisation mais un fonctionnement qui me convienne et surtout me faire plaisir.
Ce n'est que mon avis et je le partage.
Gérard.
Oula, cela me semble être une comparaison un peu inégale ! Dans l'exemple du C, il y a définition et implémentation de toutes les fonctions utilisées dans la communication avec un module LCD ! Dans l'exemple du BASIC, je ne suis pas spécialiste, mais il me semble que seules les constantes (ports, lignes) sont définies, puis une routine toute implémentée s'en charge (LCDOUT).Envoyé par Fred-ql
[...]
alors, c'est quoi le plus simple ?
[...]
Loin de moi l'idée de lancer une comparaison, voire une compétition entre les deux langages (ce serait absolument inutile et absurde), mais avec une routine toute faite en C, le résultat devient le même !
une fonction Message_Lcd() présente dans l'exemple sert d'ailleurs à cela !
La différence c'est que dans l'exemple du C, on voit clairement l'implémentation de celle-ci
Par contre, en rège générale, ce n'est absolument pas à prouver que le BASIC est bien plus simple que le C, je ne remet surtout pas cela en question... Mais un autre exemple aurait peut-être été plus apte à le monter !
... Pour en revenir sur mon compilo C (SDCC pour ne pas le citer), on peut définir une fonction qui prendra en charge la sortie standard : il suffit de préciser que "STDOUT= STREAM_USER", puis de placer sa fonction, celle qui envoie vers le module LCD, par exemple, dans une fonction PUTCHAR()... et nous voilà à écrire directement sur le module LCD à chaque printf()
bonjour,
je ne comprends pas comment fonctionnent vos fonctions "toutes faites" pour piloter un LCD par exemple.
Je ne travaille pas sur des pics, mais le problème est le même: la fonction doit prendre en compte les connexions physiques du lcd au µcontrôleur.
Par exemple, la fonction ne sera pas la même selon que le LCD sera connecté au port A ou au port B, ou bien qu'il sera utilisé en mode 4 bits ou 8 bits.
A+
Salut,
d'accord avec Lolomatic, la comparaison est inégale.
Dans ton exemple en basic n'apparait pas le traitement des transferts de data, ni les routines de formatage, ni les séquences d'écriture sur l'afficheur, ni l'initialisation de l'afficheur, bref y a pas l'essentiel.
Là, c'est sur que c'est plus simple comme ça, sauf que ça marche pas!
bonjour, j'aimerai programmer des 16F628, il faut que je fabrique le programmateur (pas bien compliqué sans doute...). Mais je ne sais que programmer en basic. Alors quel compilateur choisir ? Un gratuit ? Un payant, quel ordre de prix ? Où trouver la doc pour la syntaxe ?... il y a tant de questions...
declare lcd_type 0 ;alphanumerique
declare lcd_dtpin PORTB.4 ;5,6,7 (37 --> 40) 4 lignes de donnees
declare lcd_enpin PORTB.3 ;(36) enable
declare lcd_rspin PORTB.2 ;(35) RS pin
voilà les références des pin
print at 2,3,dec2 hr," : ",dec2 mn," : ",dec2 sec
voilà l'affichage de hr (heures) puis : puis mn (minutes) puis : puis sec (secondes)
ceci sur la 2ème ligne à partir de l'emplacement 3
(print at 2,3 .....)
Et çà marche !
Et c'est du Basic.
Gérard.
Ok, bon je vais tenter de faire une brève comparaison, un tant soit peu objective :
Je ne remets pas en question le fait que les deux exemples fonctionnent ! Les compilateurs BASIC pour microcontroleurs intègrent beaucoup de routines permettant l'utilisation très simple de modules LCD, du bus I²C, One Wire, ou autre, sans parler du PIC lui-même !
Ils sont faits pour prendre en main très rapidement un microcontroleur sans connaissances approfondie de celui-ci , ce qui est parfait pour un débutant ou pour quelqu'un souhaitant boucler rapidement un projet !
Par contre, les compilateurs C, plus orientés vers les initiés, permettent une souplesse d'utilisation et une exploitation bien plus poussée du microcontroleur : on peut faire précisément la même chose qu'en assembleur, mais avec un langage de plus haut niveau ( affecter tous les registres, utiliser les interruptions,...).
Pour cela, il faut quand même une connaissance parfaite de son microcontroleur, car de même qu'en assembleur, si on ne désactive pas les comparateurs ou entrées analogiques, par exemple, cela posera problème sur l'utilisation d'E/S (on sent le vécu...), si on ne configure pas correctement les oscillateurs internes, ça ne se fera pas tout seul... Les exemples ne manquent pas !
Ainsi, si quelqu'un maîtrise parfaitement l'assembleur, et surtout, dispose de routines toutes faites, cela ne vaudra pas le coup de tout réécrire en C ! Par contre, si quelqu'un est un habitué du C, et manipule déjà ce langage (très académique, qui plus est...) tous les jours, il sera tout à fait productif sur n'importe quel microcontroleur !
Je tiens enfin à rajouter que la plupart des compilateurs C disposent, au même titre que les compilateurs BASIC, de routines préconcues permettant également de simplifier les traitements vers des périphériques externes (dont les modules LCD)...
...C'est précisément ce que je dénonçait dans l'exemple précédement cité, car nul besoin dans la plupart des cas de redéfinir un jeu de fonction pour prendre en charge les modules LCD, dans la mesure ou dans tous les compilateurs que j'ai rencontré, ces fonctions y étaient déjà !
Il suffit d'include la bonne librairie et d'appeler la bonne fonction...
Et ça prend deux lignes...
Et ça marche !
Et c'est du C
Pour finir, et pour revenir au sujet, c'est sans hésiter que je conseilles à tout débutant le BASIC ! j'ai moi-même fait mon tout premier programme pour PIC avec un tel compilateur, avant de passer à l'assembleur !
Pour les prix, mieux vaut utiliser un compilateur en version démo et si vous vous découvrez une allergie à l'assembleur ou une folle passion ravageuse pour le BASIC, vous pourrez alors investir dans la version payante !
Un petit lien vers un des spécialistes du domaine en france :
http://www.lextronic.fr/develop/PP2.htm
Voilà ! @+
Ah bon, je suis désolé mais si tu prend HTPIC C qui est quand même une référence, il n'y a pas de bibliothèque toute faite comme tu dis pour afficheur ou autre.Je tiens enfin à rajouter que la plupart des compilateurs C disposent, au même titre que les compilateurs BASIC, de routines préconcues permettant également de simplifier les traitements vers des périphériques externes (dont les modules LCD)...
...C'est précisément ce que je dénonçait dans l'exemple précédement cité, car nul besoin dans la plupart des cas de redéfinir un jeu de fonction pour prendre en charge les modules LCD, dans la mesure ou dans tous les compilateurs que j'ai rencontré, ces fonctions y étaient déjà !
Il suffit d'include la bonne librairie et d'appeler la bonne fonction...
Et ça prend deux lignes...
Et ça marche !
Et c'est du C
Je sais que certain autres compilos proposent des bibliothèques toute faites mais souvent intransportable vers d'autres µC car ils utilisent du pseudo C non ANSI.
Des fonctions oui (math.h,...), des macro commandes spécifiques (lcd.h,...), non.
Moi qui doutait de l'absence de telles librairies dans certains compilateurs, me voilà informé
Si on prend ce qui est pour moi LE compilateur de référence, à savoir C18 (c'est celui de Microchip quand même), on a bien une telle routine (xlcd.h il me semble) qui permet de manipuler de différentes manières un module LCD (envoi de commande, de caractère, de chaine de caractère, etc...).
Un autre compilateur, celui de mikroelektronica : MikroC, supporte aussi ce genre de routines. (http://www.lextronic.fr/mikro/compil/PP1x2.htm)
Pour ce qui est de la portabilité, j'avoue ne pas avoir compris la remarque : en général, lorsque le compilateur C fournit ce genre de librairies, il se débrouille pour qu'elle soit utilisable sur tous les modèles supportés... conformes ANSI C ou pas !
Ce qui arrange le plus les éditeurs, c'est surtout que ces librairies soient utilisables (et portables) sur toutes les architectures supportées par leur produit (encore heureux, vu leur prix...)
A ce sujet, de nombreux compilateurs (pour PC y compris) ne sont pas à 100% conformes à la norme ANSI, mais ça ne nuit pas systématiquement à la portabilité !
Voilà, j'espère ne pas avoir mal interprêté la remarque précédente.
@+
MikroC n'est pas ANSI et je boycott personnellement ceux qui ne respectent pas une norme établie selon des règles qui font l'intégrité d'un langage.Moi qui doutait de l'absence de telles librairies dans certains compilateurs, me voilà informé
Si on prend ce qui est pour moi LE compilateur de référence, à savoir C18 (c'est celui de Microchip quand même), on a bien une telle routine (xlcd.h il me semble) qui permet de manipuler de différentes manières un module LCD (envoi de commande, de caractère, de chaine de caractère, etc...).
Un autre compilateur, celui de mikroelektronica : MikroC, supporte aussi ce genre de routines.
C'est comme si on admettait de se passer des accents dans la langue française sous prétexte que certain sont gênés ou qu'il trouvent ça inutile.
J'estime que c'est nuisible.
Quant à C18 il a l'intérêt d'être gratuit, mais de là à dire que c'est le meilleur...
Tu serais surpris de voir les bibliothèques pourries qui circulent chez certains éditeurs...
Ca nuit forcément.A ce sujet, de nombreux compilateurs (pour PC y compris) ne sont pas à 100% conformes à la norme ANSI, mais ça ne nuit pas systématiquement à la portabilité !
Finalement ça me fait penser aux débats sur les CAO où le parallèle peut se faire si l'on tient compte des empreintes foireuses ou aux schématiques pleine de boulettes.
Comme par hasard c'est toujours les logiciels qui ont une myriade de librairies qui sont les plus craignos...
En effet, je suis tout à fait d'accord sur le principe, mais je tolère néanmoins que certains s'éloignent un peu des normes à une condition : si c'est à l'avantage du programmeur !
Je ne sais pas si les éditeurs peuvent se permettre de faire des bibliothèques pleinement portables et normalisées sur des architectures et du matériel nécessitant autant d'optimisation que des microcontroleurs !
Un exemple concret serait peut-être la fonction indispensable qu'est printf() Pour laquelle nombre de compilateurs ont vite faits d'abandonner la version ANSI afin de faire une version optimisée et spécifique !
Je n'ai tout simplement pas une connaissance suffisante de la norme ANSI C pour juger de conformité ou non d'un compilateur, et de son incidence sur la portabilité d'un code !
Tu as l'air bien plus renseigné que moi sur le sujet, et si tu soutiens que c'est nuisible, je te crois alors sur parole !
Je n'ai pas dit que c'était le meilleur ! Je ne peux d'ailleurs pas le dire, étant donné que je n'ai qu'une expérience limitée quand à l'utilisation de compilateurs C pour PIC !
J'ai dit que C18 est pour moi le compilateur de référence, parce qu'il vient de Microchip (et qu'il n'est pas mauvais dut tout, ceci dit...) ! A partir de ça, je m'en sert pour juger les autres compilateurs : s'ils sont moins bons (proposent moins d'optimisations, moins de librairies) ou s'ils sont meilleurs (j'admet tout à fait que ce soit possible, et c'est même rassurant de le savoir!)
Oula !Ce n'est pas moi qui dirai le contraire :c) J'ai déjà eu l'occasion de l'être ! Sous prétexte que le langage C est permissif et souple, on nous livre parfois vraiment n'importe quoi, et documenté n'importe comment !
J'en ai fait l'expérience sur un projet avec un microcontroleur SC12 (de BECK - FESTO), le compilateur C est livré avec un nombre impressionnant de librairies, mais lorsqu'on se retrouve à être obligé d'éplucher les sources des librairies pour savoir comment elles fonctionnent, on est d'accord sur le fait qu'on peut les qualifier de "bibliothèques pourries" ;c)
Pour l'info: une des bourdes concernait la librairie de gestion de l'UART, qui prenait en entrée un "int", soit 16 bits sur cette architecture, pour envoyer un caractère de 8 bits ! Après examen des sources, on s'apperçoit que la fonction prend le paramètre et le met aussi sec dans le registre AL - qui a une taille d'un octet - obligeant à faire un cast !!! Et c'est pas le seul exemple !
@+
merci de toute ces réponses
j'ai encore une petite question
si je veut programmer en assembleur quel programme je doit utiliser en gratuit de préférence
ensuite j'ai un petit servisse a demander j'ai pas de Programmateur pour pic je souhaite en fabriquer un (celui la) seulement je n'est pas de machine a insoler et graver les CI es que quelqu'un pourrai me le faire en échange de quelque euro
merci de votre aide
Bonsoir, Zelio
Je ne saurais pas te faire ce circuit imprimé, mais j'en ai encore quelques uns du programmateur :
http://www.68hc08.net/modules/news/a...php?storyid=73
C''est pas du pic, mais c'est tout aussi bien (et même largement mieux).
Si tu en veux un, envoie moi un MP.
Le compilateur C/C++ (CodeWarrior) est téléchargeable gratuit sur www.freescale.com
Thierry
Le Monsieur veut programmer des PIC !
http://kudelsko.free.fr/
rubrique programmateur
L'assembleur est dispo chez Microchip gratuitement.
Gérard.
salut tout le monde j'ai fait un programme en assembleur au cours d'un projet et mon tuteur m'a demandé de le traduire en c comment dois-je procéder
1_choisir un compilateur C
2_lire la doc
3_traduire de l'asm en C
Bon courage
Gérard.
