Comprendre les bases de la programmation PIC

[djviper16]

Bonjour à tous,

Merci de m'accueillir sur votre forum, Jérôme, 30 ans, à mon compte depuis 8 ans dans le domaine de l'usinage.
Je suis présent sur le forum usinages.com comme d'autres ici (j'ai aperçu F6FCO), notamment pour parler de la fabrication de ma fraiseuse CNC.

Je suis sorti de BTS électronique il y a plus de 10 ans, et aujourd'hui je voudrai me remettre à la programmation des PIC.
Et surtout, prendre le temps de comprendre ce que je fais, ce qui n'était pas le cas quand j'étais étudiant.

Parce que prendre un projet tout fait pour modifier quelques lignes, je trouve que c'est du bricolage. Ca marche, mais on ne sait pas vraiment comment ni pourquoi.

En matériel dispose d'un clone pickit2, de quelques pic des familles 12F, 16F, 18F et 30F.
Et logiciellement je suis sous MPLAB IDE v8.10 + compilateur CCS.

Depuis quelques jours je m'amuse avec un PIC16F628 et je me pose de nombreuses questions.
Je jongle continuellement entre l'aide de CCS et la datasheet du pic mais j'ai du mal.

Premièrement, parlons du fichier header (PIC16F628.h), puisque c'est lui qui apparaît en première ligne du programme en C (#include <16F628.h>).
D'après ce que j'ai compris, on doit utiliser le fichier compatible avec notre compilateur, donc celui fourni par CCS.
Ensuite tout ce que je ne comprends pas :
- à quoi sert ce fichier concrètement ?
- "#nolist" d'après la doc CCS c'est une commande "pré-processeur", qui permet de ne pas encombrer le fichier ".LST". Je suis allé voir ce fichier ".LST" dans l'un de mes projets, et il semblerait que ce soit un mélange de mon programme et de ce programme converti en langage assembleur. La commande "#nolist" permet donc de ne pas transcrire le fichier header ?
- "#define PIN_A0 40" je ne comprends pas pourquoi "40". C'est écrit en décimal puisqu'il n'y a pas de "0x" devant. C'est une adresse ? Ça sert à quoi et pourquoi ? En gros je comprends pas à quoi sert la commande "#define". D'après la doc CCS ça me permettrait d'écrire "PIN_A0" au lieu de "40" dans mon code en C.


Bon j'arrête là, des questions comme ça j'en ai plein. Déjà si vous pouvez me renseigner là dessus ce sera bien.

[Temps-x]

Bonjour djviper16, et tout le forum,

Bienvenu sur le forum,

Je suis pas dans ma section, car moi, je suis plutôt orienté ASM, je qui me rapproche le plus possible de l'électronique et la compréhension du microcontrôleur.

Si tu veux comprendre ton microcontrôleur, et les routines qui son caché dans le compilateur C il faut faire de l'assembleur.

Bon je retourne dans ma section, parce que je sens que je vais me faire jeté....

A+

[satinas]

Bonjour djviper16 et bienvenue

et bonjour au prosélyte Temps-x

Tu innoves, je pense pas qu'il y ait des pratiquants du compilateur CCS ici.
C'est un compilateur avec pas mal de bibliothèques comme MikroC, contrairement aux autres compilateurs C18, C30, xc8, xc16 qui proposent plutôt le C de base.

Le "#define" est une directive importante du C, quel est ton niveau dans ce langage ?
Pour chaque type de processeur il y a un fichier include attribuant avec #define des noms à des valeurs numériques, afin de rendre les arguments de fonction plus lisibles, par exemple. Je vois pas dans ces fichiers include la liste des registres SFR du pic, cela veut peut être dire que le compilateur CCS permet de s'en passer, je sais pas.

Pour la ligne "#define PIN_A0 40", ils en parlent dans la doc CCS.
Comme on est souvent amené à lire ou modifier l'état d'un seul bit d'un port, ces bits sont numérotés à partir de 0.
Les bits 0 à 7 du registre d'adresse 0x00 portent les numéros 0 à 7
Les bits 0 à 7 du registre d'adresse 0x01 portent les numéros 8 à 14
...
Les bits 0 à 7 du registre d'adresse 0x05 portent les numéros 40 à 47
...
Le registre d'adresse 0x05 est PORTA, celui permettant de lire et écrire le port A du pic, donc la pin A0 est désignée par 40. Ensuite CCS fournit des fonctions pour manipuler ces identifiants.
par exemple -> output_low(PIN_A0);

