/*

Fonctions d'entrées/sorties
Laboratoire d'informatique
Bachelier en électronique 2 année

Compilateurs : 	Microchip Studio GCC
Processeurs  : 	ATMEGA328P
Version : 		V19.09.23
Développeur : 	Eric Vandermeersch

*/



#include <avr/io.h>
#define F_CPU 16000000//fréquence du processeur//
#define USART_BAUDRATE 9600
#define UBRR_VALUE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)


/*prototype des fonctions hardware externes*/
unsigned char MyGetChar(void);
void MySendChar (char ch);
void InitSerial(void);


#define  uint32 unsigned long int
#define  int32  signed long int




/*
Nom de la Fonction : PrintString 
Déscription : Ecrit une chaine de caractères (constantes)vers le port série
Exemple d'utilisation :

	PrintString("Hello World\n");
//
*/

void PrintString(char *t)
{ 
 
    while(*t!=0) 	MySendChar(*t++);
}

/*
Nom de la Fonction : PrintArray 
Déscription : Ecrit une chaine de caractères (variables) vers le port série
Remarque : PrintArray("Hello World\n") ne fonctionnera pas sur 8051 !
		   Dans ce cas, utiliser PrintString("Hello World");
Exemple d'utilisation :
	char ucTableau[]="Hello World\n";
	PrintArray(ucTableau);
*/
void PrintArray(char *t)
{ 
   	while(*t!=0) 	MySendChar(*t++);
}



/*
Nom de la Fonction : ScanArray 
Déscription : Lit une chaine de caractères du port série vers un tableau
Exemple d'utilisation :
	char ucTableau[80];
	ScanArray(ucTableau);
*/

void ScanArray(char *t)
{
  
   while(1)
   {
   *t = MyGetChar();
   if((*t=='\n')||(*t=='/')) break;
   t++;
   }
   *t=0x00;
}

/*
Nom de la Fonction : PrintDecimal 
Déscription : écrit une valeur décimale sur le port série
Exemple d'utilisation :

	int32 iValeur=5;
	PrintDecimal(iValeur);
*/  

  void PrintDecimal(int32 t)
{
  
 
  int32 iTableauTmpIndex = 0;
  int32 iresult = 0;
  
  int32 bStartInteger=0;
  
  int32 TableauMul[10]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
 
  
  if(t<0) 
  {
  	MySendChar('-');
	t= ~t;
	t++;
  }
 
   for(iTableauTmpIndex = 9; iTableauTmpIndex>=0 ;iTableauTmpIndex--)
      { 
	  iresult = t/TableauMul[iTableauTmpIndex];
	  if(iresult!=0) bStartInteger = 1;
	  if(bStartInteger==1)  
	  {
	   MySendChar(iresult + '0');
	   t-=iresult*TableauMul[iTableauTmpIndex];
	  }
	}
    if(bStartInteger==0) 
  {
  	MySendChar('0');
  }
 
}

/*
Nom de la Fonction : ScanDecimal 
Déscription : lit une valeur décimale sur le port série et l'envoie dans une variable de type int.
Exemple d'utilisation :

	int32 iValeur;
	ScanDecimal(&iValeur);
*/  
  void ScanDecimal(int32 *t)
{
 
  unsigned char TableauTmp[16];
  int32 iTableauTmpIndex = 0;
  int32 iresult = 0;
  
  int32 i;
  
  int32 TableauMul[10]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};

  uint32 TableauMulIndex = 0;
  int32 bNegative=0;
 
  for(i=0;i<16;i++)TableauTmp[i]='0';

  while(1)
  {	
    TableauTmp[iTableauTmpIndex] = MyGetChar();
    if ((TableauTmp[iTableauTmpIndex] == '\n')|| (TableauTmp[iTableauTmpIndex] == '/')) break;
	iTableauTmpIndex++;
  }
 
  if(TableauTmp[0]=='-')
  { 
  bNegative=1; 
  for(iTableauTmpIndex=0;iTableauTmpIndex<15;iTableauTmpIndex++){TableauTmp[iTableauTmpIndex]=TableauTmp[iTableauTmpIndex+1];}

  }	
  for(iTableauTmpIndex=0;iTableauTmpIndex<16;iTableauTmpIndex++){if((TableauTmp[iTableauTmpIndex]=='\n')||(TableauTmp[iTableauTmpIndex]=='/'))break;}
 
  iTableauTmpIndex--;
  for(;iTableauTmpIndex>=0;iTableauTmpIndex--,TableauMulIndex++)
  { 
   i= (int)TableauTmp[iTableauTmpIndex] - 0x30;
   iresult += (i * TableauMul[TableauMulIndex]); 
  }
 
  if(bNegative==1)iresult *= -1;

  *t = iresult;
 
  
}

 /*
Nom de la Fonction : PrintHexaDecimal 
Déscription : écrit une valeur Hexadécimale sur le port série
Exemple d'utilisation :

	int32 iValeur=0xE5;
	PrintHexaDecimal(iValeur);
*/  

  void PrintHexaDecimal(int32 t)
{
   
  int32 iTableauTmpIndex = 0;
  int32 iresult = 0;
  
  int32 bStartInteger=0;
   
  uint32 TableauMul[8]={0x01,0x10,0x100,0x1000,0x10000,0x100000,0x1000000,0x10000000};
 
  for(iTableauTmpIndex = 7; iTableauTmpIndex>=0 ;iTableauTmpIndex--)
    { 
	  iresult = t/TableauMul[iTableauTmpIndex];
	  if(iresult!=0) bStartInteger = 1;
	  if(bStartInteger==1)  
	  {
	   if(iresult<0x0A) MySendChar(iresult + '0');
	   else	MySendChar(iresult+'A'-0x0A);
	   t-=iresult*TableauMul[iTableauTmpIndex];
	  }
	}
 
     if(bStartInteger==0) 
     {
  	    MySendChar('0');
     }
 


}

