Début PortB =0 MLI = 0 Tant Que « vrai » Répéter Si (Bplus =0 OU Bpmoins = 0) Alors Si (Bpplus=0 ET MLI<255) Alors MLI =MLI + 51 Fin Si Si (Bpmoins=0 ET MLI>50) Alors MLI =MLI - 51 Fin Si Si MLI = 0 Alors jakubowicz Marc Lycée Loritz Fin Si Attendre 2s Fin Si Fin Tant Que Fin

Étapes de programmation Définition d’un cahier des charges fonctionnel (ce que doit faire le programme…) Définition de l’environnement (A quelle broche brancher telles ou telles commandes …) Ecriture du programme :  A partir du cahier charge fonctionnel (CdCf), le programmeur écrit le programme. Le langage utilisé est l’algorithme ou l’algorigramme. Le codage :  A partir de l’algorithme le codeur va transcoder l’algorithme ou algorigramme en un langage de haut niveau : C C++ Basic, ou en un langage de bas niveau : assembleur  A ce stade le programme peut-être simulé afin de vérifier que son exécution est conforme. La Compilation :  La compilation consiste à transformer le langage de haut ou bas niveau en code machine directement exécutable par le microcontrôleur.

Étapes de programmation Programmation des composants.  Le code machine et les variables de fonctionnement vont être introduits dans les différentes mémoires du microcontrôleur.  La programmation peut s'effectuer :  Sur site, le microcontrôleur est dans son environnement, le technicien le place dans un mode "maintenance" ce qui permet de modifier n'importe quelle mémoire.  Hors site, le microcontrôleur est placé sur un programmateur externe, ce qui permet de modifier la mémoire ROM et EEPROM. Vérification.  Elle se fait directement sur le système.

Un algorithme est une règle. Processus défini par une succession finie, ordonnée dans le temps, d’opérations d’un acteur unique appliquées à un nombre fini de données conduisant en un nombre fini d’étapes à un résultat défini quelles que soient les valeurs des données dans leurs domaines de définition. Algorigramme Représentation graphique conventionnelle d’un algorithme Règle 0 L’algorithmique est faite pour décrire l’aspect temporel des processus. Un algorithme sans fin ne peut représenter qu’un programme mal fait et planté. Deux événements représentés sur deux lignes (cellules graphiques) consécutives se succèdent strictement dans le temps.

Règle 1 Deux événements simultanés doivent être mentionnés dans la même ligne d’algorithme, ou dans le même rectangle d’algorigramme. Règle 2 Les mots clés de l’algorithmique (il n’y en n’a même pas 20, un minimum de 12 suffisent) s’emploient toujours soulignés. Règle 3 Les couples suivants fonctionnent comme des parenthèses algébriques (à une ouverture correspond une et une seule fermeture sans enchevêtrement) et sont toujours reliés par des traits verticaux de validation : Début Fin Tant que Fin tant que (ftq) Répéter Jusqu’à

Règle 4 Le signe « = » a toujours une valeur de test booléen (une question à laquelle la réponse ne peut être que oui ou non, un affirmation qui ne peut être que vraie ou fausse), l’affectation est toujours représentée par son signe « prend pour valeur » :  Règle 5 Tout algorithme a un début et une fin. Un processus « permanent » a toujours une boucle principale qui n’atteint sa fin que sur rupture des conditions normales de fonctionnement. Règle 6 Tout algorithme peut se représenter en algorigramme et réciproquement. Règle 7 L’algorigramme n’est pas un outil d’analyse des systèmes, c’est un outil de validation et de présentation des solutions élaborées en mode algorithme (texte).

Règle 8 Les deux formes de boucle légitimes ne sont pas équivalentes. Les événements de la boucle répéter sont toujours exécutés au moins une fois alors que la boucle tant que peut très bien ne jamais avoir lieu. Règle 9 Un « si » ne contrôle jamais une boucle ! ! ! Ce sont les structures « tant que » et « répéter...jusqu’à » qui contrôlent les boucles légitimes Règle 10 La description en langage libre ne doit jamais contenir de structures de contrôle implicites. Cela interdit donc les synonymes plus ou moins avoués de nos mots clés : “continuer”, “reprendre”, “arrêter”, “passer à”, “attendre”, “stop”, “sauter en”, “selon”, “en fonction de”, “exécuter”, “attendre”, “choisir”, “recommencer”, “soit que...soit que”, “quand”, “dès que”, “après que”, “vérifier”, “au cas où”, etc...

