Bonjour, 

Dans le cadre d'un projet je n'arrive pas à convertir un programme que mon enseignant m'a donné en C++. J'aurais besoin de le convertir en C.

Je demande donc votre aide pour tenter de le convertir.

 void main ()

{ FILE* fichier ;

int buffer; short int i;

fichier = fopen( "testing.wav", "rb") ;

if ( fichier==NULL ) { printf("Ouverture du fichier impossible !");

exit(0); }

printf("\n Liste des valeurs lues : \n");

while ( fread( &buffer, sizeof(short int), 1, fichier),!feof(fichier) )

{

printf( "%d\n", buffer );

}

fclose( fichier ) ;

Je vous en remercie d'avance, bonne journée. 

-
Edité par LucasCachot 28 mars 2017 à 11:16:10

Yop,

C'est déjà du C pas du C++, contente toi de changer l'extension .cpp en .c et de compiler avec un compilateur C.

Merci 

J'ai failli avoir une attaque.

/ * Bibliothèque DHT
	Licence MIT
	écrit par Adafruit Industries
	* /
	# inclure " DHT.h "
	# define MIN_INTERVAL 2000
	DHT :: DHT ( uint8_t pin, uint8_t type uint8_t nombre) {
	_pin = pin;
	_type = type;
	# ifdef __AVR
	_bit = digitalPinToBitMask (pin);
	_port = digitalPinToPort (pin);
	# endif
	_maxcycles = microsecondsToClockCycles ( 1000 ); // délai d'attente de 1 milliseconde pour
	// lecture des impulsions du capteur DHT.
	// Notez que le compte est maintenant ignoré car l'algorithme de lecture DHT s'ajuste
	// basé sur la vitesse du processeur.
	}
	void DHT :: begin ( void ) {
	// installe les goupilles!
	pinMode (_pin, INPUT_PULLUP);
	// L' utilisation de cette valeur permet de s'assurer que millis () - lastreadtime sera
	// > = MIN_INTERVAL immédiatement. Notez que cette affectation se termine,
	// mais aussi la soustraction.
	_lastreadtime = -MIN_INTERVAL;
	DEBUG_PRINT ( " Max cycles d'horloge: " ); DEBUG_PRINTLN (_maxcycles, DEC);
	}
	// booléen S == Échelle. Vrai == Fahrenheit; Faux == Celcius
	float DHT :: readTemperature ( bool S, bool force) {
	float f = NAN;
	si ( lire (force)) {
	commutateur (_type) {
	cas DHT11:
	f = données [ 2 ];
	si (S) {
	f = convertCtoF (f);
	}
	briser ;
	cas DHT22:
	cas DHT21:
	f = données [ 2 ] & 0x7F ;
	f * = 256 ;
	f + = données [ 3 ];
	f * = 0,1 ;
	si (données [ 2 ] & 0x80 ) {
	f * = -1 ;
	}
	si (S) {
	f = convertCtoF (f);
	}
	briser ;
	}
	}
	retourne f;
	}
	float DHT :: convertCtoF ( float c) {
	retourne c * 1.8 + 32 ;
	}
	float DHT :: convertFtoC ( float f) {
	retour (f- 32 ) * 0,55555 ;
	}
	flotter DHT :: readHumidity ( bool la force) {
	float f = NAN;
	if ( read ()) {
	commutateur (_type) {
	cas DHT11:
	f = données [ 0 ];
	briser ;
	cas DHT22:
	cas DHT21:
	f = données [ 0 ];
	f * = 256 ;
	f + = données [ 1 ];
	f * = 0,1 ;
	briser ;
	}
	}
	retourne f;
	}
	// boolean isFahrenheit: True == Fahrenheit; Faux == Celcius
	flotter DHT :: computeHeatIndex ( float température, flotteur percentHumidity, bool isFahrenheit) {
	// Utilisation des équations de Rothfusz et de Steadman
	// http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
	float salut;
	si (! isFahrenheit)
	température = convertCtoF (température);
	hi = 0,5 * (température + 61,0 + ((température - 68,0 ) * 1,2 ) + (pourcentage d'Humidité * 0,094 ));
	si (salut> 79 ) {
	salut = - 42.379 +
	2.04901523 * temperature +
	10.14333127 * pourcentHumidité +
	- 0.22475541 * température * pour centHumidité +
	- 0,00683783 * pow (température, 2 ) +
	- 0,05481717 * pow (pourcentage d'Humidité, 2 ) +
	0,00122874 * pow (temperature, 2 ) * percentHumidity +
	0.00085282 * température * pow (pourcentage d'Humidité, 2 ) +
	- 0,00000199 * pow (température, 2 ) * pow (pourcentage d'Humidité, 2 );
	if ((percentHumidity < 13 ) && (temperature> = 80.0 ) && (temperature <= 112.0 ))
	hi - = (( 13,0 % d'humidité) * 0,25 ) * sqrt (( 17,0 - abs (température - 95,0 )) * 0,05882 );
	else if ((percentHumidity> 85.0 ) && (temperature> = 80.0 ) && (temperature <= 87.0 ))
	hi + = (pour centHumidité - 85,0 ) * 0,1 ) * (( 87,0 - température) * 0,2 );
	}
	retour isFahrenheit? hi: convertFtoC (hi);
	}
	boolean DHT :: read ( bool force) {
	// Vérifie si le capteur a été lu moins de deux secondes auparavant et revient plus tôt
	// utiliser la dernière lecture.
	uint32_t heure actuelle = millis ();
	if (! force && ((heure actuelle - _lastreadtime) < 2000 )) {
	retourne _lastresult; // retourne la dernière mesure correcte
	}
	_lastreadtime = heure actuelle;
	// Remet à zéro les 40 bits de données reçues.
	données [ 0 ] = données [ 1 ] = données [ 2 ] = données [ 3 ] = données [ 4 ] = 0 ;
	// Envoyer le signal de départ. Voir la fiche technique DHT pour le diagramme complet du signal:
	// http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf
	// Aller en état d'impédance élevée pour permettre à la remontée d'augmenter le niveau de la ligne de données et
	// commence le processus de lecture.
	digitalWrite (_pin, HIGH);
	délai ( 250 );
	// Première position de ligne de données basse pour 20 millisecondes.
	pinMode (_pin, OUTPUT);
	digitalWrite (_pin, LOW);
	retarder ( 20 );
	uint32_t cycles [ 80 ];
	{
	// Désactive temporairement les interruptions car les prochaines sections sont critiques
	// et nous ne voulons pas d'interruptions.
	Verrouillage InterruptLock;
	// Terminez le signal de départ en réglant la ligne de données à une valeur supérieure à 40 microsecondes.
	digitalWrite (_pin, HIGH);
	délaiMicrosecondes ( 40 );
	// Maintenant, commencez à lire la ligne de données pour obtenir la valeur du capteur DHT.
	pinMode (_pin, INPUT_PULLUP);
	délaiMicrosecondes ( 10 ); // Retardez un peu pour laisser le capteur tirer la ligne de données à l'état bas.
	// Attend d' abord un signal faible pendant environ 80 microsecondes suivi d'un signal fort
	// encore ~ 80 microsecondes.
	if ( expectPulse (LOW) == 0 ) {
	DEBUG_PRINTLN ( F ( " Délai d'attente pour l'impulsion basse du signal de démarrage. " ));
	_lastresult = false ;
	retourne _lastresult;
	}
	if ( expectPulse (HIGH) == 0 ) {
	DEBUG_PRINTLN ( F ( " Délai d'attente pour l'impulsion haute du signal de démarrage. " ));
	_lastresult = false ;
	retourne _lastresult;
	}
	// Lisez maintenant les 40 bits envoyés par le capteur. Chaque bit est envoyé sous forme de 50
	// impulsion basse en microsecondes suivie d'une impulsion haute de longueur variable. Si la
	// impulsion haute est ~ 28 microsecondes alors c'est un 0 et si c'est ~ 70 microsecondes
	// alors c'est un 1. Nous mesurons le nombre de cycles de l'impulsion basse initiale de 50us
	// et l'utiliser pour comparer le nombre de cycles de l'impulsion haute afin de déterminer
	// si le bit est 0 (nombre de cycles d'état élevé <nombre de cycles d'état faible) ou un
	// 1 (nombre de cycles d'état élevé> nombre de cycles d'état faible). Notez que pour la vitesse tout
	// les impulsions sont lues dans un tableau et ensuite examinées dans une étape ultérieure.
	pour ( int i = 0 ; i < 80 ; i + = 2 ) {
	cycles [i] = expectPulse (LOW);
	cycles [i + 1 ] = expectPulse (HIGH);
	}
	} // Le code critique de synchronisation est maintenant terminé.
	// Inspecter les impulsions et déterminer celles qui sont 0 (nombre de cycles d'état élevé <faible
	// nombre de cycles d'état) ou 1 (nombre de cycles d'état élevé> nombre de cycles d'état faible).
	pour ( int i = 0 ; i < 40 ; ++ i) {
	uint32_t lowCycles = cycles [ 2 * i];
	uint32_t highCycles = cycles [ 2 * i + 1 ];
	if ((lowCycles == 0 ) || (highCycles == 0 )) {
	DEBUG_PRINTLN ( F ( " Délai d'attente pour l'impulsion. " ));
	_lastresult = false ;
	retourne _lastresult;
	}
	données [i / 8 ] << = 1 ;
	// Comparons maintenant les temps de cycle haut et bas pour voir si le bit est à 0 ou à 1.
	if (highCycles> lowCycles) {
	// Les cycles hauts sont supérieurs à 50 us. Le nombre de cycles bas doit être 1.
	données [i / 8 ] | = 1 ;
	}
	// Les autres cycles hauts sont inférieurs (ou égaux à, un cas étrange) au minimum de 50us
	// compte de cycle donc ce doit être un zéro. Rien ne doit être changé dans le
	// données stockées.
	}
	DEBUG_PRINTLN ( F ( " Received: " ));
	DEBUG_PRINT (données [ 0 ], HEX); DEBUG_PRINT ( F ( " , " ));
	DEBUG_PRINT (données [ 1 ], HEX); DEBUG_PRINT ( F ( " , " ));
	DEBUG_PRINT (données [ 2 ], HEX); DEBUG_PRINT ( F ( " , " ));
	DEBUG_PRINT (données [ 3 ], HEX); DEBUG_PRINT ( F ( " , " ));
	DEBUG_PRINT (données [ 4 ], HEX); DEBUG_PRINT ( F ( " =? " ));
	DEBUG_PRINTLN ((données [ 0 ] + données [ 1 ] + données [ 2 ] + données [ 3 ]) & 0xFF , HEX);
	// Vérifie que nous lisons 40 bits et que la somme de contrôle correspond.
	if (data [ 4 ] == ((data [ 0 ] + data [ 1 ] + data [ 2 ] + data [ 3 ]) & 0xFF )) {
	_lastresult = true ;
	retourne _lastresult;
	}
	sinon {
	DEBUG_PRINTLN ( F ( " Echec de la somme de contrôle! " ));
	_lastresult = false ;
	retourne _lastresult;
	}
	}
	// On s’attend à ce que la ligne de signal soit au niveau spécifié pendant un certain temps et
	// retourne un nombre de cycles de boucle dépensés à ce niveau (ce nombre de cycles peut être
	// utilisé pour comparer le temps relatif de deux impulsions). Si plus d'une milliseconde
	// ellapses sans changement de niveau, l'appel échoue avec une réponse nulle.
	// Ceci est adapté de la fonction pulseInLong d'Arduino (disponible uniquement
	// dans les toutes dernières versions de l'IDE):
	// https://github.com/arduino/Arduino/blob/master/hardware/arduino/avr/cores/arduino/wiring_pulse.c
	uint32_t DHT :: expectPulse ( bool niveau) {
	uint32_t count = 0 ;
	// Sur les plates-formes AVR, utilisez un accès direct au port GPIO, qui est beaucoup plus rapide et performant.
	// pour capturer des impulsions de 10 micronsecondes:
	# ifdef __AVR
	uint8_t portState = niveau? _bit: 0 ;
	while ((* portInputRegister (_port) & _bit) == portState) {
	if (count ++> = _maxcycles) {
	retourne 0 ; // Délai dépassé, échouer.
	}
	}
	// Autrement recours à digitalRead (cela semble être nécessaire sur ESP8266
	// maintenant, peut-être des bugs dans les fonctions d’accès direct au port?).
	# else
	while ( digitalRead (_pin) == niveau) {
	if (count ++> = _maxcycles) {
	retourne 0 ; // Délai dépassé, échouer.
	}
	}
	# endif
	compte de retour ;
	}

Bonjour,

Déterrage

Citation des règles générales du forum :

Avant de poster un message, vérifiez la date du sujet dans lequel vous comptiez intervenir.

Si le dernier message sur le sujet date de plus de deux mois, mieux vaut ne pas répondre.
En effet, le déterrage d'un sujet nuit au bon fonctionnement du forum, et l'informatique pouvant grandement changer en quelques mois il n'est donc que rarement pertinent de déterrer un vieux sujet.

Au lieu de déterrer un sujet il est préférable :

• soit de contacter directement le membre voulu par messagerie privée en cliquant sur son pseudonyme pour accéder à sa page profil, puis sur le lien "Ecrire un message"
• soit de créer un nouveau sujet décrivant votre propre contexte
• ne pas répondre à un déterrage et le signaler à la modération

Je ferme ce sujet. Me contacter par MP si besoin.