Communiquer avec port série PC - Page 1

Bonjour,

Je souhaite faire communiquer ma ti 89 platinium avec le port série d'un PC sans passer par le logiciel TI connect pour faire passer les données que je veux.
J'ai fouillé pas mal de forums et de site webs sans trouver mon bonheur. J'ai cependant trouvé un code qui fait communiquer un palm avec une ti en passant par un port série. Je me suis inspiré de ce code.

Voici mon code :

// C Source File
// Created 10/07/2007; 15:31:05

#include <tigcclib.h>

#define LINK_STATUS 0x60000C
#define LINK_PORT 0x60000E
#define CLK_L_DAT_L 0x0300
#define CLK_L_DAT_H 0x0200
#define CLK_H_DAT_H 0x0000

#define MAX_SERIAL_DATA 100




volatile int *pLinkPort = (int*) LINK_PORT;
int *pLinkStatus = (int*) LINK_STATUS;
int iOldPortStatus = 0;
unsigned BitPeriod1 = 0;
unsigned BitPeriod1Tx = 0;
unsigned BitPeriod15 = 0;
unsigned char SerialDataTx[ MAX_SERIAL_DATA ] = "0";

// Main Function
void _main(void)
{

// Place your code here.
clrscr();
OpenLinkPort();
InitBaudRate(); //9600 baud

SendSerialData('a');
ngetchx();

CloseLinkPort();

}


void OpenLinkPort ()
{
printf("Ouverture du port COM\n");
iOldPortStatus = *pLinkStatus;
*pLinkStatus = 0xFF00;
return;
}

void CloseLinkPort()
{
printf("Fermeture du port COM\n");
*pLinkPort = 0x0000;
*pLinkStatus = iOldPortStatus;
return;
}

void InitBaudRate()
{
BitPeriod1 = 113;
BitPeriod15 = 162;
// BitPeriod1Tx = BitPeriod1;
}

void SendSerialData( unsigned BytesToSend )
{
printf("Envoie de donne\n");
unsigned ByteIndex, BitCycle;
unsigned char CurrentByte;

OSSetSR (0x0700); // Disable all interrupts, so our critical
// timing is pure and not affected
*pLinkPort = CLK_L_DAT_H;

for ( ByteIndex = 0; ByteIndex < BytesToSend; ByteIndex++ )
{
CurrentByte = SerialDataTx[ ByteIndex ];

if ( BytesToSend == 0xFFFF )
{
if ( CurrentByte == 0 )
{
break;
}
}

*pLinkPort = CLK_H_DAT_H; // Send Start Bit

DoDelay( BitPeriod1Tx );

for (BitCycle = 0; BitCycle < 8; BitCycle++)
{
if ( CurrentByte & ( 1 << BitCycle ) )
{
*pLinkPort = CLK_L_DAT_H;
}
else
{
*pLinkPort = CLK_H_DAT_H;
}
DoDelay( BitPeriod1Tx );
}

*pLinkPort = CLK_L_DAT_H;
DoDelay( BitPeriod1Tx ); // Send Stop Bit
}

OSSetSR (0x0000);
return;
}

void DoDelay( unsigned DelayTime )
{
int Temp;

while ( DelayTime-- )
{
Temp = *pLinkStatus;
}

return;
}


Cependant mon problème ne s'arrête pas là, car j'ai fabriqué moi même un câble série mais je ne sais pas si il fonctionne, je me suis aidé de ce schéma :

J'ai vérifié quand même avant les tensions et elles sont bonnes. Je sais qu'on est dans le topic programmation c mais si vous pouviez me dire si il peux fonctionner ca m'aiderai à me concentrer sur mon problème originel.

Merci pour votre aide.

ps : si vous avez des liens sur des sites ou des forums traitant de ce sujet je les prends volontier (anglais et français), même si j'en ai déjà visité un bon paquets.

- la ti platinium n'existe que dans tes rêves

- ce code devrait marcher pour envoyer au PC, mais la vitesse dépend des piles.

le souci c'est que le port des TI n'est que half duplex et n'a aucun buffer ni aucune interruption, donc si le PC envoie une données HOP comme ça sans prévenir, la TI est incapable de le détecter. Si t'en as pas besoin tant mieux, sinon tant pis

PS: t'aurais pu mettre ça dans hardware au lieu de programmation

la ti platinium n'existe que dans tes rêves
30s je me mets 2 baffes et je me réveil ^^ je voulais dire évidemment titanium...

t'aurais pu mettre ça dans hardware au lieu de programmation
J'ai hésité mais il y a tout mon code qui d'ailleur ne fonctionne pas^^ donc je l'ai mis dans programmation. Et pour l'instant j'ai juste besoin d'envoyer de la ti à un pc.

