Final code.

transcodeur/lcd.c

@@ -10,33 +10,30 @@
 
 void LCD_Init (void)
 {
-	DDRC = 0xFF;	// Le port de controle en sortie
+	DDRC = 0xFF;									// Le port de controle en sortie
-	DDRA = 0xFF;	// le port des donnees en sortie
+	DDRA = 0xFF;									// le port des donnees en sortie
-	PORTC &= ~(1<<E);	// E=0 Enable desactive
+	PORTC &= ~(1<<E);								// E=0 Enable desactive
-	_delay_ms(50);		//on attends +30ms pour que Vdd soit a 4,5V
+	_delay_ms(50);									//on attends +30ms pour que Vdd soit a 4,5V
-	LCD_Command (FUNCTION_SET | TWO_LINE_MODE);
+	LCD_Command (FUNCTION_SET | TWO_LINE_MODE);		//Mode deux lignes
-	LCD_Command (DISPLAY_CTRL | DISPLAY_ON);
+	LCD_Command (DISPLAY_CTRL | DISPLAY_ON);		//Affichage allumé
-	LCD_Command (CLEAR_DISPLAY);
+	LCD_Command (CLEAR_DISPLAY);					//Nettoyage de l'écran
-	LCD_Command (ENTRY_MODE_SET | INCREMENT_MODE);
+	LCD_Command (ENTRY_MODE_SET | INCREMENT_MODE);	//Mode d'incrémentation dans la RAM
 }
 
 void LCD_Command(unsigned char cmd)
 {
-	PORTC &= ~(1<<RS);	// RS=0 on active le mode commande
+	PORTC &= ~(1<<RS);			// RS=0 on active le mode commande
-	PORTC &= ~(1<<RW);	// RW=0 write mode
+	PORTC &= ~(1<<RW);			// RW=0 write mode
-	PORTC |= (1<<E);	// E=1 Enable autorise
+	PORTC |= (1<<E);			// E=1 Enable autorise
-	PORTA= cmd;		//on envoie la donnee
+	PORTA= cmd;					//on envoie la donnee
-	PORTC &= ~(1<<E);	// E=0 Enable desactive
+	PORTC &= ~(1<<E);			// E=0 Enable desactive
 	switch(cmd)
 	{
-		case 0x01:
+		case CLEAR_DISPLAY:		//si écran nettoyé
-		_delay_ms(2);
+		_delay_ms(2);			//on attend +1,53ms
 		break;
-		case 0x81:
+		default:				//dans les autres cas
-		_delay_ms(2);
+		_delay_us(50);			//on attend +39us
-		break;
-		default:
-		_delay_us(50);
 	};
 }
 

transcodeur/lcd.h

@@ -26,10 +26,9 @@
 #define INCREMENT_MODE 0x02
 #define ENTIRE_SHIFT_ON 0x01
 
-#define FIRST_LINE 0x80
+#define POSITION 0x80
-#define SECOND_LINE 0xC0
+#define SECOND_LINE 0x40
 
-void LCD_Init (void);
+void LCD_Init (void);					//initialise le LCD
-void LCD_Command(unsigned char cmd);
+void LCD_Command(unsigned char cmd);	//envoie un commande au LCD
-int LCD_putchar(char c, FILE *stream);
+int LCD_putchar(char c, FILE *stream);	//envoie un caractere au LCD
-void LCD_placing(char c);

transcodeur/main.c

@@ -20,11 +20,9 @@ int main(void)
     int  taille=0;
     char  tab[MAX];
 	stdout=&std_out_lcd;
-	DDRB|=(1<<PB3);	
 	while(1){
 			saisie(tab,&taille);
 			LCD_Command (CLEAR_DISPLAY);
-			printf("%s",tab);
+			printandtranslate(tab,taille);
-			latin2morse(tab,taille);
 	};
 }

transcodeur/main.h

@@ -5,12 +5,12 @@
  *  Author: yboujon1
  */ 
 
