Morse en c.entrez une phrase et vous entenderez votre haut-parleur du pc bipper!!(interruptions logicielles)

Soyez le premier à donner votre avis sur cette source.

Vue 7 657 fois - Téléchargée 427 fois

Description

Reproduit le code morse grâce au haut-parleur à l'intérieur de votre unité centrale à partir d'une phrase entrée...
Version simple : utilise des fonctions toutes toutes faites.
Version complexe : programmation de toutes les interruptions logicielles...

!! Gros probleme !! : le prog a été fait à l'IUT sous TURBO C.et je n'arrive pas à le re-compiler chez moi.erreur lié à la librairie dos.h -> Please help me!
Si qqn peut m'aider n'hésitez surtout pas...
Par contre si qqn veut teste l'executable chez lui ya pas de problème jme la suis ramené par disquette..mailez-moi..

>> J'ai téléchargé TURBO C version 4.5 et ça compile enfin!! (j'ai corrigé en plus l'erreur le majuscule qu'il y avait..)

Source / Exemple :


// Version complexe //
#include <iostream.h>
#include <dos.h>
#include <ctype.h>

REGS Rin,Rout;
void Pause    (void);
void Silence  (void);
void BipCourt (void);
void BipLong  (void);
void Son();
void PaSon();
void EmettreTexte   (char ChaineMorse[]);
char VerifierChaine (char ChaineAVerifier[]);
void ConvertirMaj   (char ChaineAConvertir[]);
void ConvertirCar   (char c, char ChaineResultat[]);

const unsigned char tabMorse[]={0x42,0x84,0xA4,0x83,0x01,0x24,0xC3,0x04,0x02,0x74,0xA3,0x44,0xC2,0x82,0xE3,0x64,0xD4,0x43,0x03,0x81,0x23,0x14,0x63,0x94,0xB4,0xC4};
const unsigned short int FREQUENCEBIP=700;
const unsigned short int DUREE=70;
const int TMAX=200;
const int TMORSE=7;

//==========================================================main
// Procedure principale
//==========================================================

void main (void)
{

	unsigned char Phrase[TMAX+1];
	unsigned char CarMorse[TMORSE];
	char car;
	int i;

	cout<<"\\\\nBienvenue au programme de conversion TEXTE ECRIT -> MORSE\\\\n";

	//======================
	//Saisie et verification
	//======================

	do {
		cout<<"\\\\nEntrez une phrase (200 caracteres alphabtiques max) : ";
		cin.get(Phrase,sizeof(Phrase));

		// test de troncation; remise en etat du flot d'entree si necessaire
		if (cin.get(car) && car!='\\\\n') {
			cin.clear();
			cin.ignore(1000,'\\\\n');
		}
	} while (!VerifierChaine(Phrase));

	//======================
	//Conversion Majuscules
	//======================

	ConvertirMaj(Phrase);

	//======================
	//Conversion Morse
	//======================

	cout<<"\\\\n\\\\nLa phrase en Morse est : ";

	i=0;
	while (Phrase[i]!='\\\\0')
	{
		ConvertirCar(Phrase[i],CarMorse);
		cout<<Phrase[i]<<CarMorse;
		EmettreTexte(CarMorse);
		i++;
	}
	cout<<endl<<endl;
};

//==========================================================Pause
// Cette procedure attends un laps de temps defini par la
// constante DUREE.
//==========================================================
void Pause(void){
long int pause;
Rin.h.ah=0;
int86(0x1A,&Rin,&Rout);
long int x=Rout.x.cx;
x<<=16;
x=x+Rout.x.dx;
do { 
Rin.h.ah=0;
int86(0x1A,&Rin,&Rout);
pause=Rout.x.cx;
pause<<=16;
pause=(pause+Rout.x.dx)-x;
}
while(pause < DUREE/55);
};

//==========================================================Silence
// Cette procedure "emet" un silence correspondant au
// caractere espace.
//==========================================================

void Silence (void)
{
PaSon();
Pause();
};

//==========================================================BipCourt
// Cette procedure emet un bip court correspondant au '.'
// suivi d'un silence afin de marquer la separation
// avec le '.' ou le '-' suivant
//==========================================================

void BipCourt (void)
{
Son();
Pause();
Silence();
};

