Ir ao conteúdo
Regras do Clube do Hardware

C comunicação entre dois computadores

Feucon

Por Feucon
em C/C#/C++

 Compartilhar

Posts recomendados

Feucon
 

Feucon

Postado
Postado

ola , estou com um grande problema , preciso fazer uma comunicação entre dois PCS com o objetivo de um enviar pacotes para um e o outro receber ,porém comecei a fazer e n consigo mais ir para frente , alguém pode me ajudar ? aqui em baixo esta o programa em C

  

#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <vector>
#include <cstdlib>

using namespace std;

class SerialPort
{
    private:
        //Declaração da porta serial.
        HANDLE hComm;

        //Vetores Auxiliares

        char Buffer[8096];
        char Byte;

        //Variáveis de Controle da Porta Serial.
        DWORD dwToRead;
        DWORD dwRead;
        DWORD dwWritten;
        DWORD BaudRate;
        BYTE Parity;
        BYTE StopBits;
        BYTE ByteSize;

    public:
        //Construtor da classe SerialPort.
        SerialPort();

        //Abertura e fechamento da porta serial.
        BOOL OpenSerialPort(string, string);
        void CloseSerialPort();

        //Escrita e leitura do buffer de dados.
        BOOL WriteABuffer(char *, DWORD);
        char * ReadABuffer();

        //Demais parâmetros de controle da porta serial.
        vector <string> CheckSerialPort();
        unsigned int getBufferSize();

};
//---------------------------------------------------------------------------

SerialPort::SerialPort()
{
    //Variável que que receberá a porta serial aberta.
    hComm = NULL;

    //Valores padrão.
    BaudRate = CBR_115200;  // CBR_38400, CBR_9600
    Parity   = NOPARITY;    // 0 - 4 = no, odd, even, mark, space
    StopBits = ONESTOPBIT;  // 0 - 2 = 1, 1.5, 2
    ByteSize = 8;

    //Configuração dos tamanhos dos buffers de leitura e escrita.
    dwToRead = 2048;
}
//---------------------------------------------------------------------------

