Sunteți pe pagina 1din 4

#include <iom16.

h>
#include "usart.h"
// ----------------------------------------------------------- myPrint----------------------------------------------------unsigned char string[20];
long long dataHex;
double dataReal;
int dataIntreg;
unsigned char aux=0;
unsigned char i=0;
unsigned char *pString;
void myPrint(unsigned char tipData, unsigned char nrCifre, void * date)
{
aux=0;
i=0;
switch(tipData)
{
case 0:
dataHex=*((long long*)date);
while(dataHex>0&&nrCifre>i)//cat timp mai avem cifre si nu ma depasit numaru
l maxim de cifre
{
aux=dataHex&0xf; //scoatem ultimul carater hexa din numar - modulo 16
string[i++]=aux; //stocam caracterul pentru utilizare ulterioara
dataHex>>=4;
//stergem ultimul caracter deja salvat - impartim la 16
}
for(aux=i;aux>0;--aux)//parcurgem in sens invers sirul
{
if(string[aux-1]<=9)
{
USART_transmit(string[aux-1]+'0');//transmitem pe seriala caractere <10
}
else
{
USART_transmit(string[aux-1]+'A'-10);//transmitem pe seriala caractere >
9
}
}
break;
case 1:
dataHex=*((long long*)date);
while(dataHex>0&&nrCifre>i)//cat timp mai avem cifre si nu ma depasit numaru
l maxim de cifre
{
aux=dataHex%10; //scoatem ultima cifra din numar
string[i++]=aux; //stocam cifra pentru utilizare ulterioara
dataHex/=10;
//stergem ultima cifra deja salvata
}
for(aux=i;aux>0;--aux)//parcurgem in sens invers sirul
{
USART_transmit(string[aux-1]+'0');//transmitem pe seriala caracterele in o
rdinea corecta
}
break;
case 2:
dataReal=*((double*)date);//stocam data

dataIntreg=(int)dataReal;//convertim in int ca sa putem lucra mai usor cu nu


marul
if(dataIntreg == 0 )
{
USART_transmit('0');
}
/* if(dataIntreg < 9 )
{
USART_transmit('0');
}*/
while(dataIntreg>0&&nrCifre>i)//cat timp mai avem cifre si nu ma depasit num
arul maxim de cifre
{
aux=dataIntreg%10; //scoatem ultima cifra din numar
string[i++]=aux; //stocam cifra pentru utilizare ulterioara
dataIntreg/=10;
//stergem ultima cifra deja salvata
}
for(aux=i;aux>0;--aux)//parcurgem in sens invers sirul
{
USART_transmit(string[aux-1]+'0');//transmitem pe seriala caracterele in
ordinea corecta
}
//am terminat cu partea intreaga
//punem .
USART_transmit('.');//transmitem '.'
dataReal=dataReal-(int)dataReal;
//cream parte intreaga din numarul de cifre ramas de afisat
//nr cifre ramase
nrCifre=nrCifre-i;
aux=nrCifre;
while(aux--)
{
dataReal=dataReal*10;
if(dataReal<1)
{
USART_transmit('0');//transmitem pe seriala '0' pentru cazurile 52.000
9
}
}
i=0;
dataIntreg=(unsigned int)dataReal;//convertim in int ca sa putem lucra mai u
sor cu numarul
while(dataIntreg>0)//cat timp mai avem cifre si nu ma depasit numarul maxim
de cifre
{
aux=dataIntreg%10; //scoatem ultima cifra din numar
string[i++]=aux; //stocam cifra pentru utilizare ulterioara
dataIntreg/=10;
//stergem ultima cifra deja salvata
}
for(aux=i;aux>0;--aux)//parcurgem in sens invers sirul
{
USART_transmit(string[aux-1]+'0');//transmitem pe seriala caracterele in o
rdinea corecta
}

break;
case 3:
pString=(unsigned char*)date;
for(i=0;i<nrCifre;i++)
{
USART_transmit(pString[i]);
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------end of myPrint ---------------------------------------------

// ----------------------------------------------------------------------------- crc16 ----------------------------------------------------#define CRC16_CCITT 0x1021


enum BitOrder { LSBF, MSBF };
unsigned int crc16(unsigned int polinom16, unsigned int init_val_16,
unsigned int adr_start,unsigned int len, enum BitOrder ord)
{
//rezultatul final
unsigned int crc = init_val_16;
//re?ine n octetul cel mai semnificativ datele
//extrase din memoria flash
unsigned int data = 0;
while( len-- ) {
unsigned int i;
//se extrage valoarea unui octet de la adresa de start
//din memoria RAM!!!!! daca voiam din flash faceam cast la char __flash *
data = *(__flash char *)adr_start;
if ( ord == MSBF ) //op?iunea cu shiftare spre MSB
{
//octetul este shiftat la stnga pentru a se alinia
//cu polinomul generator
data <<= 8;
//datele sunt "transferate" n rezultat
crc ^= data;
adr_start++;
//pentru bi?ii de date se face XOR cu polinomul generator,
//daca bitul cel mai semnificativ este 1 sau se shifteaza datele
//la stnga, dac? bitul cel mai semnificativ este 0
for( i = 0; i < 8; ++i ) {
//se verific? dac? bitul cel mai semnificativ este 1
if( crc & 0x8000 )
crc = (crc << 1) ^ polinom16;
else
crc = crc << 1;
}
}
else
//op?iunea cu shiftare spre LSB

//parametrul polinom16 al func?iei trebuie s? aib? bi?ii inversa?i n


//prealabil
{
crc ^= data;
adr_start++;
//se verific? bitul cel mai putin semnificativ ?i dac?
//acesta este 1 se face XOR cu polinomul generator,
// altfel datele sunt shiftate la dreapta
for( i = 0; i < 8; ++i ) {
//se verific? daca cel mai pu?in semnificativ bit este 1
if( crc & 0x0001 )
crc = (crc >> 1) ^ polinom16;
else
crc = crc >> 1;
}
}
}
return crc;
}
// ----------------------------------------------------------------------------- end of crc16 -----------------------------------------------------

void main(){
USART_initialize(BAUD_RATE);
unsigned int myCRC=crc16(CRC16_CCITT,0,0,(0x4000-2),MSBF); // length 16kb=16*1
024
unsigned int realCRC=*(__flash unsigned int*)(0x4000-2);
if(myCRC==realCRC){
// memoria flash este OK
}else{
// memoria flash nu este OK;
}
while(1){
}
}