void testMorseDetecteImpulsionsET() {
morseReinitialise();
fileReinitialise();
morseEnfoncePioche();
attendTicTac(1);
morseLiberePioche();
testeEgaliteChars("MDIET01", fileDefile(), CARACTERE_POINT);
attendTicTac(MORSE_MIN_DUREE_PAUSE);
testeEgaliteChars("MDIET02", fileDefile(), CARACTERE_PAUSE);
testeEgaliteChars("MDIET03", fileDefile(), 'E');
testeEgaliteChars("MDIET04", fileDefile(), '\r');
testeEgaliteChars("MDIET05", fileDefile(), '\n');
morseEnfoncePioche();
attendTicTac(MORSE_MAX_DUREE_POINT + 1);
morseLiberePioche();
testeEgaliteChars("MDIET06", fileDefile(), CARACTERE_LIGNE);
attendTicTac(MORSE_MIN_DUREE_PAUSE);
testeEgaliteChars("MDIET07", fileDefile(), CARACTERE_PAUSE);
testeEgaliteChars("MDIET08", fileDefile(), 'T');
testeEgaliteChars("MDIET09", fileDefile(), '\r');
testeEgaliteChars("MDIET10", fileDefile(), '\n');
attendTicTac(MORSE_MIN_DUREE_PAUSE);
testeEgaliteEntiers("MDIET11", fileEstVide(), 255);
attendTicTac(MORSE_MIN_DUREE_PAUSE * 2);
testeEgaliteEntiers("MDIET12", fileEstVide(), 255);
}
int testAfficheAuMaximum99() {
afficheurEtablitDigits(100);
testeEgaliteEntiers("AMX100a", digit(1), 0x6F);
testeEgaliteEntiers("AMX100b", digit(0), 0x6F);
afficheurEtablitDigits(255);
testeEgaliteEntiers("AMX255a", digit(1), 0x6F);
testeEgaliteEntiers("AMX255b", digit(0), 0x6F);
}
int testAfficheDe10A99() {
afficheurEtablitDigits(10);
testeEgaliteEntiers("AFF10a", digit(1), 0x3F);
testeEgaliteEntiers("AFF10b", digit(0), 0x06);
afficheurEtablitDigits(99);
testeEgaliteEntiers("AFF99a", digit(1), 0x6F);
testeEgaliteEntiers("AFF99b", digit(0), 0x6F);
}
int testAffichePasDeZeroAGauche() {
afficheurEtablitDigits(0);
testeEgaliteEntiers("AZG00a", digit(1), 0x3F);
testeEgaliteEntiers("AZG00b", digit(0), 0);
afficheurEtablitDigits(9);
testeEgaliteEntiers("AZG09a", digit(1), 0x6F);
testeEgaliteEntiers("AZG09b", digit(0), 0);
}
void testMorseIgnorePauseInitiale() {
morseReinitialise();
fileReinitialise();
attendTicTac(MORSE_MIN_DUREE_PAUSE);
testeEgaliteEntiers("IPI01", fileEstVide(), 255);
attendTicTac(MORSE_MIN_DUREE_PAUSE);
testeEgaliteEntiers("IPI02", fileEstVide(), 255);
}
void testEtablitEtLitValeurPwm() {
pwmReinitialise();
pwmPrepareValeur(0);
pwmEtablitValeur(80);
testeEgaliteEntiers("PWMV01", pwmValeur(0), pwmConversion(80));
testeEgaliteEntiers("PWMV02", pwmValeur(1), 0);
pwmPrepareValeur(1);
pwmEtablitValeur(180);
testeEgaliteEntiers("PWMV03", pwmValeur(0), pwmConversion( 80));
testeEgaliteEntiers("PWMV04", pwmValeur(1), pwmConversion(180));
}
void testConversionPwm() {
testeEgaliteEntiers("PWMC001", pwmConversion( 0), 62);
// testeEgaliteEntiers("PWMC002", pwmConversion( 4), 63);
// testeEgaliteEntiers("PWMC003", pwmConversion(126), 93);
testeEgaliteEntiers("PWMC004", pwmConversion(127), 93);
// testeEgaliteEntiers("PWMC005", pwmConversion(128), 94);
// testeEgaliteEntiers("PWMC006", pwmConversion(129), 94);
// testeEgaliteEntiers("PWMC007", pwmConversion(132), 95);
// testeEgaliteEntiers("PWMC008", pwmConversion(251), 124);
testeEgaliteEntiers("PWMC009", pwmConversion(255), 125);
}
void testEspacementPwm() {
unsigned char n;
pwmReinitialise();
for (n = 0; n < PWM_ESPACEMENT; n++) {
testeEgaliteEntiers("PWME00", pwmEspacement(), 0);
}
testeEgaliteEntiers("PWME01", pwmEspacement(), 255);
for (n = 0; n < PWM_ESPACEMENT; n++) {
testeEgaliteEntiers("PWME00", pwmEspacement(), 0);
}
testeEgaliteEntiers("PWME01", pwmEspacement(), 255);
}
void testUartTransmission() {
uartReinitialise();
uartPutch('A');
uartPutch('T');
testeEgaliteChars ("UPAT00", uartEtat, UART_TRANSMISSION_EN_COURS);
testeEgaliteChars ("UPAT01", dernierCaractereTransmis, 'A');
testeEgaliteChars ("UPAT02", uartTransmission(), 'T');
testeEgaliteEntiers("UPAT03", uartCaracteresDisponiblesPourTransmission(), 0);
}
void testDebordePuisRecupereLesCaracteres() {
fileReinitialise();
char c = 1;
while(!fileEstPleine()) {
fileEnfile(c++);
}
testeEgaliteEntiers("FDB001", fileDefile(), 1);
testeEgaliteEntiers("FDB002", fileDefile(), 2);
while(!fileEstVide()) {
c = fileDefile();
}
fileEnfile(1); // Ces caractères sont ignorés...
fileEnfile(1); // ... car la file est pleine.
testeEgaliteEntiers("FDB003", c, FILE_TAILLE);
}
void testCapturePwm() {
pwmDemarreCapture(0, 0);
pwmCompleteCapture(0, 80);
pwmDemarreCapture(1, 10000);
pwmCompleteCapture(1, 10090);
testeEgaliteEntiers("PWMC01a", pwmValeur(0), 80);
testeEgaliteEntiers("PWMC01b", pwmValeur(1), 90);
pwmDemarreCapture(0, 65526);
pwmCompleteCapture(0, 80);
pwmDemarreCapture(1, 65516);
pwmCompleteCapture(1, 80);
testeEgaliteEntiers("PWMC02a", pwmValeur(0), 90);
testeEgaliteEntiers("PWMC02b", pwmValeur(1), 100);
}
void testConversionDirection() {
testeEgaliteEntiers("CD01", conversionDirection( 0), ARRIERE);
testeEgaliteEntiers("CD02", conversionDirection( 1), ARRIERE);
testeEgaliteEntiers("CD03", conversionDirection(127), ARRIERE);
testeEgaliteEntiers("CD04", conversionDirection(128), AVANT);
testeEgaliteEntiers("CD05", conversionDirection(129), AVANT);
testeEgaliteEntiers("CD06", conversionDirection(255), AVANT);
}
/**
* valeurMesuree = magnitude * 2.6
*
* a = (valeurMesuree * 26 - magnitude * 10) / 10
*/
void testPidConvergence() {
PID pid1 = {1, 0, 2, 0, 0, 0, 0};
ModelePhysique modelePhysique = {26, 5, 10};
unsigned char n;
unsigned char valeurControle, valeurSortie = 0;
valeurSortie = 0;
for (n = 0; n < 100; n++) {
valeurControle = calculatePID(&pid1, valeurSortie, 56);
valeurSortie = itereModelePhysique(&modelePhysique, valeurControle, valeurSortie, 3);
}
testeEgaliteEntiers("PID001", valeurSortie, 56);
}
void testEnfileEtDefileBeaucoupDeCaracteres() {
int n = 0;
char c = 0;
fileReinitialise();
for (n = 0; n < FILE_TAILLE * 4; n++) {
fileEnfile(c);
if (testeEgaliteEntiers("FBC001", fileDefile(), c)) {
return;
}
c++;
}
}
void testEnfileEtDefile() {
fileReinitialise();
testeEgaliteEntiers("FIL01", fileEstVide(), 255);
testeEgaliteEntiers("FIL02", fileDefile(), 0);
testeEgaliteEntiers("FIL03", fileDefile(), 0);
fileEnfile(10);
fileEnfile(20);
testeEgaliteEntiers("FIL04", fileEstVide(), 0);
testeEgaliteEntiers("FIL05", fileDefile(), 10);
testeEgaliteEntiers("FIL06", fileDefile(), 20);
testeEgaliteEntiers("FIL07", fileEstVide(), 255);
testeEgaliteEntiers("FIL08", fileDefile(), 0);
}
void testConversionMagnitude() {
testeEgaliteEntiers("CM01", conversionMagnitude(0), 254);
testeEgaliteEntiers("CM02", conversionMagnitude(1), 252);
testeEgaliteEntiers("CM03", conversionMagnitude(2), 250);
testeEgaliteEntiers("CM04", conversionMagnitude(125), 4);
testeEgaliteEntiers("CM05", conversionMagnitude(126), 2);
testeEgaliteEntiers("CM06", conversionMagnitude(127), 0);
testeEgaliteEntiers("CM07", conversionMagnitude(128), 0);
testeEgaliteEntiers("CM08", conversionMagnitude(129), 2);
testeEgaliteEntiers("CM09", conversionMagnitude(130), 4);
testeEgaliteEntiers("CM10", conversionMagnitude(253), 250);
testeEgaliteEntiers("CM11", conversionMagnitude(254), 252);
testeEgaliteEntiers("CM12", conversionMagnitude(255), 254);
}