Débuter pour programmation Scripts Bash et Flowcode/Grafcet

Version imprimable

26/12/2007, 21h59
sdumasp

Débuter pour programmation Scripts Bash et Flowcode/Grafcet

Bonjour,
Je suis lycéen en Terminale et je voudrais faire mes débuts dans la programmation mais je ne sais pas trop par où commencer.

J'utilise un peu la programmation en cours de SI au lycée, je crois que c'est du C mais ça prend la forme de blocs, on fait la programmation sous Flowcode ou Automgen (des grafcets). Donc j'aimerais pouvoir maitriser un peu plus la programmation que le simple assemblage de blocs.
Je suis aussi sous Linux et j'aimerais pouvoir faire mes propres scripts assez facilement pour pas mal de trucs et j'ai l'impression que la plupart des scripts que je trouve sur internet sont écris en C (mais encore une fois je n'y ai jamais touché :P).

Donc j'aimerais savoir par où il faut que je commence? Je pense plutôt partir sur le C mais n'y-a-t-il pas d'autres choses à apprendre d'abord? Et j'ai intérêt à démarrer par le C ou plutot C++ ou C#?

Enfin voilà j'aimerais prendre des conseils pour débuter correctement :)

Merci!
sdumasp
26/12/2007, 23h44
sdumasp

Oups, fausse question manifestement le C, le C++ et le C# ne sont pas vraiment la même chose enfin ne sont pas cousins... si j'ai bien compris...
Quelle est la différence?
Peut-on les apprendre les usn après les autres?

Et Flowcode est bien un interpréteur de C
29/12/2007, 15h42
Woufeil

Bonjour,

Ce qu'il faut savoir en programmation, c'est que les langages ne sont bons ou mauvais que dans un contexte particulier. Quels sont tes objectifs ? Est ce un apprentissage de la programmation que tu souhaites ? Ou juste développer des scripts par exemple ?
Si c'est le second cas, tu peux effectivemment faire du C mais... Tu utilises un lance roquette pour abattre une fourmi... Tu as des langages bien plus adapté, comme Perl par exemple.

Si ton but est de développer des applications proche du système ou embarquée, alors oui le C est une bonne idée.

Bref, parle nous de tes objectifs précis et on te conseillera un langage en conséquence ;)
29/12/2007, 15h53
sdumasp

merci pour cette réponse.

ben en ce qui concerne mes ambitions :
- apprendre à programmer (bon même si j'en ai pas vraiment une grande utilité, ça me botterait bien de savoir programmer ou en tout cas maitriser un langage de programmation)
- pouvoir comprenre, corriger voire carrément programmer moi-même les programmes que je fais en cours via Flowcode (parce que ça m'énerve de coller trois boîtes et de me prendre pour un programmeur alors que quand je compiles mes boiboites en C je comprends rien au source)
- faire des exécutables sous Linux qui me permettent d'exécuter des commandes dans le shell (ben en gros des scripts mais si j'ai besoin du C pour les deux points au-dessus autant me contenter du C pour ces trois points d'autant ue j'ai vu sur internet qu'il existe des librairies contenant des fonctions pour lancer des commandes dans el shell j'en ai même déjà fait l'essai)

Voilà pour mes ambitions!
29/12/2007, 16h02
Woufeil

Pour le premier et le dernier point, le C n'est pas adapté, ça serait une mauvaise idée de l'utiliser pour ça même... Par contre, pour le second, le C semble être le seul langage possible je pense bien.

Mais de toute façon, FlowCode doit surement utiliser des librairies très spécifiques. C'est de la programmation de micro-contrôleurs, donc ce n'est pas du C comme tu vas l'apprendre sur internet je pense. A toi de voir...

Sinon, je te conseille de regarder Python ou Perl pour les deux autres points ;)
29/12/2007, 16h34
sdumasp

je suis déjà parti sur le C de toutes façons...
en plus j'avais déjà abordé un peu le C il y a 2 ou 3 ans en lisant un livre sur la programmation en général et rien que le début d'apprentissage que je fais j'ai l'impression de bien saisir le schmilblik.

en ce qui concerne Flowcode j'ai depuis le début de mon apprentissage du C compilé en C un programme que j'avais fais avec mes boîboîtes et ça m'a l'air (du haut de mes pauvres compétences :D ) d'être du C plutôt formel.
il me suffirait juste une fois le C à peu près maitrisé d'utiliser les inclusions de sources en en-tête d'un programme de Flowcode et de potasser un peu ça pour voir quelles sont les entrées/sorties relatives ou PIC que j'utilise pour pouvoir faire mon truc tout seul.

enfin bon de toutes façon je ne fais pas ça dans un but professionnel c'est surtout pour em faire plaisir que je tente d'apprendre le C donc dans le pire des cas si je n'arrive pas à faire ce que je veux en scripts et en programmation de microcontrolleur, j'aurais au moins eu le plaisir d'apprendre (ou dans tous les cas d'apprendre le début :P )