//==========================================================BipLong
// Cette procedure emet un bip long correspondant au '-'
// suivi d'un silence afin de marquer la separation
// avec le '.' ou le '-' suivant
//==========================================================

void BipLong (void)
{  Son();
   Pause();
   Pause();
   Pause();
   Silence();
};

//==========================================================EmettreTexte
// Procedure qui emet les sons correspondant a un texte morse
// compose de '-', de '.' et d'espaces. Elle emet un bip long
// a la rencontre de '-', un bip court a la rencontre de '.'
// et un silence a la rencontre d'un espace.
//==========================================================

void EmettreTexte (char ChaineMorse[])
{
   for(int i = 0;i<=TMORSE;i++)
   {
   if(ChaineMorse[i]=='-') BipLong();
   if(ChaineMorse[i]=='.') BipCourt();
   else Silence();
   }
};
//==========================================================VerifierChaine
// Fonction qui verifie qu'une chaine est composee
// uniquement de caracteres alphabetiques (et/ou d'espaces)
// Elle renvoie 1 si la chaine passee en parametre est correcte,
// et 0 sinon.
//==========================================================

char VerifierChaine (char ChaineAVerifier[])
{
	int i=0;
	char c=ChaineAVerifier[i];

	while (c!='\\\\0')
	{
		if (!isalpha(c) && c!=' ') return 0;
		i++;
		c=ChaineAVerifier[i];
	};
	return 1;
};

//==========================================================ConvertirMaj
// Procedure qui convertit une chaine de caracteres
// alphabetiques en chaine de caracteres majuscules
//==========================================================

void ConvertirMaj (char ChaineAConvertir[])
{
	int i=0;
	char c=ChaineAConvertir[i];

	while (c!='\\\\0')
	{
		ChaineAConvertir[i]=toupper(c);
		i++;
		c=ChaineAConvertir[i];
	}
};

//==========================================================ConvertirCar
// Procedure qui convertit un caractere en une chaine
// composee de '-' et de '.' representant son code morse.
// Le caractere doit etre une lettre alphabetique majuscule
// ou bien un espace.
// 2 espaces sont systematiquement rajoutes . la fin de la chaine
// morse. Si le caractere a convertir est un espace alors
// la chaine generee est composee de 4 espaces.
//==========================================================

void ConvertirCar (char c, char ChaineResultat[])
{
	int i=0,j,k,n;

	if(!isupper(c) && c!=' ') return;
	if (c==' ')
	{
		ChaineResultat[i++]=' ';
		ChaineResultat[i++]=' ';
	}
	else
	{
		c=TabMorse[c-'A'];
		n=c&7;
		j=128;

		for (k=0;k<n;k++) {
			if (c&j) ChaineResultat[i++]='-';
			else	 ChaineResultat[i++]='.';
			j=j>>1;
		}
	}
	ChaineResultat[i++]=' ';
	ChaineResultat[i++]=' ';
	ChaineResultat[i]='\\\\0';
};

//==========================================================Son
// Procedure met en marche le haut parleur.
//==========================================================
void Son() {
int i=inportb(0x61);
i=i | 3;
outportb(0x61,i);
outportb(0x43,182);
outport(0x42,FREQUENCEBIP%256);
outport(0x42,FREQUENCEBIP/256);
}

//==========================================================PaSon
// Procedure coupe le son.
//==========================================================
void PaSon() {
int i=inportb(0x61);
i=i & 252;
outport (0x61,i);
}

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
31
Date d'inscription
dimanche 15 juillet 2001
Statut
Membre
Dernière intervention
8 janvier 2009

ouais mdr je viens juste de faire un proggy pareil avec waveOut ;)
jm'en va le poster
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
28
pas la peine d'aller faire un truc qui ne tournera plus que sur des systemes obsoletes, sers toi plutot de l'API.
Beep(frequence, duree);
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
8
moi avec turbo c++ ca compile et ca marche nikel, cependant il ya une erreur de recopie, c'est pas TabMorse[c-'A']; mais tabMorse[c-'A'];
Messages postés
29
Date d'inscription
mercredi 14 janvier 2004
Statut
Membre
Dernière intervention
5 mars 2007

arg........j'essayerai sous millenium bientot alors...
mais est-ce que ça résoudra le prob?!?
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
28
desole mais sous XP et win32 en general, on ne touche pas aux interruptions, c'est reserve au kernel mode.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.