Diseño de software de comunicación de doble computadora basado en puerto serie

Normalmente uso VB.Net para programar. Si encuentro un control de puerto serie, puedo crear fácilmente un montón de códigos. ¿Tu lenguaje C es C? ¿Admite controles?

Ah, por cierto, ve al foro de CSDN. Gastar dinero resuelve el problema. Un simple uno o doscientos, un complejo uno o dos mil.

Escribir programas de puerto serie en lenguaje C

Hoy en día, existen muchos tipos de software de programación populares. Son convenientes de programar y fáciles de mantener, pero no sirven de nada cuando se tratan directamente. hardware y software del sistema de compilación, por lo que el lenguaje C entra en juego. Como lenguaje de transición entre el lenguaje ensamblador y el lenguaje de alto nivel, el lenguaje C tiene la eficiencia del lenguaje ensamblador y la conveniencia del lenguaje de alto nivel.

En la comunicación, para garantizar un funcionamiento seguro y confiable, el puerto serie estándar debe tener muchas señales de intercambio e información de estado. Esto se debe a que las velocidades de la CPU de cada computadora que se comunica son diferentes (lo que puede generar "tramas incorrectas") y el transmisor puede enviar datos más rápido de lo que el receptor puede recibirlos (lo que puede generar un "sobreimpulso"). Para resolver este problema, utilizamos una señal de protocolo de enlace simple, es decir, el transmisor solo envía medio byte (4 bits inferiores) de datos cada vez, mientras que la otra mitad (4 bits superiores) se utiliza para transmitir información. Simplemente podemos codificar los bits de información (4 bits altos) de la siguiente manera:

0H: se envían nuevos datos de medio byte

1H: se reenvían los datos del último error de transmisión

2H: fin del nombre del archivo

3H: fin del archivo

De esta forma, cada vez que el remitente envía un byte, espera a que el receptor lo devuelva. Enviar un señal, esta vez la señal es el byte enviado por el transmisor. Después de que el remitente recibe la señal de eco, la compara con el byte que acaba de enviar. Si es el mismo, envía el nuevo medio byte; de ​​lo contrario, lo reenvía. Los datos nuevos se distinguen de los antiguos por bits de información. El siguiente es un programa escrito en lenguaje C para controlar el puerto serie.

#incluye "dos.h"

#incluye "stdlib.h"

#incluye "stdio.h"

# definir PUERTO 0

void SendFile(char *fname); /* Enviar archivo*/

void Send(int s);*Enviar un byte*/

void SendFileName(char *fname); /*Enviar nombre de archivo*/

void RecibirFile() /*Recibir archivo*/

void GetFileName(char *f); /*Recibir nombre de archivo*/

void InitPort(int port, unsigned char para); /*Inicializar puerto*/

void SendPort(int port, char c); Puerto de envío*/

int ReadPort(int puerto); /*Leer bytes del puerto*/

int CheckState(int puerto) /*Verificar el estado del puerto*/

int Recibir(int puerto, int *G); /*Recibir un byte*/

main(int argc, char *argv[])