aurais-tu des livres à me conseiller?
on m'a déjà conseille Delannoy.
sinon les cours disponibles sur développez.net (surtout celui de Bernard Cassagne,une longue introduction au C de 230 pages) sont-ils libres de droit? càd est-ce que je peux les faire imprimer?

merci! :)
07/01/2008, 22h37
christian22

flowcode et l'assembleur

Salut sdumap,
Le code C pour flowcode étant trés particulier, j'ai essayé le code asm, mais je ne suis jamais arrivé à compiler vers hex.
Si tu as vécu cette situation répond sur le forum, peut-être trouverons-nous une solution qui comme pour le code c serait une question de syntaxe
merci pour ta réponse
Christian
13/01/2008, 19h00
sdumasp

je n'ai pour l'instant jamais essayé de compiler pour une plateforme PIC un programme écrit avec autre chose que Flowcode

mais j'ai déjà compilé quelques trucs de Flowcode en C pour voir ce que ça donnait et je pense que c'est faisable de compiler son propre truc.
il faut d'abord faire la base via Flowcode pour avoir tous les #define, #include et les déclarations de variables et taper le reste à la main d'autant plus que c'est amplement commenté et donc compréhensible.
maintenant ça reste à tester parce que j'ai jamais essayé et je me sens pas encore l'âme assez initiée au C.
par contre je pense qu'il y a moyen (du moins à mon niveau ça doit être un minimum) de retaper quelques parties du code une fois tout fait sur Flowcode de façon à pouvoir faire des choses que l'on ne peut pas sous Flowcode.

voilà ce que j'en pense pour ma part :) mais je suis pas du tout expérimenté en langage C pour être sur de tout ça.

sinon qu'est-ce que l'asm et qu'as-tu essayé de faire?
22/01/2008, 14h11
Thierry Chappuis

Si ton but est de te faire plaisir en apprenant le C, tu trouveras un excellent complément d'information sur le site d'Emmanuel Delahaye: http://emmanuel-delahaye.developpez.com/. La FAQ C et le forum C de developpez sont aussi de très bonnes ressources lorsque quelque chose ne te semble pas clair.

En ce qui concerne les livres, je ne recommande en général pas ceux de Delannoye, quoi que celui sur le C me paraît être le moins mauvais. L'ouvrage de Kernighan et Ritchie est une excellente référence, mais pas très pédagogique. Je recommande "Méthodologie de la programmation en C" de Achille Braquelaire.

J'ai du mal à recommander le C comme premier langage. Python, Ruby ou autre Scheme sont à mon avis plus abordables et moins "dangereux". Le C est un outils complexe et subtile.

Thierry
22/01/2008, 17h30
sdumasp

merci beaucoup :)
Mais j'ai déjà eu le temps de finir le bouquin de Delannoy "Programmer en C" j'ai aussi lu pas mal de cours trouvé sur internet notamment sur le site de developpez.com (Bertrand Cassagne, Frederic Lang, Henri Garreta et compères...)
Je suis aussi en train de finir un bouquin d'exercices de Delannoy et j'ai pris quelques leçons de rigueur grâce à Emmanuel Delahaye :P