BOOL SerialPort::OpenSerialPort(string asPort, string asBaudRate)
{
    string asCommPort;

    //Verifica se há uma porta serial ainda aberta caso exista ela é fechada.
    if (hComm != NULL)
    {
        //Fecha a porta serial.
		CloseHandle(hComm);
        hComm = NULL;
    }

    //Configuração do nome da porta serial selecionada.
    asCommPort = "\\\\.\\" + asPort;

    //Configurações do Baud Rate da porta serial selecionada.
    if (asBaudRate == "256000") BaudRate = CBR_256000;
    if (asBaudRate == "128000") BaudRate = CBR_128000;
    if (asBaudRate == "115200") BaudRate = CBR_115200;
    if (asBaudRate == "57600")  BaudRate = CBR_57600;
    if (asBaudRate == "56000")  BaudRate = CBR_56000;
    if (asBaudRate == "38400")  BaudRate = CBR_38400;
    if (asBaudRate == "19200")  BaudRate = CBR_19200;
    if (asBaudRate == "14400")  BaudRate = CBR_14400;
    if (asBaudRate == "9600")   BaudRate = CBR_9600;
    if (asBaudRate == "4800")   BaudRate = CBR_4800;
    if (asBaudRate == "2400")   BaudRate = CBR_2400;
    if (asBaudRate == "1200")   BaudRate = CBR_1200;

    //Abertura da porta serial selecionada.
    hComm = CreateFile( asCommPort.c_str(),     	    // ponteiro para a porta selecionada.
                        GENERIC_READ | GENERIC_WRITE,	// Modo de acesso (escrita ou leitura).
                        0,	                            // Não utilizado.
                        0,	                            // Não utilizado.
                        CREATE_ALWAYS,              	// Como a porta será criada.
                        NULL,                       	// Não utilizado.
                        0);                             // Não utilizado.

    //Faz a verificação se a porta foi aberta corretamente.
	if (hComm != INVALID_HANDLE_VALUE)
    {
        //Configuração dos Timeouts da Porta Serial.
        COMMTIMEOUTS CommTimeouts;

        //Atribuição dos valores definidos para os Timeouts.
        CommTimeouts.ReadIntervalTimeout            = MAXDWORD;
        CommTimeouts.ReadTotalTimeoutMultiplier     = 0;
        CommTimeouts.ReadTotalTimeoutConstant       = 0;
        CommTimeouts.WriteTotalTimeoutMultiplier    = 0;
        CommTimeouts.WriteTotalTimeoutConstant      = 0;

        //Verificação se os parâmetros de configuração foram aceitos.
        if (SetCommTimeouts(hComm, &CommTimeouts) == 0)
        {
            //ShowMessage("ERRO AO ALTERAR DADOS DE CONFIGURAÇÃO DA PORTA SERIAL" + asPort);
            CloseHandle(hComm);
            hComm = NULL;

            return (false);
        }

        //Configurações dos parâmetros de funcionamento da Porta Serial.
        DCB dcb = {0};

        //Verificação se foi possível obter os parâmetros de configuração originais da Porta Serial.
        if (GetCommState(hComm, &dcb) == 0)
        {
            //ShowMessage("ERRO AO OBTER DADOS DE CONFIGURAÇÃO DA PORTA SERIAL" + asPort);
            CloseHandle(hComm);
            hComm = NULL;

            //Sinaliza erro na abertura da porta serial.
            return (false);
        }

        //Estrutura de configuração da porta serial.
        dcb.DCBlength           = sizeof(dcb);  // sizeof(DCB)

        //Atribuição dos parâmetros (DEFAULT) de configuração da Porta Serial.
        dcb.BaudRate            = BaudRate;     // current baud rate
        dcb.fBinary             = true;         // binary mode, no EOF check
        dcb.fParity             = true;         // enable parity checking
        dcb.ByteSize            = 8;            // number of bits/byte, 4-8
        dcb.Parity              = NOPARITY;     // 0 - 4 = no, odd, even, mark, space
        dcb.StopBits            = ONESTOPBIT;   // 0, 1, 2 = 1, 1.5, 2

        //Demais parâmetros opcional.
        dcb.fOutxCtsFlow        = false;        // CTS output flow control
        dcb.fOutxDsrFlow        = false;        // DSR output flow control
        dcb.fDtrControl         = DTR_CONTROL_DISABLE;  // DTR flow control type
        dcb.fDsrSensitivity     = false;        // DSR sensitivity
        dcb.fTXContinueOnXoff   = false;        // XOFF continues Tx            2
        dcb.fOutX               = false;        // XON/XOFF out flow control
        dcb.fInX                = false;        // XON/XOFF in flow control
        dcb.fErrorChar          = false;        // enable error replacement     1
        dcb.fNull               = false;        // enable null stripping
        dcb.fRtsControl         = RTS_CONTROL_DISABLE;  // RTS flow control
        dcb.fAbortOnError       = false;        // abort reads/writes on error
        dcb.fDummy2             = false;        // reserved                     1
        dcb.XonLim              = 0;            // transmit XON threshold       1
        dcb.XoffLim             = 0;            // transmit XOFF threshold      1
        dcb.XonChar;                            // Tx and Rx XON character
        dcb.XoffChar;                           // Tx and Rx XOFF character
        dcb.ErrorChar;                          // error replacement character
        dcb.EofChar;                            // end of input character
        dcb.EvtChar;                            // received event character
        //dcb.wReserved;                          // not currently used           1
        dcb.wReserved1;                         // reserved; do not use

        //Verificação se os parâmetros de configuração foram aceitos.
        if (SetCommState(hComm,&dcb) == 0)
        {
            //ShowMessage("ERRO AO ALTERAR DADOS DE CONFIGURAÇÃO DA PORTA SERIAL" + asPort);
            CloseHandle(hComm);
            hComm = NULL;

            return (false);
        }
    }
    else
    {
        //ShowMessage("ERRO AO ABRIR A PORTA SERIAL" + asPort);
        CloseHandle(hComm);
        hComm = NULL;

        return (false);
    }

    //Descarta caracteres presentes na porta e termina processos pendentes de leitura e transmissão.
    PurgeComm(hComm, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);

    return (true);
}