Je continu de tester pour voir ce qui ne fonctionne pas mais là je commence à sécher.

il me semble que tu tires ton truc d'un soft qui connectait un palm à une ti pour pouvoir dessiner avec le stylet. Il me semble me souvenir que le soft coté TI avait besoin d'une calibration en recevant un caractère quelconque, espace entrée ou chéplukoi , pour que la TI puisse se caler sur le baudrate réel.

Vu que la vitesse des timers de la TI dépend de la charge des piles...

Oui c'est bien ce programme dont je me suis inspiré mais j'avais pas compris qu'en fait on avait pas le choix de la vitesse d'emmission ... donc vu que mes piles sont neuves l'emmission doit être plus rapide que 9600 bauds. Je vais tester ca tout de suite. Merci du renseignement.

Et pour le câble est ce qu'il est correct ?

A priori oui. De toute les deux ports sont solides, et les zeners protègent des plus grosses couffes.

si tu branches mal tu recevras rien.

Bon je reprend mon post^^
J'ai modifier 2-3 trucs dans mon code, notamment pour qu'il détecte la vitesse d'emmission. Cependant lors de la détection de la vitesse il me met à chaque fois baud not found. Je vois pas pourquoi.
Mon code modidié :

// C Source File
// Created 10/07/2007; 15:31:05

#include <tigcclib.h>

#define LINK_STATUS 	0x60000C
#define LINK_PORT 		0x60000E
#define CLK_L_DAT_L 	0x0300
#define CLK_L_DAT_H 	0x0200
#define CLK_H_DAT_H 	0x0000
#define READ_DATA			0x0400
#define MAX_SERIAL_DATA 	 100




volatile int *pLinkPort = (int*) LINK_PORT;
int *pLinkStatus = (int*) LINK_STATUS;
int iOldPortStatus = 0;
unsigned BitPeriod1 = 0;
unsigned BitPeriod1Tx = 0;
unsigned BitPeriod15 = 0;
unsigned BaudRateIndex = 5;
unsigned BaudSense = 0;
unsigned char SerialDataTx[ MAX_SERIAL_DATA ] = "0";
unsigned BaudRateBreakPoints[ 9 ] = { 110, 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600 }; 
unsigned BaudSenseBreakPoints[ 9 ] = { 1659, 555, 164, 81, 39, 18, 7, 3, 0 };
int passage=0;



void DoDelay( unsigned DelayTime );
void SendSerialData( unsigned BytesToSend );
void CloseLinkPort();
void OpenLinkPort ();
float RoundFloat( float ValueToRound );
int SenseBaudRate( unsigned PeriodsToCompare );
void DrawParameters();

// Main Function
void _main(void)
{
	//Open the COM port
	OpenLinkPort();
	*pLinkPort = CLK_L_DAT_H;					// Setting Tx (white) low, inactive and
  																	// setting Rx (red) line high so we can sense its state.
	//Set a baudrate
	SetBaudRate( BaudRateIndex );
	//Print parameters
	DrawParameters();
	ClrScr();
	//Print text
	DrawStr( 0, 0, "Press a key for sensing...", A_NORMAL );
	ngetchx();
	ClrScr();
	//Print text
	DrawStr( 30, 0, "Sensing Baud  ", A_REPLACE);
	//Call the function to know the baud rate
	if ( SenseBaudRate( 0x000A ) ) 
	{
	//Print an error text
		DrawStr( 30, 0, "Baud Not Found", A_REPLACE);
	}
	else
	{
	//Print a text
		DrawStr( 30, 0, "Done Sensing  ", A_REPLACE);
		passage++;
	}
	
	if(passage == 1)
	{
		//Print parameters
		DrawParameters();
		DrawStr( 30, 0, "Press a key to send a data", A_REPLACE);
		ngetchx();
		//Send a date to the COM port	
		SendSerialData('a');
		CloseLinkPort();
	}
	ngetchx();
}
//Function : print the baudrate
void DrawParameters()
{
	printf("Baud Rate       = %5u", BaudRateBreakPoints[ BaudRateIndex ] );
}
//Function : open the COM port
void OpenLinkPort ()
{
	printf("open COM port\n");
	iOldPortStatus = *pLinkStatus;
	*pLinkStatus = 0xFF00;
	return;
}