-#define F_CPU 3686400
+#define F_CPU 3686400		//fréquence du processeur
-#include <avr/io.h>
+#include <avr/io.h>			//librairie de base pour microcontroleur
-#include <avr/interrupt.h>
+#include <avr/interrupt.h>	//librairie pour l'interruption
-#include <util/delay.h>
+#include <util/delay.h>		//librairie pour la fonction delay
-#include <stdio.h>
+#include <stdio.h>			//librairie de base pour le langage c
-#include <stdlib.h>
+#include <stdlib.h>			//librairie pour les chaines de caracteres
-#include <string.h>
+#include <string.h>			//librairie pour les traitement mémoire (chaine de caracteres)
-#include <stdint.h>
+#include <stdint.h>			//librairie essentielle pour les .h et .c
-#include <inttypes.h>
+#include <inttypes.h>		//pour faire fonctionner stdint.h

transcodeur/morse.c

@@ -50,31 +50,32 @@ void envoyer_signe_morse(unsigned char signe_morse)
 {
 	switch(signe_morse){
 		case POINT:
-		start_timer0();
+		start_timer0();					//démarre la fréquence 440 Hz
-		start_timer1(ONEMS);
+		start_timer1(ONEMS*speed);		//	100ms*vitesse
-		wait_ocf1a_timer1();
+		wait_ocf1a_timer1();			//	d'attente
-		stop_timer0();
+		stop_timer0();					//arrêt de 440 Hz
-		wait_ocf1a_timer1();
+		start_timer1(ONEMS*speed);		//	100ms*vitesse
+		wait_ocf1a_timer1();			//	d'attente
 		break;
 		case TRAIT:
-		start_timer0();
+		start_timer0();					//démarre la fréquence 440 Hz
-		start_timer1(3*ONEMS);
+		start_timer1(3*ONEMS*speed);	//	300ms*vitesse
-		wait_ocf1a_timer1();
+		wait_ocf1a_timer1();			//	d'attente
-		stop_timer0();
+		stop_timer0();					//arrêt de 440 Hz
-		start_timer1(ONEMS);
+		start_timer1(ONEMS*speed);		//	100ms*vitesse
-		wait_ocf1a_timer1();
+		wait_ocf1a_timer1();			//	d'attente
 		break;
 		case INTERLETTRE:
-		start_timer1(2*ONEMS);
+		start_timer1(2*ONEMS*speed);	//	200ms*vitesse
-		wait_ocf1a_timer1();
+		wait_ocf1a_timer1();			//	d'attente
 		break;
 		case INTERMOT:
-		start_timer1(10*ONEMS);
+		start_timer1(10*ONEMS*speed);	//	1s*vitesse
-		wait_ocf1a_timer1();
+		wait_ocf1a_timer1();			//	d'attente
 		break;
 		case FIN:
-		resume_timer1();
+		resume_timer1();				//on relance l'attente
-		stop_timer1();
+		stop_timer1();					//on arrête les attentes
 		break;
 		default:
 		break;
@@ -83,8 +84,8 @@ void envoyer_signe_morse(unsigned char signe_morse)
 
 void maj2min_convert(char *tab, int n)
 {
-	int i;
+	int i;								//on initialise i
-	for(i=0; i<=n; i++)
+	for(i=0; i<=n; i++)					//on incrémente tant qu'il n'est pas plus grand que la taille n
 	{
 		if(tab[i]>=65 && tab[i]<=90)    //si c'est une majuscule
 		{
@@ -97,86 +98,117 @@ void maj2min_convert(char *tab, int n)
 	};
 }
 
-void latin2morse(char *tab, int n)
+void printandtranslate(char *tab, int n)
 {
-	int i=0;    //varie la chaine de caractere
+	int i=0;								//varie la chaine de caractere
-	int j=0;    //varie la librarie
+	int j=0;								//varie la librarie
+	int multiple=0;							//tous les 16 caractères, s'incrémente
 	do
 	{
+		firstlinetext(tab,i,&multiple,n);	//16 caractères de la chaîne sur la première ligne
 		switch(j)
 		{
-			case 0:
+			case 0:							//UNIQUEMENT quand j=0
-			lcd_char(tab,&i);
+			secondlinetext(tab,&i,multiple);//seconde ligne de la chaîne pour un caractère
-			maj2min_convert(tab,i);
+			maj2min_convert(tab,i);			//converti les majuscules en minuscule
-			default:
+			default:						//SINON dans tous les autres cas
-			if(tab[i]==morse_library[j][0]) //verifie si le caractere correspond ? la librarie
+			latin2morse(tab,&i,&j);			//traduction morse
-			{
-				library_checker(tab,&i,&j); //traduit dans la librairie et renvoie les deux variables pour continuer
-			}
-			else                            //si ce n'est pas dans la librarie
-			{
-				simple_terms(tab,&i,&j);    //traduit directement les termes plus simples
-			};
 			break;
 		};
-	}while(i<n);     //tant qu'on arrive ? la fin du tableau
+	}while(i<n);							//tant qu'on arrive a la fin du tableau
 }
 
-void library_checker(char *tab,int* i,int* j)
+void latin2morse(char *tab,int* i,int* j)
 {
-	morselibrary_output(*j);                   //traduit en morse
+	if(tab[*i]==morse_library[*j][0])	//verifie si le caractere correspond ? la librarie
-	*j=0;                               //on revient au d?but de la librairie
+	{
-	*i=*i+1;                            //on avance dans la chaine
+		library_checker(tab,&i,&j);		//traduit dans la librairie et renvoie les deux variables pour continuer
-	if(tab[*i]!=32 && tab[*i]!='\0')    //s'il n'y a pas d'espace ou de fin de mot apr?s, INTERLETTRE
+	}
+	else								//si ce n'est pas dans la librarie
+	{
+		simple_terms(tab,&i,&j);		//traduit directement les termes plus simples
+	};
+}
+
+void library_checker(char *tab,int** i,int** j)
+{
+	morselibrary_output(*j);				//traduit en morse
+	**j=0;									//on revient au debut de la librairie
+	**i=**i+1;								//on avance dans la chaine
+	if(tab[**i]!=32 && tab[**i]!='\0')		//s'il n'y a pas d'espace ou de fin de mot apr?s, INTERLETTRE
 	{
 		envoyer_signe_morse(INTERLETTRE);
 	};
 }
 
-void simple_terms(char *tab,int* i,int* j)
+void simple_terms(char *tab,int** i,int** j)
 {
-	switch(tab[*i])             //en fonction du caractere
+	switch(tab[**i])					//en fonction du caractere
 	{
-		case 32:                    //si c'est un espace INTERMOT
+		case 32:						//si c'est un espace alors INTERMOT
 		envoyer_signe_morse(INTERMOT);
-		*j=0;                   //on revient au d?but de la librairie
+		**j=0;							//on revient au debut de la librairie
-		*i=*i+1;                //on avance dans la chaine
+		**i=**i+1;						//on avance dans la chaine
 		break;
 		case '\0':
-		envoyer_signe_morse(FIN);      //si c'est la fin de la chaine, FIN
+		envoyer_signe_morse(FIN);		//si c'est la fin de la chaine, FIN
-		*j=0;                   //on revient au d?but de la librairie
+		**j=0;							//on revient au debut de la librairie
-		*i=*i+1;                //on avance dans la chaine
+		**i=**i+1;						//on avance dans la chaine
 		break;
-		default:                    //dans d'autres cas continuer l'analyse de la chaine
+		default:						//dans d'autres cas continuer l'analyse de la chaine
-		*j=*j+1;                //on avance dans la tableau
+		**j=**j+1;						//on avance dans la tableau
 	};
 }
 
-void morselibrary_output(int id)
+void morselibrary_output(int* id)
 {
-	int y=1;        //on commence a la 2eme colonne
+	int y=1;											//on commence a la 2eme colonne
 	do
 	{
-		if(etat==0){
+		if(etat==0){									//si l'interruption n'est pas active
-		envoyer_signe_morse(morse_library[id][y]);       //fonction qui envoie un trait ou un point en fonction de la librarie
+		envoyer_signe_morse(morse_library[*id][y]);		//fonction qui envoie un trait ou un point en fonction de la librarie
 		y++;
 		}
 		else{
-			//nothing
+			//rien
 		};
 	}
-	while(morse_library[id][y]!='\0');  //jusqu'a la fin de la traduction dans la librairie
+	while(morse_library[*id][y]!='\0');					//jusqu'a la fin de la traduction dans la librairie
 }
 
-void lcd_char(char *tab,int* i)
+void secondlinetext(char *tab,int* i,int multiple)
 {
-	switch(*i)
+	if(tab[*i]=='\0')								//si nous sommes à la fin de la chaîne, ne rien faire
 	{
-		case 0:
+		//nothing
-		LCD_Command(SECOND_LINE);
+	}
-		printf("%c",tab[*i]);
+	else{											//sinon
-		break;
+		if((*i)==16*(multiple-1))					//tous les 16 caractères en partant de 0
-		default:
+		{
-		printf("%c",tab[*i]);	
+			LCD_Command(POSITION | SECOND_LINE);	//nous allons sur le premier caractère de la seconde ligne
+			printf("%c",tab[*i]);					//on affiche le caractère en cours de la chaîne
+		}
+		else{										//dans les autres cas
+			printf("%c",tab[*i]);					//on affiche le caractère en cours de la chaîne
+		};
+	};
+}
+
+void firstlinetext(char* tab,int i,int* multiple,int taille)
+{
+	if(i==16*(*multiple))									//tous les 16 caractères en partant de 0 
+	{
+		switch(tab[i])										//en fonction du caractère
+		{
+			case '\0':										//fin de la chaine, ne fait rien
+			break;
+			default:
+			LCD_Command(ENTIRE_SHIFT_ON);					//on décale l'affichage
+			do{
+				printf("%c",tab[i]);						//on print les caractères un par un en fonction de i
+				i++;
+			}while(i < (*multiple+1)*16 && i < taille-1);	//jusquà ce que ce soit le 'multiple*16 + 1' caractère ou qu'on arrive à la fin de la chaîne
+			*multiple = *multiple + 1;						//on incrémente multiple car nous sommes à un nouveau multiple de 16
+		};
 	};
 }

transcodeur/morse.h

@@ -14,15 +14,17 @@
 #define INTERLETTRE 30
 #define INTERMOT 70
 #define FIN 0
-#define LETTRES 36
 
-void envoyer_signe_morse(unsigned char signe_morse);
+#define LETTRES 36												//nombre de lettre dans la librairie
-void maj2min_convert(char *tab, int n);         //elle traduit des majuscules en minuscules
+
-void latin2morse(char *tab, int n);             //elle cherche les correspondances par rapport a la librairie ou non
+void envoyer_signe_morse(unsigned char signe_morse);			//envoie le morse sur la sortie OC1A
-void morselibrary_output(int id);                      //elle traduit en morse par rapport a la librairie
+void maj2min_convert(char *tab, int n);							//elle traduit des majuscules en minuscules
-void envoie_morse(char morse);                  //elle envoie le caractere en morse
+void printandtranslate(char *tab, int n);						//lit la traduction code morse avec le lcd
-void library_checker(char *tab,int* i,int* j);  //traduit dans la librairie et ajoute un intermot si possible
+void latin2morse(char *tab,int* i,int* j);						//elle cherche les correspondances par rapport a la librairie ou non
-void simple_terms(char *tab,int* i,int* j);     //traduit les espaces et les fins de message
+void morselibrary_output(int* id);								//elle traduit en morse par rapport a la librairie
-void lcd_char(char *tab,int* i);
+void library_checker(char *tab,int** i,int** j);				//traduit dans la librairie et ajoute un intermot si possible
+void simple_terms(char *tab,int** i,int** j);					//traduit les espaces et les fins de message
+void firstlinetext(char* tab,int i,int* multiple,int taille);	//affiche la première ligne sur le LCD
+void secondlinetext(char *tab,int* i,int multiple);				//affiche la seconde ligne sur le LCD
 
 unsigned char morse_library[LETTRES][7];

transcodeur/saisieuart.c

@@ -9,33 +9,33 @@
 
 void uart_init(unsigned int ubrr)
 {
-	DDRD|=(1<<PD1);
+	DDRD|=(1<<PD1);							//PD1 (TXD) en sortie pour la transmission
-	UBRRL=ubrr;
+	UBRRL=ubrr;								//UBRRL prend la valeur de ubrr, soit 9600 BAUD
-	UCSRB|=(1<<RXEN)|(1<<TXEN);
+	UCSRB|=(1<<RXEN)|(1<<TXEN);				//autorise la reception et la transmission
-	UCSRC|=(1<<URSEL)|(1<<UPM1)|(3<<UCSZ0);			//mode synchrone, parité paire, mode 8 bit
+	UCSRC|=(1<<URSEL)|(3<<UCSZ0);			//mode synchrone, pas de parité, mode 8 bit
 }
 
 char uart_getchar(void)
 {
 	do{
 		//nothing
-	}while ((UCSRA & (1<<RXC))==0);
+	}while ((UCSRA & (1<<RXC))==0);			//tant que RXC = 0, ne fait rien
-	return UDR;
+	return UDR;								//renvoie en char les bits de puTTY
 }
 
 void saisie(char tab[], int *n)
 {
-	int i=0;
+	int i=0;								//soit i la variable pour chaque caractère du tableau
 	do
 	{
-		tab[i]=uart_getchar();
+		tab[i]=uart_getchar();				//recupère la donnée 
 		i++;
-	}
+	}										//continue tant qu'on appuie pas sur entrée
-	while((tab[i-1]!=13) && (i<MAX));
+	while((tab[i-1]!=13) && (i<MAX));		//et qu'on arrive pas au nombre de caracteres max
-	tab[i-1] = '\0';
+	tab[i-1] = '\0';						//le dernier caractère est '\0' car c'est une chaine
-	if (!(i<MAX))
+	if (!(i<MAX))							//si i est supérieur à la variable MAX
 	{
-		fflush(stdin);
+		fflush(stdin);						//vide la mémoire tempon, soit les caractères en trop
 	}
-	*n=strlen(tab)+1;
+	*n=strlen(tab)+1;						//n, soit taille prend la valeur des octets du tableau +1
 }

transcodeur/saisieuart.h

@@ -7,8 +7,8 @@
 
 #include "main.h"
 
-#define UBRR_THEO 23
+#define UBRR_THEO 23					//soit 9600 Bauds
-#define  MAX  17
+#define  MAX  200						//max de caractère pour la saisie
-void uart_init(unsigned int ubrr);
+void uart_init(unsigned int ubrr);		//initialisation de l'uart
-char uart_getchar(void);
+char uart_getchar(void);				//reception de l'uart
-void saisie(char *tab, int* n);                //saisie de la chaine de char
+void saisie(char *tab, int* n);			//saisie de la chaine de char

transcodeur/timerinterrupt.c

@@ -8,46 +8,72 @@
 #include "main.h"
 #include "timerinterrupt.h"
 volatile unsigned char etat = 0;
+volatile unsigned char speed = 1;
+volatile unsigned char frequency = 1;
 
 void start_timer0(void){
-	DDRB |= (1<<PB3);
+	DDRB |= (1<<PB3);							//PB3 est défini comme sortie
-	TCCR0 |= (3<<CS00)|(1<<WGM01)|(1<<COM00);
+	TCCR0 |= (3<<CS00)|(1<<WGM01)|(1<<COM00);	//prediv à 64, mode CTC, change l'état d'OC0
-	OCR0 = 65;
+	OCR0 = 64*frequency;						//valeur de OCR0 pour avoir 440Hz multiplié par frequency
 }
 
 void stop_timer0(void){
-	TCCR0 &= ~(3<<CS00);
+	TCCR0 &= ~(3<<CS00);						//prediv à 0
 }
 
 void init_interruption(void){
-	DDRD &= ~(1<<PD2);			//on met int sur pd2
+	DDRD &= ~(1<<PD2);						//INT0 en entrée
-	MCUCR |= (3<<ISC00);
+	DDRD &= ~(1<<PD3);						//INT1 en entrée
-	GICR |= (1<<INT0);
+	DDRB &= ~(1<<PB2);						//INT2 en entrée
-	sei();
+	MCUCR |= (3<<ISC00)|(3<<ISC10);			//Interruption sur front montant pour INT0 et 1
+	GICR |= (1<<INT0)|(1<<INT1)|(1<<INT2);	//on autorise toutes les interruptions
+	sei();									//validation globale des interruptions
 }
 
 ISR (INT0_vect){
 	etat = 1 - etat;
 }
 
+ISR (INT1_vect){
+	switch(speed)
+	{
+		case 4:
+		speed=1;
+		break;
+		default:
+		speed++;
+	};
+}
+
+ISR (INT2_vect){
+	switch(frequency)
+	{
+		case 3:
+		frequency=1;
+		break;
+		default:
+		frequency++;
+	};
+}
+
 void start_timer1(unsigned short int ocr1a){
-	OCR1A=ocr1a;
+	OCR1A=ocr1a;						//valeur de OCR1A pour avoir 100ms
-	TCCR1A |= (1<<COM1A0);		//toggle
+	TCCR1A |= (1<<COM1A0);				//change l'état d'OC1A et OC1B
-	TCCR1B |= (1<<WGM12)|(1<<CS12);		//compare + div 64
+	TCCR1B |= (1<<WGM12)|(1<<CS12);		//mode CTC, prediv 256
 }
 
 void stop_timer1(void){
-	TCCR1B &= ~(1<<CS12);
+	TCCR1B &= ~(1<<CS12);	//prediv non défini, arrête le timer
-	OCR1A=0;				//règle le soucis du premier mot oublié
+	OCR1A=0;				//remet la valeur OCR1A à 0
 }
 
 void resume_timer1(void){
-	TCCR1B |= (1<<CS12);
+	TCCR1B |= (1<<CS12);	//on relance le prediv à 256
 }
 
 void wait_ocf1a_timer1(void){
 	do{
 		status=TIFR;
-	}while((status & (1<<OCF1A))==0);
+	}while((status & (1<<OCF1A))==0);	//tant que OCF1A = 0, nous attendons
-	TIFR = TIFR | (1<<OCF1A);		//on remet OCF1A a 0
+	TIFR = TIFR | (1<<OCF1A);			//on remet OCF1A a 0
 }