//---------------------------------------------------------------------------

BOOL SerialPort::WriteABuffer(char *Buffer, DWORD dwToWrite)
{
    OVERLAPPED osWrite = {0};

    if (hComm != NULL)
    {
        // Create this writes OVERLAPPED structure hEvent.
        osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        if (osWrite.hEvent == NULL)
        {
            return (false);     // Error creating overlapped event handle.
        }

        if (!WriteFile(hComm, Buffer, dwToWrite, &dwWritten, &osWrite))
        {
            //ShowMessage("ERRO AO ENVIAR DADOS PARA A PORTA SERIAL");
        }

        CloseHandle(osWrite.hEvent);
    }
    else
    {
        //ShowMessage("ERRO AO ABRIR A PORTA SERIAL");
        CloseHandle(hComm);
        return (FALSE);
    }

    //Finaliza todas as pendências de escrita e leitura da porta serial selecionada.
    PurgeComm(hComm, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);

    return (true);
}

//---------------------------------------------------------------------------

char * SerialPort::ReadABuffer()
{
    OVERLAPPED osRead = {0};

    if (hComm != NULL)
    {
        // Create this writes OVERLAPPED structure hEvent.
        osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        if (osRead.hEvent != NULL)
        {
            strcpy(Buffer,"\x0");
            if (ReadFile(hComm, &Buffer, dwToRead, &dwRead, &osRead))
            {
                //Encerra corretamente a string para não retornar lixo.
                Buffer[dwRead] = '\0';
            }
            else
            {
                //ShowMessage("ERRO AO LER DADOS DA PORTA SERIAL");
            }
        }
        else
        {
            //ShowMessage("ERRO AO ABRIR A PORTA SERIAL");
            CloseHandle(hComm);
            return (FALSE);
        }

        CloseHandle(osRead.hEvent);
    }
    else
    {
        //ShowMessage("ERRO AO ABRIR A PORTA SERIAL");
        CloseHandle(hComm);
        return (FALSE);
    }

    //Finaliza todas as pendências de escrita e leitura da porta serial selecionada.
    PurgeComm(hComm, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);

    //Retorna o buffer recebido.
    return (Buffer);
}

//---------------------------------------------------------------------------

unsigned int SerialPort::getBufferSize()
{
    //Obtém o número de bytes no buffer serial a serem lidos.
    return (dwRead);
}

//---------------------------------------------------------------------------

void SerialPort::CloseSerialPort()
{
    //Fecha a porta serial aberta.
    if (hComm != NULL)
    {
        SetCommMask(hComm, 0L);

        CloseHandle(hComm);
        hComm = NULL;
    }
}

//---------------------------------------------------------------------------

void tela(char *msg, char *portas, char *baudrate)
{
    system("cls");
    printf("\n-----------------------------------------------------------------------------------------");
    printf("\n %s                         ", msg);
    printf("\n-----------------------------------------------------------------------------------------");
    printf("\n PORTA: %s                                                               BAUDRATE: %s          ", portas, baudrate);
    printf("\n-----------------------------------------------------------------------------------------");
}

//---------------------------------------------------------------------------
void tela_pacote(void)
{
    printf("\n DESCRICAO DO PACOTE DE DADOS                                                             ");
    printf("\n-----------------------------------------------------------------------------------------");
    printf("\n-----------------------------------------------------------------------------------------");
}

//---------------------------------------------------------------------------