Ensuite il y a la directive #bit qui est elle aussi permet de désigner un bit de registre ou variable.
Tout cela sous réserve, j'ai jamais programmé avec CCS.
https://www.technologuepro.com/microcon ... s-pcwh.htm

[Jérémy]

Welcome djviper16 ,

Effectivement CCS n,'est pas un compilateur extrêmement utilisé par ici. Cependant certaines syntaxe sont similaire ou transposable facilement.

A+

[djviper16]

Merci pour l'accueil chaleureux.

@Temps-x ne m'en veut pas mais l'assembleur ne m'a jamais emballé, je me souviens avoir déjà fait clignoté une led au lycée mais pas plus.
Le compilateur transforme le C en ASM puis en hexa puis en binaire pour programmer le pic ?

@satinas CCS était le compilateur utilisé au lycée avec MPLAB, les profs nous avaient passé une licence donc je continue de l'utiliser.
MikroC il est gratuit ? On m'a donné une carte de dev Easypic4 et il me semble qu'il faut utiliser ce compilateur.
Au lycée j'utilisais une "picdem2plus" avec l'icd2.

Il me semble avoir lu que le langage C est "transposable", donc il ne devrait pas y avoir de différence dans les programmes qu'on utilise l'un ou l'autre compilateur si ?

Mon niveau est "débutant", pendant ma scolarité j'ai fait des projets utilisant les timers avec leurs flags, pwm, lcd et autres mais j'ai presque tout oublié.
Si j'ai oublié c'est parce qu'il fallait aller vite, je n'avais pas le temps de comprendre et assimiler ce que je faisais.
Je n'ai jamais programmé autre chose que des pic en langage C. Par contre je pratique quotidiennement le langage gcode. Je suis patient, tenace et rigoureux donc, j'espère, apte à la conception d'un programme informatique.

Je ne saurai pas te dire pour les registres SFR. Les fichiers "header" ou "include" sont équivalents ? En fonction du type de compilateur utilisé ?

Je comprends mieux pour "#define PIN_A0 40", grâce à toi déjà je comprends pourquoi "40", mais je ne comprends toujours pas pourquoi ils n'ont pas fait par exemple un "#define PIN_A0 0x05.0"...

@Jérémy Quelles sont les différences qui te sautent aux yeux ? Vous utilisez tous MikroC ici ?


Ci joint mon fichier ".h"

Code : Tout sélectionner

//////// Standard Header file for the PIC16F628 device ////////////////
#device PIC16F628
#nolist
//////// Program memory: 2048x14  Data RAM: 223  Stack: 8
//////// I/O: 16   Analog Pins: 0
//////// Data EEPROM: 128
//////// C Scratch area: 77   ID Location: 2000
//////// Fuses: LP,XT,HS,EC,NOWDT,WDT,NOPUT,PUT,PROTECT,PROTECT_50%
//////// Fuses: PROTECT_75%,NOPROTECT,NOBROWNOUT,BROWNOUT,MCLR,NOMCLR,LVP
//////// Fuses: NOLVP,ER_IO,INTRC_IO,ER,INTRC,CPD,NOCPD
//////// 
////////////////////////////////////////////////////////////////// I/O
// Discrete I/O Functions: SET_TRIS_x(), OUTPUT_x(), INPUT_x(),
//                         PORT_B_PULLUPS(), INPUT(),
//                         OUTPUT_LOW(), OUTPUT_HIGH(),
//                         OUTPUT_FLOAT(), OUTPUT_BIT()
// Constants used to identify pins in the above are:

#define PIN_A0  40
#define PIN_A1  41
#define PIN_A2  42
#define PIN_A3  43
#define PIN_A4  44
#define PIN_A5  45
#define PIN_A6  46
#define PIN_A7  47

#define PIN_B0  48
#define PIN_B1  49
#define PIN_B2  50
#define PIN_B3  51
#define PIN_B4  52
#define PIN_B5  53
#define PIN_B6  54
#define PIN_B7  55

////////////////////////////////////////////////////////////////// Useful defines
#define FALSE 0
#define TRUE 1

#define BYTE int
#define BOOLEAN short int

#define getc getch
#define fgetc getch
#define getchar getch
#define putc putchar
#define fputc putchar
#define fgets gets
#define fputs puts

////////////////////////////////////////////////////////////////// Control
// Control Functions:  RESET_CPU(), SLEEP(), RESTART_CAUSE()
// Constants returned from RESTART_CAUSE() are:
#define WDT_FROM_SLEEP  0     
#define WDT_TIMEOUT     8     
#define MCLR_FROM_SLEEP 16    
#define NORMAL_POWER_UP 24    