as-tu des liens ou des références de bouquins pour approfondir la programmation en C après avoir vu déjà ce que je viens de citer?

merci! :)
22/01/2008, 18h38
Thierry Chappuis

Citation:

Envoyé par sdumasp

as-tu des liens ou des références de bouquins pour approfondir la programmation en C après avoir vu déjà ce que je viens de citer?

merci! :)

Je n'ai pas beaucoup d'ouvrages en français à conseiller, mais C en action chez O'Reilly me être une bonne suite.

Thierry
22/01/2008, 19h30
sdumasp

ok merci je regarde ça!
mais à la rigueur donne-moi tes références anglaise je pense que ça devrait le faire si je me renseigne sur le vocabulaire particulier

syntaxe asm dans le code c de flowcode

à force de poser de me poser des questions, j'y suis arrivé et pour vous aider je vous ai rédigé ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Ecriture dans un bloc C de FLOWCODE
//Les instructions du pic sont notées en majuscules ou minuscules
//Les Variables utilisées dans flowcode doivent être définies 
//avant d'être utilisées en majuscules précédées de _FCV_ dans l'ASM
//Chaque ligne de remarque doit être précédée de // ou de ;
//L'accu doit être noté W (en majuscule)
//Les registres source du pic doivent être notés _tmr0 (en minuscules)
//Les registres cible sont notés en MAJUSCULES
//Avant d'écrire un prg asm,il est utile de compiler vers Hex le début
//du prg compris entre "DEBUT - variables définies=0 - END", d'afficher
//l'ASM pour noter les adresses des variables utilisées.
//Exemple d'un prog asm dans un code C (ce prog ne sert à rien mais 
//explique la syntaxe asm de flowcode)
//BON AMUSEMENT
//Christian MICHEL