int main(void)
{
    char buffer[8096];
    char portas[15];
    char baudrate[15];
    char ch;
    unsigned short ADCResult = 0;
    int i = 0;

    // Inicialização da porta serial.
    SerialPort *porta;
    porta = new SerialPort();


    tela("PARAMETROS DE configuração DA PORTA SERIAL","","");



    // Obtém a porta serial a ser conectada.
    printf("\n>> INFORME UMA PORTA PARA CONECTAR (Ex: COM3 / ENTER - VALIDAR PORTA / ESC - CANCELAR)");
    printf("\n>> PORTA: ");

    i = 0;
    ch = '\0';
    while (ch != 13)
    {
        kbhit();
        ch = getch();
        printf("%c",ch);

        portas[i] = ch;
        i++;

        if (ch == 27)
        {
            printf("\n>> INFORME UMA NOVA PORTA!");
            printf("\n>> PORTA: ");

            i = 0;
            ch = '\0';
            strcpy(portas," ");
        }
    }

    i--;
    portas[i] = '\0';
    printf("\n>> PORTA ESCOLHIDA: %s\n\n",portas);


    printf("\n>> INFORME A TAXA DE BAUDRATE (Ex: 9600 / ENTER - VALIDAR BAUDRATE / ESC - CANCELAR)");
    printf("\n>> BAUDRATE: ");

    i = 0;
    ch = '\0';
    while (ch != 13)
    {
        kbhit();
        ch = getch();
        printf("%c",ch);

        baudrate[i] = ch;
        i++;

        if (ch == 27)
        {
            printf("\n>> INFORME UM NOVO BAUDRATE!");
            printf("\n>> BAUDRATE: ");

            i = 0;
            ch = '\0';
            strcpy(baudrate," ");
        }
    }

    i--;
    baudrate[i] = '\0';
    printf("\n>> BAUDRATE ESCOLHIDO: %s\n",baudrate);

    // Atualização da tela.
    system("cls");
    tela("EXEMPLO DE INTEGRACAO SOFTWARE-HARDWARE COM A API DA PORTA SERIAL",portas,baudrate);

    // Conecta o microcontrolador à porta e ao baudrate escolhido..
    porta->OpenSerialPort(portas,baudrate);

    printf("\n>> ABRINDO PORTA SERIAL, AGURADE...");






    printf("\n>> PRESSIONE QUALQUER TECLA PARA CONTINUAR...");
    getch();

    system("cls");
    tela("EXEMPLO DE INTEGRACAO SOFTWARE-HARDWARE COM A API DA PORTA SERIAL",portas,baudrate);
    tela_pacote();

    i = 0;
    ch = '\0';
    strcpy(buffer," ");
    printf("\n PACOTE >> ");

    while (ch != 27)
    {
        if (kbhit())
        {
            ch = getch();
            printf("%c",ch);

            buffer[i] = ch;
            i++;

            if (ch == 13)
            {
                i--;
                buffer[i] = '\0';
                printf("\n>> PACOTE ENVIADO: %s", buffer);



                // Solicita resposta de conexão ao microcontrolador.
                porta->WriteABuffer(buffer,6);
                Sleep(500);


                    while (ch != 0)
                    {


                // Faz a leitura do buffer de recepção do computador com a resposta do microcontrolador.
                strcpy(buffer, porta->ReadABuffer());

                    }
                printf("\n>> PRESSIONE QUALQUER TECLA PARA CONTINUAR...");
                getch();

                // Inicializa ambiente.
                system("cls");
                tela("EXEMPLO DE INTEGRACAO SOFTWARE-HARDWARE COM A API DA PORTA SERIAL",portas,baudrate);
                tela_pacote();
                i = 0;
                ch = '\0';
                strcpy(buffer," ");
                printf("\n PACOTE >> ");
            }

            if (ch == 27)
            {
                printf("\n>> TECLA ESC PRESSIONADA!!!\n");
                printf("\n>> FINALIZANDO O SISTEMA E DESCONECTANDO O MICROCONTROLADOR...\n");
                exit(0);
            }
        }
    }


   //------------------------------------------------------









    printf("\n>> FINALIZANDO O SISTEMA E DESCONECTANDO O MICROCONTROLADOR...\n\n\n");

    // Fecha a porta serial.
    porta->CloseSerialPort();
    porta = NULL;
    delete porta;

    return 0;
}

 

  • Curtir 1
Feucon
 

Feucon

Postado
  • Autor
Postado

Olá argento sim usei o programa x ctu ele os dois se comunicam porém preciso fazer os dois se comunicar com esse código , um enviando pacote e outro recebendo 

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!