void PrintHex(uint8_t* data, uint8_t length) {
	for (uint8_t i = 0; i < length; i++) {
		if (data[i] < 0x10) {
			MySendChar('0');  // Pour s'assurer qu'il y a toujours deux caractères
		}
		PrintHexaDecimal(data[i]);  // Passe un seul argument ici : un entier de type int32_t
		MySendChar(' ');  // Ajoute un espace entre les octets
	}
	MySendChar('\n');  // Nouvelle ligne à la fin de l'affichage
}

  
/*Nom de la Fonction : ScanHexaDecimal 
Déscription : lit une valeur hexadécimale sur le port série et l'envoie dans une variable de type int.
Exemple d'utilisation :
*/
	
	  

void ScanHexaDecimal(int32 *t)
{
 
  unsigned char TableauTmp[16];
  int32 iTableauTmpIndex = 0;
  int32 iresult = 0;
  int32 i;

  uint32 TableauMul[8]={0x01,0x10,0x100,0x1000,0x10000,0x100000,0x1000000,0x10000000};
  
  uint32 TableauMulIndex = 0;

   for(i=0;i<16;i++)TableauTmp[i]='0';  
   iTableauTmpIndex=0;
 
   while(1)
  {	
    TableauTmp[iTableauTmpIndex] = MyGetChar();
    if ((TableauTmp[iTableauTmpIndex] == '\n')|| (TableauTmp[iTableauTmpIndex] == '/')) break;
	iTableauTmpIndex++;
  }
  
  for(iTableauTmpIndex=0;iTableauTmpIndex<16;iTableauTmpIndex++)
  { if((TableauTmp[iTableauTmpIndex]=='\n')||(TableauTmp[iTableauTmpIndex]=='/'))
  
     break;}
  
  iTableauTmpIndex--;
  
  for(;iTableauTmpIndex>=0;iTableauTmpIndex--,TableauMulIndex++)
  { 
   i= (int)TableauTmp[iTableauTmpIndex];
   if((i>='0')&& (i<='9')) i -='0';
   else if((i>='A')&& (i<='F')) i -='A'-10;
   else if((i>='a')&& (i<='f')) i -='a'-10;
  
   iresult += (i * TableauMul[TableauMulIndex]); 
  }
 
  *t = iresult;

}



/*
Nom de la Fonction : PrintFloat 
Déscription : écrit une valeur en virgule flottante sur le port série
avec le nombre de décimales derrière la virgule
Exemple d'utilisation :

	float fValeur=5.345;
	PrintFloat(fValeur,3);
*/ 

  void PrintFloat(float t,int decimals)
{
  
  
 int iCpt=0;
 int iDecimalCpt = 0;
 int value;
//zero ?
  if(t==0.0)
  {	 MySendChar('0');
     MySendChar('.');
  	 for(iCpt=0;iCpt<decimals;iCpt++) MySendChar('0');
     return;
  }

 // handle negative numbers 
  if(t<0.0)
  {
    MySendChar('-');
  	t *=-1;
  }
 while (((int)t)!=0) { iCpt++; t/=10; }		

 if(iCpt==0) MySendChar('0');

 for(iDecimalCpt=0;iDecimalCpt<iCpt;iDecimalCpt++)
 {
  t*=10;
  value =  (int)t;
  PrintDecimal(value);
  t=t-value;
  
 }
 MySendChar('.');
 for(iDecimalCpt=0;iDecimalCpt<decimals;iDecimalCpt++)
 {
  t*=10;
  value =  (int)t;
  PrintDecimal(value);
  t=t-value;
  
 }

 }