//Function : close the COM port
void CloseLinkPort()
{
	printf("Close COM port\n");
	*pLinkPort = 0x0000;
	*pLinkStatus = iOldPortStatus;
	return;
}
//Function : send a data to the COM
void SendSerialData( unsigned BytesToSend )
{
	printf("Send data\n");
	unsigned ByteIndex, BitCycle;
	unsigned char CurrentByte;

	OSSetSR (0x0700);														// Disable all interrupts, so our critical 
	  																					// timing is pure and not affected
	*pLinkPort = CLK_L_DAT_H;

	for ( ByteIndex = 0; ByteIndex < BytesToSend; ByteIndex++ )
	{
		CurrentByte = SerialDataTx[ ByteIndex ];

		if ( BytesToSend == 0xFFFF ) 
		{
			if ( CurrentByte == 0 )
			{
				break;
			}
		}

		*pLinkPort = CLK_H_DAT_H;									// Send Start Bit
						
		DoDelay( BitPeriod1Tx );
		
		for (BitCycle = 0; BitCycle < 8; BitCycle++)
		{
			if ( CurrentByte & ( 1 << BitCycle ) )
			{
				*pLinkPort = CLK_L_DAT_H;
			}
			else
			{
				*pLinkPort = CLK_H_DAT_H;
			}
			DoDelay( BitPeriod1Tx );
		}
		
		*pLinkPort = CLK_L_DAT_H;
		DoDelay( BitPeriod1Tx );									// Send Stop Bit
	}
		
	OSSetSR (0x0000);
	return;
}

void DoDelay( unsigned DelayTime )
{
	int Temp;
	
	while ( DelayTime-- )
	{
		Temp = *pLinkStatus;
	}

	return;	
}


void SetBaudRate( unsigned BaudRateIndexToSet )
{
	BaudRateIndex = BaudRateIndexToSet;
	
	switch ( BaudRateIndexToSet )
	{
		case 0: // 110
			BitPeriod1 = 11658;
			BitPeriod15 = 17475;
			BitPeriod1Tx = BitPeriod1;
			break;
			
		case 1:	// 300
			BitPeriod1 = 4259;
			BitPeriod15 = 6397;
			BitPeriod1Tx = BitPeriod1;
			break;
			
		case 2:	// 1200
			BitPeriod1 = 1048;
			BitPeriod15 = 1577;
			BitPeriod1Tx = BitPeriod1;
			break;
	
		case 3: // 2400
			BitPeriod1 = 515;
			BitPeriod15 = 778;
			BitPeriod1Tx = BitPeriod1;
			break;
			
		case 4: // 4800
			BitPeriod1 = 247;
			BitPeriod15 = 362;
			BitPeriod1Tx = BitPeriod1;
			break;
			
		case 5: // 9600
			BitPeriod1 = 113;
			BitPeriod15 = 162;
			BitPeriod1Tx = BitPeriod1;
			break;
			
		case 6: // 19200
			BitPeriod1 = 46;
			BitPeriod15 = 76;
			BitPeriod1Tx = 44;
			break;
			
		case 7: // 38400
			BitPeriod1 = 13;
			BitPeriod15 = 27;
			BitPeriod1Tx = 11;
			break;
			
		case 8: // 57600
			BitPeriod1 = 2;
			BitPeriod15 = 10;
			BitPeriod1Tx = 0;
			break;

	}
	return;
}