////////////////////////////////////////////////////////////////// Timer 0
// Timer 0 (AKA RTCC)Functions: SETUP_COUNTERS() or SETUP_TIMER0(),
//                              SET_TIMER0() or SET_RTCC(),
//                              GET_TIMER0() or GET_RTCC()
// Constants used for SETUP_TIMER0() are:
#define RTCC_INTERNAL   0
#define RTCC_EXT_L_TO_H 32
#define RTCC_EXT_H_TO_L 48

#define RTCC_DIV_1      8
#define RTCC_DIV_2      0
#define RTCC_DIV_4      1
#define RTCC_DIV_8      2
#define RTCC_DIV_16     3
#define RTCC_DIV_32     4
#define RTCC_DIV_64     5
#define RTCC_DIV_128    6
#define RTCC_DIV_256    7


#define RTCC_8_BIT      0     

// Constants used for SETUP_COUNTERS() are the above
// constants for the 1st param and the following for
// the 2nd param:

////////////////////////////////////////////////////////////////// WDT
// Watch Dog Timer Functions: SETUP_WDT() or SETUP_COUNTERS() (see above)
//                            RESTART_WDT()
//
#define WDT_18MS        8   
#define WDT_36MS        9   
#define WDT_72MS       10   
#define WDT_144MS      11   
#define WDT_288MS      12   
#define WDT_576MS      13   
#define WDT_1152MS     14   
#define WDT_2304MS     15   

////////////////////////////////////////////////////////////////// Timer 1
// Timer 1 Functions: SETUP_TIMER_1, GET_TIMER1, SET_TIMER1
// Constants used for SETUP_TIMER_1() are:
//      (or (via |) together constants from each group)
#define T1_DISABLED         0
#define T1_INTERNAL         0x85
#define T1_EXTERNAL         0x87
#define T1_EXTERNAL_SYNC    0x83

#define T1_CLK_OUT          8

#define T1_DIV_BY_1         0
#define T1_DIV_BY_2         0x10
#define T1_DIV_BY_4         0x20
#define T1_DIV_BY_8         0x30

////////////////////////////////////////////////////////////////// Timer 2
// Timer 2 Functions: SETUP_TIMER_2, GET_TIMER2, SET_TIMER2
// Constants used for SETUP_TIMER_2() are:
#define T2_DISABLED         0
#define T2_DIV_BY_1         4
#define T2_DIV_BY_4         5
#define T2_DIV_BY_16        6

////////////////////////////////////////////////////////////////// CCP
// CCP Functions: SETUP_CCPx, SET_PWMx_DUTY
// CCP Variables: CCP_x, CCP_x_LOW, CCP_x_HIGH
// Constants used for SETUP_CCPx() are:
#define CCP_OFF                         0
#define CCP_CAPTURE_FE                  4
#define CCP_CAPTURE_RE                  5
#define CCP_CAPTURE_DIV_4               6
#define CCP_CAPTURE_DIV_16              7
#define CCP_COMPARE_SET_ON_MATCH        8
#define CCP_COMPARE_CLR_ON_MATCH        9
#define CCP_COMPARE_INT                 0xA
#define CCP_COMPARE_RESET_TIMER         0xB
#define CCP_PWM                         0xC
#define CCP_PWM_PLUS_1                  0x1c
#define CCP_PWM_PLUS_2                  0x2c
#define CCP_PWM_PLUS_3                  0x3c
long CCP_1;
#byte   CCP_1    =                      0x15        
#byte   CCP_1_LOW=                      0x15        
#byte   CCP_1_HIGH=                     0x16        
////////////////////////////////////////////////////////////////// UART
// Constants used in setup_uart() are:
// FALSE - Turn UART off
// TRUE  - Turn UART on
////////////////////////////////////////////////////////////////// COMP
// Comparator Variables: C1OUT, C2OUT
// Constants used in setup_comparators() are:
#define A0_A3_A1_A2  0xfff04
#define A0_A2_A1_A2  0x7ff03
#define NC_NC_A1_A2  0x6ff05
#define NC_NC_NC_NC  0x0ff07
#define A0_VR_A1_VR  0x3ff02
#define A3_VR_A2_VR  0xcff0A
#define A0_A2_A1_A2_OUT_ON_A3_A4 0x7e706
#define A3_A2_A1_A2  0xeff09

#bit C1OUT = 0x1f.6
#bit C2OUT = 0x1f.7