asm
{
    NOP;    remarque         opération blanche  
    NOP
    CLRW;                    accu W=0
    CLRWDT;                  chien de garde = 0
    CLRF   _FCV_Z;           z = 0
    movlw  4;                accu W = 4
    MOVWF  _FCV_X;           W --> x
    MOVF   _FCV_Y,0;         contenu de y --> accu W (accu = y)
    INCF   _FCV_Y,1;         y = y + 1 (résultat dans registre (y))
    INCF   _FCV_Y,0;         y + 1     (résultat dans W ) 
    INCF   _FCV_Y,0;         y + 1     (résultat dans W )
    INCF   _FCV_Y,1;         y = y + 1 (résultat dans y )
    DECF   _FCV_Y,0//        y - 1     (résultat dans W )
    COMF   _FCV_Y,1//        accu W = complément de y
    BTFSS  _FCV_Y,3;         si b3 de y = 1 l'instruction suivante est ignorée
    XORWF  _FCV_Y,1;         W = W excl or (y)
    XORLW  11;               W = W excl or 0B
    ANDLW  5//  remarque     W = W and 05
    ANDWF  _FCV_Y,0;         W = W and (y)
    ADDWF  _FCV_Y,0;         W = W + (y)
    IORWF  _FCV_Y,1;         y = W inclusif or y         
    MOVF   _FCV_Y,1;         y --> accu (résultat dans registre (y))
    movf   _tmr0,0;          timer0 --> accu
    movwf  _FCV_N;           accu --> n
    rlf    _FCV_N,0;         W = (glissement à gauche de n) 
    rrf    _FCV_N,1;         n = (glissement à droite de n)
    movwf  _tmr0;            accu --> timer0
    clrf   _tmr0;            timer0 = 0 
    SWAPF  _status,0;        accu = permutation des tétrades L et H
    movf   _status,0;        status --> accu
    movlw  4;                accu = 04
    movwf  _FCV_X;           accu --> x
   
    nop;                exemple d'adressage indirect 
    movlw  50;               accu W = 32h
    movwf  _FCV_MAVARIABLE;  mavariable = accu = 32h
    movlw  17;               17=11h=adresse de mavariable --> accu W
    movwf  _fsr;             11h --> fsr (fsr pointe sur mavariable)
    movf   _indf,0;  (contenu de indf)--> accu =(contenu de l'ad 50=32h)
    nop;                adressage indirect FIN
    bsf    _intcon,7;        bit7 de intcon = 1
    bcf    _intcon,3
    bcf    _intcon,6;        bit6 de intcon = 0
    bcf    _intcon,5
    BSF    _intcon,4
    BCF    _intcon,2
    bcf    _intcon,1
    BCF    _intcon,0
    sleep;                   pic en somnolence
    NOP
    NOP
}

Voici le programme assembleur de l’exemple (notez l’adresse de mavariable définie en minuscules dans organigramme flowcode)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
;/////////////////////////////////////////////////////////////////////////////////
;// Code Generator: BoostC Compiler - http://www.sourceboost.com
;// Version       : 6.70
;// License Type  : Standard License
;// Limitations   : PIC12,PIC16 max code size:4096 words, max RAM banks:Unlimited, Non commercial use only
;/////////////////////////////////////////////////////////////////////////////////

	include "P16F84A.inc"
; Heap block 0, size:62 (0x00000012 - 0x0000004F)
__HEAP_BLOCK0_BANK               EQU	0x00000000
__HEAP_BLOCK0_START_OFFSET       EQU	0x00000012
__HEAP_BLOCK0_END_OFFSET         EQU	0x0000004F
; Heap block 1, size:0 (0x00000000 - 0x00000000)
__HEAP_BLOCK1_BANK               EQU	0x00000000
__HEAP_BLOCK1_START_OFFSET       EQU	0x00000000
__HEAP_BLOCK1_END_OFFSET         EQU	0x00000000
; Heap block 2, size:0 (0x00000000 - 0x00000000)
__HEAP_BLOCK2_BANK               EQU	0x00000000
__HEAP_BLOCK2_START_OFFSET       EQU	0x00000000
__HEAP_BLOCK2_END_OFFSET         EQU	0x00000000
; Heap block 3, size:0 (0x00000000 - 0x00000000)
__HEAP_BLOCK3_BANK               EQU	0x00000000
__HEAP_BLOCK3_START_OFFSET       EQU	0x00000000
__HEAP_BLOCK3_END_OFFSET         EQU	0x00000000
gbl_status                       EQU	0x00000003 ; bytes:1
gbl_indf                         EQU	0x00000000 ; bytes:1
gbl_tmr0                         EQU	0x00000001 ; bytes:1
gbl_pcl                          EQU	0x00000002 ; bytes:1
gbl_fsr                          EQU	0x00000004 ; bytes:1
gbl_porta                        EQU	0x00000005 ; bytes:1
gbl_portb                        EQU	0x00000006 ; bytes:1
gbl_eedata                       EQU	0x00000008 ; bytes:1
gbl_eeadr                        EQU	0x00000009 ; bytes:1
gbl_pclath                       EQU	0x0000000A ; bytes:1
gbl_intcon                       EQU	0x0000000B ; bytes:1
gbl_option_reg                   EQU	0x00000081 ; bytes:1
gbl_trisa                        EQU	0x00000085 ; bytes:1
gbl_trisb                        EQU	0x00000086 ; bytes:1
gbl_eecon1                       EQU	0x00000088 ; bytes:1
gbl_eecon2                       EQU	0x00000089 ; bytes:1
gbl_FCV_X                        EQU	0x0000000C ; bytes:1
gbl_FCV_Y                        EQU	0x0000000D ; bytes:1
gbl_FCV_Z                        EQU	0x0000000E ; bytes:1
gbl_FCV_N                        EQU	0x0000000F ; bytes:1
gbl_FCV_COUNT                    EQU	0x00000010 ; bytes:1
gbl_FCV_MAVARIABLE               EQU	0x00000011 ; bytes:1
	ORG 0x00000000
	GOTO	_startup
	ORG 0x00000003
main
; { main ; function begin
	MOVLW 0xC0
	BSF STATUS, RP0
	MOVWF gbl_option_reg
	BCF STATUS, RP0
	CLRF gbl_FCV_COUNT
	CLRF gbl_FCV_X
	CLRF gbl_FCV_Y
	CLRF gbl_FCV_Z
	CLRF gbl_FCV_MAVARIABLE
	NOP
	NOP
	CLRW
	CLRWDT
	CLRF gbl_FCV_Z
	MOVLW 0x04
	MOVWF gbl_FCV_X
	MOVF gbl_FCV_Y, W
	INCF gbl_FCV_Y, F
	INCF gbl_FCV_Y, W
	INCF gbl_FCV_Y, W
	INCF gbl_FCV_Y, F
	DECF gbl_FCV_Y, W
	COMF gbl_FCV_Y, F
	BTFSS gbl_FCV_Y,3
	XORWF gbl_FCV_Y, F
	XORLW 0x0B
	ANDLW 0x05
	ANDWF gbl_FCV_Y, W
	ADDWF gbl_FCV_Y, W
	IORWF gbl_FCV_Y, F
	MOVF gbl_FCV_Y, F
	MOVF gbl_tmr0, W
	MOVWF gbl_FCV_N
	RLF gbl_FCV_N, W
	RRF gbl_FCV_N, F
	MOVWF gbl_tmr0
	CLRF gbl_tmr0
	SWAPF gbl_status, W
	MOVF gbl_status, W
	MOVLW 0x04
	MOVWF gbl_FCV_X



	NOP
	MOVLW 0x32
	MOVWF gbl_FCV_MAVARIABLE
	MOVLW 0x11
	MOVWF gbl_fsr
	MOVF gbl_indf, W
	NOP
	BSF gbl_intcon,7
	BCF gbl_intcon,3
	BCF gbl_intcon,6
	BCF gbl_intcon,5
	BSF gbl_intcon,4
	BCF gbl_intcon,2
	BCF gbl_intcon,1
	BCF gbl_intcon,0
	SLEEP
	NOP
	NOP
label268439605
	GOTO	label268439605
; } main function end

	ORG 0x0000003F
_startup
	BCF PCLATH,3
	BCF PCLATH,4
	GOTO	main
	END;

Voici la version C compilée de l’exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
//************************************************************************************
//**  
//**  File name:     G:\rob\exemple.c
//**  Generated by:  Flowcode v3.2.1.38
//**  Date:          Saturday, January 19, 2008 11:54:24
//**  Licence:       Student
//**  
//**  
//**     PAS À USAGE COMMERCIAL
//**  
//**  http://www.matrixmultimedia.com
//************************************************************************************


//Définir pour microcontrôleur
#define P16F84A
#define MX_EE
#define MX_EE_TYPE1
#define MX_EE_SIZE 64

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

//Configuration de données

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

//Déclarations de fonction Macro


//Déclarations de Variable
char FCV_X;
char FCV_Y;
char FCV_Z;
char FCV_N;
char FCV_COUNT;
char FCV_MAVARIABLE;



//Définitions supplémentaires


//Implémentations Macro

//Installation supplémentaire


void main()
{
	
	//Initialisation
	

	//Code d'initialisation d'Interruption
	option_reg = 0xC0;


	//Calcul
	//Calcul:
	//  COUNT = 0
	//  x = 0
	//  y = 0
	//  z = 0
	//  mavariable = 0
	FCV_COUNT =  0 ;
	FCV_X =  0 ;
	FCV_Y =  0 ;
	FCV_Z =  0 ;
	FCV_MAVARIABLE =  0 ;
	

	//Code C
	//Code C:
	//Les instructions du pic sont notées en majuscules ou minuscules
	//Les Variables utilisées dans flowcode doivent être définies 
	//avant d'être utilisées en majuscules précédées de _FCV_ dans l'ASM
	//Chaque ligne de remarque doit être précédée de // ou de ;
	//L'accu doit être noté W (en majuscule)
	//Les registres source du pic doivent être notés _tmr0 (en minuscules)
	//Les registres cible sont notés en MAJUSCULES
	//Avant d'écrire un prg asm,il est utile de compiler vers Hex le début
	//du prg compris entre "DEBUT - variables définies=0 - END", d'afficher
	//l'ASM pour noter les adresses des variables utilisées.
	//Exemple d'un prog asm dans un code C (ce prog ne sert à rien mais 
	//explique la syntaxe asm de flowcode)
	//BON AMUSEMENT
	//Christian MICHEL

	asm
	{
	    NOP;    remarque         opération blanche  
	    NOP
	    CLRW;                    accu W=0
	    CLRWDT;                  chien de garde = 0
	    CLRF   _FCV_Z;           z = 0
	    movlw  4;                accu W = 4
	    MOVWF  _FCV_X;           W --> x
	    MOVF   _FCV_Y,0;         contenu de y --> accu W (accu = y)
	    INCF   _FCV_Y,1;         y = y + 1 (résultat dans registre (y))
	    INCF   _FCV_Y,0;         y + 1     (résultat dans W ) 
	    INCF   _FCV_Y,0;         y + 1     (résultat dans W )
	    INCF   _FCV_Y,1;         y = y + 1 (résultat dans y )
	    DECF   _FCV_Y,0//        y - 1     (résultat dans W )
	    COMF   _FCV_Y,1//        accu W = complément de y
	    BTFSS  _FCV_Y,3;         si b3 de y = 1 l'instruction suivante est ignorée
	    XORWF  _FCV_Y,1;         W = W excl or (y)
	    XORLW  11;               W = W excl or 0B
	    ANDLW  5//  remarque     W = W and 05
	    ANDWF  _FCV_Y,0;         W = W and (y)
	    ADDWF  _FCV_Y,0;         W = W + (y)
	    IORWF  _FCV_Y,1;         y = W inclusif or y         
	    MOVF   _FCV_Y,1;         y --> accu (résultat dans registre (y))
	    movf   _tmr0,0;          timer0 --> accu
	    movwf  _FCV_N;           accu --> n
	    rlf    _FCV_N,0;         W = (glissement à gauche de n) 
	    rrf    _FCV_N,1;         n = (glissement à droite de n)
	    movwf  _tmr0;            accu --> timer0
	    clrf   _tmr0;            timer0 = 0 
	    SWAPF  _status,0;        accu = permutation des tétrades L et H
	    movf   _status,0;        status --> accu
	    movlw  4;                accu = 04
	    movwf  _FCV_X;           accu --> x
	    nop;                exemple d'adressage indirect 
	    movlw  50;               accu W = 32h
	    movwf  _FCV_MAVARIABLE;  mavariable = accu = 32h
	    movlw  17;               17=11h=adresse de mavariable --> accu W
	    movwf  _fsr;             11h --> fsr (fsr pointe sur mavariable)
	    movf   _indf,0;  (contenu de indf)--> accu =(contenu de l'ad 50=32h)
	    nop;                adressage indirect FIN
	    bsf    _intcon,7;        bit7 de intcon = 1
	    bcf    _intcon,3
	    bcf    _intcon,6;        bit6 de intcon = 0
	    bcf    _intcon,5
	    BSF    _intcon,4
	    BCF    _intcon,2
	    bcf    _intcon,1
	    BCF    _intcon,0
	    sleep;                   pic en somnolence
	    NOP
	    NOP
	}



	mainendloop: goto mainendloop;
}

AVEC cet exemple d’un programme qui ne sert à rien vous devrez pouvoir vous débrouiller

Voir pour cela :
S’initier à la programmation des pics de Alain REBOUX
La programmation des pics par BIGONOFF
Les notes du constructeur
Et Bien évidemment FLOWCODE V3 !!!!

Bon amusement

Christian MICHEL

22/01/2008, 21h39
sdumasp

merci beaucoup je regarderai ça à tête reposée pour m'essayer à la programmation PIC en C
juste une petite requête est-ce que vous pourriez utiliser les balises de codes pour que ça soit plus lisible et que je puisse m'y retrouver s'il-vous-plaît?
merci! :)
26/07/2009, 00h14
rudehivers

google flowcode portable ! satifait !