Règle 11 Une boucle algorithmique est toujours exécutée un nombre entier de fois. Règle 12 Une boucle GOTO peut apparaître en première analyse de constatation d’un objet existant mais elle peut et doit toujours être éliminée de la version finale. Règle 14 Deux boucles peuvent être successives ou imbriquées, jamais enchevêtrées. Règle 13 LE GOTO s’élimine en réécrivant une boucle tant que ou répéter

Règle 15 La hiérarchie matérielle d’un système doit se traduire par la hiérarchie de l’algorithme : l’algorithme liée à une structure matériellement subordonnée à une autre ne peut être qu’un sous- algorithme de l’algorithme de la structure prioritaire Règle 16 Tout état physique mémoire (bascule, charge de condensateur, état d’un commutateur...) se représente par une variable Règle 17 La hiérarchie algorithmique doit respecter la hiérarchie matérielle. Règle 18 Le sous-algorithme d’une structure qui fonctionne sous le contrôle matériel permanent d’une autre ne peut contenir de boucle « durable ».

Séquence Ensemble d'opérations, d'instructions, comprises entre deux délimiteurs qui seront exécutées successivement dans le temps. Début Instruction 1 Instruction 2 Opération 1 … Fin

Condition est une variable booléenne. Structure algorithmique correspondante : Si (condition vraie) alors faire Séquence 1 sinon faire Séquence 2. Fin si Alternative ou choix Alternative multiple Cas [variable_clé] [condition_booléenne_1 sur variable_clé] [action_1] [condition_booléenne_2 sur variable_clé] [action_2]... [condition_booléenne_n sur variable_clé] [action_n] sinon [action_autre] Fin cas

Itération (répétition) Répétition d’une séquence un nombre de fois déterminé ou non. n peut être connu ou inconnu

Pour Variable1 de début à fin Pour Variable de [début] à [fin] Séquence 1 Séquence 2 Répéter Remarque : les variables [Début] et [fin] doivent être déterminée avant l’itération. Faire… jusqu’à Faire Séquence 1 Séquence 2 … jusqu’à (condition = vraie) Remarque : les séquences sont réalisées au moins une fois. Structures algorithmiques possibles : Tant que … faire Tant que (condition = vraie) Répéter Séquence 1 Séquence 2… Fin tant que Remarque : les séquences peuvent ne pas être réalisées. Le Fin tant que n’est pas obligatoire.

Représentation sous forme d’algorigramme

AlgorithmeAlgorigrammeQ Basic Séquence linéaire Début : Instruction 1 Instruction 2 Séquence Fin : Exemple de programme Y=Y+1 X=X*3+2 CALL trace Choix ou Alternative SI (condition vraie) Alors faire Séquence Sinon faire Instruction Fin SI Exemple de programme IF touche = 1 THEN CALL clavier ELSE tmp=tmp+1 END IF Itération Faire…jusqu’à Faire Séquence Jusqu’à (condition=vraie) Exemple de programme DO CALL encodage LOOP UNTIL res=1

AlgorithmeAlgorigrammeQ Basic Itération Tant que…faire Tant que (condition=vraie) Répéter Instruction Séquence Fin Tant que Exemple de programme WHILE test=1 X=X+1 CALL tempo WEND Itération Pour variable de début à fin Pour variable CNT de [début] à [fin] instruction … Répéter Exemple de programme FOR CNT=0 TO 100 Y=CNT*12+3 NEXT CNT

Réaliser le programme suivant :  Initialisez une variable « compteur » à 0.  Sortir la variable « compteur » sur le port B  Incrémenter la variable « compteur »  Attendre 200ms.  Recommencer à l’infini. Début Tant que 1 Répéter Compteur = 0 Pour boucle de 0 à 255 Sortir compteur sur port B Incrémenter Compteur Attendre 200 ms Répéter Fin Tant Que Fin

Réaliser le programme suivant :  Initialisez une variable « compteur » à 0.  Sortir la variable « compteur » sur le port B  Incrémenter la variable « compteur »  Attendre 200ms.  Recommencer à l’infini. Algorigramme type Flowcode Début Tant que 1 Répéter Compteur = 0 Pour boucle de 0 à 255 Sortir compteur sur port B Incrémenter Compteur Attendre 200 ms Répéter Fin Tant Que Fin