////////////////////////////////////////////////////////////////// VREF
// Constants used in setup_vref() are:
//
#define VREF_LOW  0xa0
#define VREF_HIGH 0x80
// Or (with |) the above with a number 0-15
#define VREF_A2   0x40

////////////////////////////////////////////////////////////////// INT
// Interrupt Functions: ENABLE_INTERRUPTS(), DISABLE_INTERRUPTS(),
//                      EXT_INT_EDGE()
//
// Constants used in EXT_INT_EDGE() are:
#define L_TO_H              0x40
#define H_TO_L                 0
// Constants used in ENABLE/DISABLE_INTERRUPTS() are:
#define GLOBAL                    0x0BC0
#define INT_RTCC                  0x0B20
#define INT_RB                    0x0B08
#define INT_EXT                   0x0B10
#define INT_TBE                   0x8C10
#define INT_RDA                   0x8C20
#define INT_TIMER1                0x8C01
#define INT_TIMER2                0x8C02
#define INT_CCP1                  0x8C04
#define INT_LCD                   0x8C80
#define INT_COMP                  0x8C40
#define INT_EEPROM                0x0B40
#define INT_TIMER0                0x0B20

#list 

[satinas]

Je comprends mieux pour "#define PIN_A0 40", grâce à toi déjà je comprends pourquoi "40", mais je ne comprends toujours pas pourquoi ils n'ont pas fait par exemple un "#define PIN_A0 0x05.0"...

Parce que ces defines vont avec les fonctions input, output, toggle,... et ces fonctions sont les mêmes pour tous les modèles de pic, mais le code qu'elles génèrent n'est pas le même, car entre un 16F et un 32MX il y a des différences. Arduino et sans doute MikroC, c'est pareil, il y a des fonctions génériques, implémentées selon le type de processeur.

#define PIN_A0 0x05.0
Tu en fais quoi de cette ligne ?

Plutôt, pour l'équivalent à la fonction output :

// 16F
#byte PORTA = 5
#bit pin_A0 = PORTA,0
pin_A0 = 1

// 18F
#byte LATA = 0xF89H
#bit pin_A0 = LATA,0
pin_A0 = 1

IL doit y avoir un autre ficher include avec les registres, et donc contenant "#byte PORTA = 5"

[Jérémy]

Pour ma part, à l'époque ou j'ai commencé la programmation sur PIC, j'ai longtemps bouquiné et recherché le compilateur qui me plairait. 2 choix était évident MPLAB ou MIKROC , j'ai opté pour MIKROC avec sa carte EASYPIC et les modules.
Les 2 deux ou leurs défauts et inconvénients. Ici il y a un peu de tout.

Je suis capable de lire et comprendre un programme écrit pour MPLAB, mais pas de le faire à cause de cette syntaxe, mais c'est juste une question d'habitude. Les exemple de syntaxes comme pour les delay par exemple ou pour les déclarations et autres petit truc.

[satinas]

output(0x05.0)
essaie de compiler cela :)

Des fonctions C de ce type éviteraient les defines.
output_low(port, pin)
output_high(port, pin)

J'utilise MpLab avec C18 pour les 18F, C30 pour le 30F, C32 pour les 32 bits.
Et leurs successeurs sous MpLabX xc8, xc16, xc32, mais MpLabX m'interdit le double écran :(

[paulfjujo]

bonsoir,

...mais MpLabX m'interdit le double écran :(

j'utilise 2 ecrans: 1 de 27" et 1 de 21" avec MPLABX 5.30 et XC8 WIN10
on peut doker n'importe quelle vue (window) sur le 2 em ecran
j'ai 2 cartes videos dans le PC ( Intel de base + Nvidia Geforce)

tres confortable pour mettre la datasheet d'un coté et MPLab de l'autre

[satinas]

J'espérais qu'avec les nouvelles versions de MpLabX, ça s'arrangerait, mais que nenni.
Il aime pas la carte AMD Radeon HD5450.

En C on peut créer une variable de taille 1 bit, elle est stockée dans un octet avec d'autres, or le processeur n'adresse que des octets, pas des bits. C'est pour cela qu'ils ont créé ces defines spécifiques permettant d'adresser un bit particulier du port, avec des fonctions elles-mêmes spécifiques.

Pour le reste #bit permet de créer des variables bit, mais non adressables.
#bit pin PORTA,0
on peut faire :
pin = 1;
pin = 0;
pin = !pin;
v = pin; // v passe à 0 ou 1
l'adresse de pin n'est pas accessible, on ne peut pas faire :
output_low(&pin)