{

if(argclt; 2){

printf("Ingrese el parámetro R (recibir) o S (enviar): "); /p>

}

InitPort(PUERTO, 231)

if(*argv[1]==''''S'''') /*Verificar la validez de la selección*/

SendFile(argv[2]);

else if(*argv[1]==''''R'''' )

RecibirArchivo();

else{

printf("Error parámetro. Ingrese nuevamente."); ;

}

}

void SendFile(char *fname)

{

ARCHIVO * fp;

int ch, s;

if((fp=fopen(fname, "rb"))==NULL)

{

printf("No se puede abrir el archivo.\n");

exit(1

}

SendFileName (fname); );

hacer{

ch=(int)getc(fp);

if(ferror(fp)){

printf("Error al leer el archivo.\n");

break;

}

s=ch16 /*Obtener un byte en el archivo. 4 bits*/

Envío(s)

;

s=ch/16; /*Obtener los 4 bits superiores de un byte en el archivo*/

Enviar(s);

}mientras ( !feof(fp));

s=46; /*Enviar información final del archivo*/

Envío(s);

Envío(s) ;

fclose(fp);

}

envío(s) vacío(s)

int s; {

int G;

SendPort(PUERTO, s);

G=ReadPort(PUERTO /*Esperando señal de protocolo de enlace*/

if(s!=G)

s=s 16;

hacer{

SendPort(PORT, s

G=ReadPort(PORT); /*Esperando señal de protocolo de enlace*/

} while(s!=G);

}

void SendFileName(fname )

char *fname;

{

int s, ch

printf("Ahora transmite el archivo. Espere..");

while(*fname){

ch=(int)fname;

s=ch16; /*Obtenga uno. de los nombres de archivos Los 4 bits inferiores del byte*/

Envío(s);

s=ch/16

Envío(s); /*Obtener el nombre del archivo Los 4 bits inferiores de un byte*/

}

s=32 /*Enviar el indicador de final del nombre del archivo*/

Envío(s);

}

void RecibirArchivo(){

ARCHIVO *fp;

char ch;

int G1, G2, G3;

char fname[15]; /p>

printf ("Recibiendo archivo s.\n", fname);

remove(fname);

if((fp=fopen(fname, "wb). "))==NULL)

{

printf("No se puede abrir el archivo de salida.\n");

exit(1 );

}

/*El bucle es para verificar si los datos recibidos cada vez son datos nuevos. Si no, */

/*Los datos. recibido esta vez sobrescribirá los últimos datos recibidos*/

G1=ReadPort(PORT);

G2=Receive(PORT,&G1);

do{

G3=Receive(PORT,&G2);

ch=(char)(G116 G2*16);/*Restaurar datos separados, combinar 4 bits altos y 4 bajos bits*/

putc(ch, fp);

if(ferror(

fp)){

printf("\nError al escribir el archivo.");

exit(1); =Recibir(PUERTO,&G3);

G1=G3;

}mientras(G1/16!=48);

printf("\ nTransmisión finalizada .");

fclose(fp);

}

int Recibir(puerto, G)

int puerto, *G

{

int GM;

SendPort(puerto, *G)

GM=ReadPort(puerto); p>

if(GM/16==0)

devolver GM;

else if(GM/16==1){

hacer {

*G=GM;

SendPort(puerto, GM);

GM=ReadPort(puerto); (GM/16==1);

}

return GM;

}

void GetFileName(char *f )

{

int G1, G2, G3;

char ch;

G1=ReadPort(PUERTO); p> G2=ReadPort(PUERTO);

hacer{

G3=Recibir(PUERTO,&G3);

ch=(char) (G116 G2/ 16);

*f=ch;

*f;

G2=Recibir(PUERTO,amp;G3);

G1=G3;

} while(G1/16!=32);

printf("Transmisión del nombre del archivo finalizada.\n");

void InitPort(puerto, para)

int puerto

unsigned char para

{

unión REGS reg;

reg.x.dx=puerto;

reg.h.ah=0;

reg.h.al =para;

int86(0x14,?,?);

}

void SendPort(puerto, c)

int puerto ;

char c;

{

unión REGS reg;

reg.x.dx=puerto;

reg. h.al=c;

reg.h.ah=1;

int86(0x14,?,?);

si( reg.h. ahamp;128){

printf("\n¡Enviar errores!"

salida(1);

}

}

int ReadPort(puerto)

int puerto;

{

union REGS reg;

while(!(CheckState(port)amp;256)){

if (kbhit()){/*Si el puerto no tiene datos durante mucho tiempo, la espera puede finalizar artificialmente*/

printf("Presione cualquier tecla para salir.");

getch();

salir(1);

}

}

reg.x.dx=puerto;

reg .h.ah=2;

int86(0x14,?,?);

if(reg.h.ahamp;128){

printf( "\nError de lectura!");

exit(1);

}

return reg.h.al;

}

int CheckState(puerto)

int puerto

{

unión REGS

reg.x.dx=puerto;

reg.h.ah=3;

int86(0x14,?,?);

return reg.x.ax ;

}

El programa anterior puede transferir archivos en varios formatos y también tiene ciertas capacidades de corrección automática de errores, pero su capacidad para manejar situaciones anormales Es relativamente débil y los lectores pueden mejorarlo ellos mismos. Debido a limitaciones de espacio, se solicita a los lectores que verifiquen por sí mismos la información relevante sobre la función de la interrupción 14H, el significado de los parámetros de entrada y los parámetros de retorno.

************************************

Apéndice:

La mayoría de los puertos serie ahora siguen el estándar RS-232. Las siguientes son las señales RS-232 más utilizadas:

Nombre, número de pin, significado

. RTS 4 Solicitud de envío (solicitud de envío)

CTS 5 Borrar para enviar (borrar para enviar)

DSR 6 Conjunto de datos listo (dispositivo de datos listo)

DTR 20 Terminal de datos listo (terminal de datos listo)

TXD 2 Transmitir datos (enviar datos)

RXD 3 Recibir datos (recibir datos)

GRD 7 Tierra( Tierra)