transcodeur/timerinterrupt.h

@@ -7,14 +7,18 @@
 
 #include "main.h"
 
-#define ONEMS 1440
+#define ONEMS 1440								//valeur de OCR1A pour 100ms
-void start_timer0(void);
+void start_timer0(void);						//démarre et intialise le timer0
-void stop_timer0(void);
+void stop_timer0(void);							//arrête le timer0
-void init_interruption(void);
+void start_timer1(unsigned short int ocr1a);	//démarre et initialise le timer1 en fonction d'une temporisation
-ISR (INT0_vect);
+void stop_timer1(void);							//arrête le timer1 (reset OCR1A)
-unsigned char status;
+void resume_timer1(void);						//reprend le timer1
-void start_timer1(unsigned short int ocr1a);
+void wait_ocf1a_timer1(void);					//attente pour timer1 (fonctionne comme un delay)
-void stop_timer1(void);
+void init_interruption(void);					//initialisation des interruptions
-void resume_timer1(void);
+ISR (INT0_vect);								//action avec l'interruption 0 (arrêt)
-void wait_ocf1a_timer1(void);
+ISR (INT1_vect);								//action avec l'interruption 1 (vitesse)
-volatile unsigned char etat;
+ISR (INT2_vect);								//action avec l'interruption 2 (frequence)
+volatile unsigned char etat;					//arrête la traduction
+volatile unsigned char speed;					//fait varier le temps
+volatile unsigned char frequency;				//fait varier la fréquence du signal
+unsigned char status;							//permet d'utiliser la valeur de TIFR