/*
Nom de la Fonction : ScanFloat 
Déscription : lit un float sur le port série et l'envoie dans une variable de type float.
Exemple d'utilisation :

	float fValeur;
	ScanFloat(&fValeur);
*/

void ScanFloat(float *t)
{
 
    unsigned char ucTableauTmp[16];
  int iTableauTmpIndex = 0;
  int iTableauMemTmpIndex = 0;
  float f = 0.0;
  int i;
 
  int bNegative = 0;

  for(i=0;i<16;i++)ucTableauTmp[i]='0';   

/*  while( (ucTableauTmp[iTableauTmpIndex] = MyGetChar())!='\n')iTableauTmpIndex++;*/
  while(1)
  {	
    ucTableauTmp[iTableauTmpIndex] = MyGetChar();
    if ((ucTableauTmp[iTableauTmpIndex] == '\n')|| (ucTableauTmp[iTableauTmpIndex] == '/')) break;
	iTableauTmpIndex++;
  }

//zero ?
if((ucTableauTmp[0]=='0')&&
  (ucTableauTmp[1]=='.') &&
  (ucTableauTmp[2]=='0') &&
  (ucTableauTmp[3]=='/') ){*t=0.0;return;}

  if(ucTableauTmp[0]=='-')
  { 
  bNegative=1; 
  for(iTableauTmpIndex=0;iTableauTmpIndex<15;iTableauTmpIndex++){ucTableauTmp[iTableauTmpIndex]=ucTableauTmp[iTableauTmpIndex+1];}

  }	


  for(iTableauTmpIndex=0;iTableauTmpIndex<16;iTableauTmpIndex++){if(ucTableauTmp[iTableauTmpIndex]=='.')break;}
  iTableauMemTmpIndex = iTableauTmpIndex;

  if(iTableauTmpIndex==16) 
  {
  PrintString("\nValeur n'est pas un float car ne contient pas de point. mise à 0.0 de la variable par defaut\n");
  *t = 0.0;
  return;
  }
//erase the dot.  
    
   for(;iTableauTmpIndex<15;iTableauTmpIndex++){ucTableauTmp[iTableauTmpIndex]=ucTableauTmp[iTableauTmpIndex+1];}

   //erase 0x2F !
   for(i=0;i<15;i++) if (ucTableauTmp[i]==0x2F) ucTableauTmp[i]=0x30;
  
  iTableauTmpIndex=0;
  for(iTableauTmpIndex=15;iTableauTmpIndex>=0;iTableauTmpIndex--)
  { 
   i= (int)ucTableauTmp[iTableauTmpIndex] - 0x30;
   f += i;
   f/=10; 
  }
 
   for(iTableauTmpIndex=0;iTableauTmpIndex<iTableauMemTmpIndex;iTableauTmpIndex++)
  { 
   f*=10; 
  }
  if(bNegative==1) f *=-1;
  *t = f;
 
 	  
}

/*
Nom de la Fonction : ScanBreakPoint 
Déscription : Met le programme en pause et attend un caractère
Exemple d'utilisation :
	ScanBreakPoint();
*/
void ScanBreakPoint(void)
{
 PrintString("\nBreakPoint ! Press any key to continue\n");
 MyGetChar();
}

// Fonctions propres au compilateurs

void InitSerial(void)
{
 UBRR0H = (uint8_t)(UBRR_VALUE>>8);
 UBRR0L = (uint8_t)UBRR_VALUE;
 // Set frame format to 8 data bits, no parity, 1 stop bit
 UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);
 //enable transmission and reception
 UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
}

/* Fonction qui va lire le charactère dans le 8051 */
unsigned char MyGetChar(void)
{		 
 // Wait for byte to be received
 while(!(UCSR0A&(1<<RXC0))){};
 // Return received data
 return UDR0;
}

unsigned char InCommingChar(void)
{
	 // Wait for byte to be received
	if(!(UCSR0A&(1<<RXC0)))
		{return (0);}
	else {return(1);}
		
	 // Return received data
	 return UDR0;
}

void MySendChar(char ch)
{  
//wait while previous byte is completed
while(!(UCSR0A&(1<<UDRE0))){};
// Transmit data
UDR0 = ch;
}


void MyInitSerial()
{
   
   InitSerial();
   PrintString("\nSerialEvdm Version 11.10.22 - ");
   PrintString("ATMEGA328P\n");
}