int SenseBaudRate( unsigned PeriodsToCompare )
{
	unsigned ActiveTime, InactiveTime, BaudIndex, BitTimeMin = 0xFFFF;
	float fBitPeriod1, fBitPeriod15, fBaudSense;
	
	OSSetSR (0x0700);														// Disable all interrupts, so our critical 
																							// timing is pure and not affected
	*pLinkPort = CLK_L_DAT_H;	

	while ( --PeriodsToCompare > 0 )
	{
	
		if ( (*pLinkPort & READ_DATA) == 0 )			// Serial port going high (+V) (Start Bit)
		{
			ActiveTime = 0;
			while ( (*pLinkPort & READ_DATA) == 0 )			
			{
				++ActiveTime;
				if ( ActiveTime == 0xFFFF )
				{
					break;
				}
			}
	
			if ( ActiveTime < BitTimeMin )
			{
				BitTimeMin = ActiveTime;
			}
		}
		

		if ( *pLinkPort & READ_DATA )							// Serial port going low (-V)
		{
			InactiveTime = 0;
			while ( *pLinkPort & READ_DATA )			
			{
				++InactiveTime;
				if ( InactiveTime == 0xFFFF )
				{
					break;
				}
			}
	
			if ( InactiveTime < BitTimeMin )
			{
				BitTimeMin = InactiveTime;
			}
		}
	}
		
	if ( BitTimeMin == 0xFFFF )		// No valid sense has occurred
	{
		OSSetSR (0x0000);						// Enable Interrupts
		return 1;		
	}

	BaudSense = BitTimeMin;
	fBaudSense = (float) BitTimeMin;
	
	for ( BaudIndex = 0; BaudIndex <= 8; BaudIndex++ )
	{
		if ( BaudSense > BaudSenseBreakPoints[ BaudIndex ] )
		{
			break;
		} 
	}
	
	BaudRateIndex = BaudIndex;
	
	// Use a linear interpolation on Bit Periods based off of BaudSense
	//
	fBitPeriod1 = ( fBaudSense * 4.8051 ) - 8.7589;
	fBitPeriod15 = ( fBaudSense * 7.2 ) - 6.8;
	
	BitPeriod1 = (int) RoundFloat( fBitPeriod1 );
	BitPeriod15 = (int) RoundFloat( fBitPeriod15 );
	
	switch ( BaudRateBreakPoints[ BaudRateIndex ] )
	{
		// Patch in the bit periods for the fastest speeds.  They cannot be calculated
		// accurately because BaudSense has little resolution at these speeds.
		// These speeds will not "self correct" to battery voltage and clock offset.

		case 57600:
			BitPeriod1 = 2;
			BitPeriod15 = 10;
			BitPeriod1Tx = 0;
			break;
			
		case 38400:
			BitPeriod1 = 13;
			BitPeriod15 = 27;
			BitPeriod1Tx = 11;
			break;
			
		case 19200:
			BitPeriod1Tx = 44;
			break;
			
		default:
			BitPeriod1Tx = BitPeriod1;	
			break;	
	}

	OSSetSR (0x0000);													// Enable Interrupts
	return 0;	
}
float RoundFloat( float ValueToRound )
{
	float Frac, RoundedValue, *pTempCrap = &RoundedValue;
	
	Frac = modf( ValueToRound, pTempCrap );

	if ( Frac >= 0 )
	{
		if ( Frac > 0.5 )
		{
			RoundedValue = ceil( ValueToRound );
		}
		else
		{
			RoundedValue = floor( ValueToRound );
		}
	}
	else
	{
		if ( Frac < -0.5 )
		{
			RoundedValue = floor( ValueToRound );
		}
		else
		{
			RoundedValue = ceil( ValueToRound );
		}
	}

	return ( RoundedValue );

}

désolé, mais en italique et sans indentation c'est totalement illisible.

e ton post et utilise la balise trucEdit pas italique stp.

Bon en fait ce code marche pour détecter la vitesse de transmission, mais il ne m'envoie rien^^

Et désolé pour l'indentation mais elle saute à chaque fois.

faux, si tu faisais ce que je t'ai dit en éditant tes posts, tu incluerais l'indentation et je pourrais lire le code.

t'as édité mon post pour regarder? [cite ] est inutile, c'est [pre ] que tu dois utiliser. Réfléchis 2 secondes.

Désolé je ne suis pas un habitué des posts sur forum.

Pour le code je bloque sur l'envoie.

J'ai mis des printf un peu partout pour voir ce que le code faisait et je suis tombé sur :
CurrentByte = SerialDataTx[ ByteIndex ];

SerialDataTx est initialisé à 0 et rempli nul part et quand je fais un printf j'obtiens :
48
0 (98 fois)
27
78
96
0
0
48
46
0
8
51
192
0
3
133
110
12
64
0
8
98
0
1

Je ne comprends pas ces valeurs et pourquoi je n'ai pas la donnée que je cherche à envoyer? ou son code ascii ?

va t'acheter des yeux

void SendSerialData( unsigned BytesToSend )

y'a pas marqué "data"
le paramètre est le nombre d'octets en envoyer
les octets réels doivent être préalablement stockés dans le buffer SerialDataTx[] qui n'est pas initialisé, vu que tu ne remplis pas... et dont l'initialisation à "0" est inutile et même fausse.

d'où l'utilité de lire le code et de faire l'effort de le comprendre.

Connais tu exactement le protocole que tu es en train d'utiliser? si oui, alors tu poserais pas ces questions.

Tu n'es pas très courtois, squalyl

désolé, certainement parce que je me débats avec plein d'autres trucs en C à coté, et que je sais que le port série sur TI est chiant à réaliser.

Bon théoriquement :
SerialDataTx [ 0 ] = 'z';
SendSerialData(1);

ca ca marche
Mais j'ai un soucis j'aimerais récupérer la vitesse d'emmission de la calculette mais je n'y arrive pas, j'ai mis des printf dans toute la fonction SenseBaudRate() mais sans succès.
J'ai actuellement un problème technique (j'ai pété mon cable série), je reprendrais donc demain.

Bon ca y est mon cable remarche^^
Je chope le bautrate qui est a 2400 mais toujours pas de données envoyées

squalyl (./14) :
désolé, certainement parce que je me débats avec plein d'autres trucs en C à coté, et que je sais que le port série sur TI est chiant à réaliser.

ça n'excuse rien...

C'est pas grave, ce qui l'est plus c'est que j'arrive toujours pas à envoyer de données grrr

Je peux pas aider, mon link est cassé...