void main() { COMPTEUR = 0 ; while( 1 ) { for (LOOP1=0; LOOP1<255; LOOP1++) { trisb = 0x00; portb = COMPTEUR; COMPTEUR = COMPTEUR + 1 ; delay_ms(200); } mainendloop: goto mainendloop; }

program compteur dim compteur as byte dim boucle as byte main: trisb = $00 'Le port B est en sortie While true compteur = $0 For boucle = 0 to 255 PortB = compteur compteur = compteur + 1 Delay_ms(200) Next boucle Wend end. 'Fin de programme

label2 BCF STATUS, RP0 CLRF gbl_COMPTEUR CLRF gbl_LOOP1 label6 MOVLW 0xFF SUBWF gbl_LOOP1, W BTFSC STATUS,C GOTOlabel2 BSF STATUS, RP0 CLRF gbl_trisb BCF STATUS, RP0 MOVF gbl_COMPTEUR, W MOVWF gbl_portb INCF gbl_COMPTEUR, W MOVWF gbl_COMPTEUR MOVLW 0xC8 MOVWF delay_ms_00000_arg_del CALL delay_ms_00000 INCF gbl_LOOP1, F GOTOlabe6 ; } main function end

main: CMCON=7 'Configure le portA en entrées/sorties numériques trisa = $FF 'le port A est en entrée trisb = $00 'Le port B est en sortie portb = $00 'Met les sortie du port B à 0 While (bp=1 'Tant que bp non appuyé faire la boucle Wend del=1 'Sortie b0 à 1 Del allumée Delay_ms(2000) 'Attendre 2s del=0 'Sortie b0 à 0 Del éteinte end. 'Fin de programme Programme 0 Eteindre toutes les DEL. Attendre que BP soit à 1 Allumer la DEL 0 durant 200ms. Eteindre la DEL 0. Terminé.

main: CMCON=7 'Configure je portA en entrées/sorties numériques trisa = $FF 'le port A est en entrée trisb = $00 'Le port B est en sortie portb = $0 'Met les sortie du port B à 0 PortB = $FF 'Sortie b0 à 1 Del allumée Delay_ms(1000) 'Attendre 1s PortB = 0 'Sortie b0 à 0 Del éteinte Delay_ms(1000) 'Attendre 1s end. Programme 1 Allumer toutes les DEL. Attendre 1s. Eteindre toutes les DEL. Attendre 1s. Terminé.

main: CMCON=7 'Configure je portA en entrées/sorties numériques trisa = $FF 'le port A est en entrée trisb = $00 'Le port B est en sortie portb = $0 'Met les sortie du port B à 0 while true PortB = $FF 'Sortie b0 à 1 Del allumée Delay_ms(1000) 'Attendre 1s PortB = 0 'Sortie b0 à 0 Del éteinte Delay_ms(1000) 'Attendre 1s Wend end. Programme 2 Allumer toutes les DEL. Attendre 1s. Eteindre toutes les DEL. Attendre 1s. Le programme se répète à l’infini.

dim compteur as byte ‘Définition de la variable compteur comme un octet main: … compteur = $0 While true ‘Faire tant que’ do ‘Faire PortB = compteur Delay_ms(200) compteur = compteur +1 loop until compteur = $FF ‘Jusqu’à Wend ‘Répéter end. Programme 3 On va compter … : Initialisez une variable « compteur » à 0. Sortir la variable « compteur » sur le port B Incrémenter la variable « compteur » compteur = compteur +1 Attendre 200ms. Et recommencer à l’infini.

dim port as byte main: … While true Port = portA port= NOT Port PortB = port Wend end. Programme 5 Lire le port A en entrée, le stocker dans une variable « port » on veut sur le port de sortie, l’inverse de port Sortir sur le port B la variable « /port ». Et recommencer à l’infini.

main: While true chenille = $01 for compteur = 0 to 6 PortB = chenille delay_ms(200) chenille = chenille << 1 Next compteur for compteur = 0 to 6 PortB = chenille delay_ms(200) chenille = chenille >> 1 Next compteur Wend end Programme 6 – 7 Un petit chenillard … Initialiser une variable « chenille » à 01 Sortir sur le port B la variable « chenille ». Attendre 200ms. Décaler à gauche d’un bit la variable « chenille » Recommencer 7 fois. on veut que la DEL fasse un allez retour perpétuel

main: … While true port = portA.0 IF port = 1 then chenille = $01 for compteur = 0 to 7 PortB = chenille delay_ms(200) chenille = chenille << 1 Next compteur else chenille = $80 for compteur = 0 to 7 PortB = chenille delay_ms(200) chenille = chenille >> 1 Next compteur End IF Wend end. Programme 8 Variante du programme 6, on veut que la DEL fasse un allez ou retour dans le sens de l’interrupteur A0.

Réalisez le programme en Qbasic permettant de dessiner une courbe sinusoïdale.