х86+Ассемблер+ЭБУ

 Приведу пример выполнения настройки порта и выполнения чтения/записи данных. 
 
 #include <windows.h>
 #include <string.h>
 
 . . .
 
 DCB dcb;
 COMMTIMEOUTS ct;
 HANDLE port;
 DWORD bc;
 
 char *buf_out="Test string";
 char *buf_in;
 
 . . .
 
 dcb.DCBlength=sizeof(DCB);
 BuildCommDCB("baud=9600 parity=N data=8 stop=1",&dcb);
 dcb.fNull=TRUE;
 
 ct.ReadIntervalTimeout=10;
 ct.ReadTotalTimeoutMultiplier=ct.ReadTotalTimeoutConstant=0;
 ct.WriteTotalTimeoutMultiplier=ct.WriteTotalTimeoutConstant=0;
 
 port=CreateFile("COM2",GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
 
 SetCommState(port,dcb);
 SetCommTimeouts(port,&ct);
 PurgeComm(port,PURGE_TXCLEAR|PURGE_RXCLEAR);
 SetupComm(port,256,256);
 
 . . .
 
 buf_in=(char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,strlen(buf_out)+1);
 WriteFile(port,buf_out,strlen(buf_out),&bc,NULL);
 ReadFile(port,buf_in,strlen(buf_out),&bc,NULL);
 
 HeapFree(GetProcessHeap(),0,buf_in);
 CloseHandle(port);
 
 . . .
 
 Если на COM2 установить перемычку между сигналами TxD и RxD, то переменная buf_in, после выполнения ReadFile, будет содержать ту же информацию, что и buf_out. Других пояснений пример не требует, все уже было подробно рассмотрено раньше.

//  История изменений
//      04.07.2000 Изменены характеристики WakeUp импульса была пауза после FO = Sleep(150) стала Sleep(25)
//          (не проверено)
//
//  Версия для МИКАС ЭБУ 5.4.
 
#include "stdafx.h"
 
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h> 
//#include <streams.h> 
#include <edevdefs.h>  
 
 
#include "Tester.h"
#include "uart.h"
 
#define RefreshReceive() RMess_Len=RMess_Ptr=0 // Ждем следующего сообщения.  
 
uart::uart()
{
    BadCRC=0;
    NotToTester=0;
    NotFromMIKAS=0;
    FramesReceived=0;
    BytesReceived=0;
    strncpy(PortCom1,"COM1",5); 
    strncpy(PortCom2,"COM2",5); 
    strncpy(PortCom3,"COM3",5); 
    strncpy(PortCom4,"COM4",5); 
    Was40=FALSE;
 
    pcComPort = NULL;
    hComPort = 0; 
    memset((void *)&m_dcb,0,sizeof(m_dcb));
    memset((void *)&sTimeouts,0,sizeof(sTimeouts));
    UARTErrors=0;
    RxTimeout=20L;
    UartInited=FALSE;
    FrameNotReceived=FALSE;
    Timeout=100; 
}
 
uart::~uart(){}
 
 
void uart::ErrMessageBox(char *TitleString)
{
    UARTErrors++;
/*
LPVOID lpMsgBuf;
    if (UARTErrors>2) return;
            FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,NULL );
                MessageBox( NULL, (LPCTSTR)lpMsgBuf, TitleString , MB_OK | MB_ICONSTOP );
                LocalFree( lpMsgBuf );  
*/
}
/*****************************************************/
void uart::CloseUart()
{
    if (!UartInited) return;
    UartInited=FALSE;
    if (DeleteFile(pcComPort))  { ErrMessageBox("Ошибка закрытья COM порта.");  return; } 
    pcComPort = NULL;
//  UARTErrors=0;
    if ( !CloseHandle( hComPort ) ) { ErrMessageBox("Ошибка закрытья COM порта.");  return; } 
    hComPort = 0; 
 return;  
}
 
/*****************************************************/
void  uart::FlushUart( void ) 
{ DWORD dwRetByteCnt; 
    DWORD dwCommError; 
    COMSTAT CommStat;
    char buf[256];  
 
//  UARTErrors=0;
    if (PurgeComm(hComPort, PURGE_RXCLEAR)) { ErrMessageBox("Ошибка PurgeСОМ in FlushUart()."); return; } 
    ClearCommError( hComPort, &dwCommError, &CommStat ); 
    if (CommStat.cbInQue) 
        { if(!ReadFile(hComPort, buf,(DWORD)CommStat.cbInQue,(LPDWORD)&dwRetByteCnt,(LPOVERLAPPED)NULL)) {ErrMessageBox("Ошибка ReadСОМ in FlushUart()."); return; } 
    }
}  
 
/************************************************************************/
/*              Процедура      */
/* unchar   InitUart(int *Port)                                 */
/* Принимает:      Номер порта который надо открыть                    */
/*                      (COM1=2=DEV_PORT_COM1, COM2=3=DEV_PORT_COM2,...)*/
/* Возвращает:        0   - если открыл                                 */
/*                  1   - если указано не правильное имя порта           */
/*                  2   - ошибка открытия порта                          */
/*                  3   - невозможно получить DCB                     */
/*                  4   - ошибка установки параметров                  */
/*                  255 -           */
/*************************************************************************/
unchar  uart::InitUart(int Port) 
{
    COM_Port=Port;
    if (UartInited) return 0;
    
    switch (Port)
    { 
    case DEV_PORT_COM1: pcComPort = PortCom1; break; 
    case DEV_PORT_COM2: pcComPort = PortCom2; break; 
    case DEV_PORT_COM3: pcComPort = PortCom3; break; 
    case DEV_PORT_COM4: pcComPort = PortCom4; break; 
    default:  return 1; 
    } 
// пробуем открыть Порт 
    if ( (hComPort = CreateFile( pcComPort,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL )) == (HANDLE)-1 )  
            {/* Не получилось*/ ErrMessageBox("Ошибка открытия СОМ."); return 2; }  
//  UARTErrors=0;
// Пробуем получить DCB
    if ( !GetCommState( hComPort, &m_dcb ) ) { CloseUart(); ErrMessageBox("Ошибка получения DCB."); return 3; }  
 
    m_dcb.BaudRate = 9600;  m_dcb.fBinary = TRUE;  
    m_dcb.fOutxCtsFlow=FALSE;      // CTS output flow control 
    m_dcb.fOutxDsrFlow=FALSE;      // DSR output flow control 
    m_dcb.fDtrControl = DTR_CONTROL_ENABLE; 
    m_dcb.fDsrSensitivity = FALSE;     //   m_dcb.fTXContinueOnXoff=TRUE; // XOFF continues Tx 
    m_dcb.fOutX = FALSE;    m_dcb.fInX = FALSE;     
    m_dcb.fNull = FALSE;    
    m_dcb.fRtsControl = RTS_CONTROL_ENABLE;
    m_dcb.fAbortOnError = FALSE;  m_dcb.ByteSize = 8;     
    m_dcb.fParity=FALSE; 
    m_dcb.Parity = NOPARITY;     // 0-4=no,odd,even,mark,space
    m_dcb.StopBits = ONESTOPBIT;  // 0,1,2 = 1, 1.5, 2 
/*
    DWORD fErrorChar: 1;       // enable error replacement 
*/
    if(!SetCommState(hComPort, &m_dcb))     {   ErrMessageBox("Ошибка установки параметров СОМ (9600bps).");    }
    if (!GetCommTimeouts(hComPort, &sTimeouts)){ErrMessageBox("Ошибка Получения таймаутов СОМ.");CloseUart();return 5; } 
    sTimeouts.ReadIntervalTimeout = RxTimeout; 
    sTimeouts.ReadTotalTimeoutMultiplier = 1L; 
    sTimeouts.ReadTotalTimeoutConstant = RxTimeout; 
    sTimeouts.WriteTotalTimeoutMultiplier = 0L; 
    sTimeouts.WriteTotalTimeoutConstant = 0L; 
    if (!SetCommTimeouts(hComPort, &sTimeouts)){ErrMessageBox("Ошибка установки таймаутов СОМ.");CloseUart();return 6; } 
    UartInited=TRUE;
    return 0;
}
 
/************************************************************************************/
// Программа выдает Wake-Up импульс: 25 мсек. затем пауза 50 мсек.  
 
unchar  uart::WakeUpImpuls(int Port) 
{
BOOL    WasInited=FALSE;
LPDWORD Actual;
unsigned char   WakeupByte;
    
    if (UartInited) {WasInited=TRUE; CloseUart();}
 
    switch (Port)
    { 
    case DEV_PORT_COM1: pcComPort = PortCom1; break; 
    case DEV_PORT_COM2: pcComPort = PortCom2; break; 
    case DEV_PORT_COM3: pcComPort = PortCom3; break; 
    case DEV_PORT_COM4: pcComPort = PortCom4; break; 
    default:  return 1; 
    } 
// пробуем открыть Порт 
    if ( (hComPort = CreateFile( pcComPort,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL )) == (HANDLE)-1 )  
            {/* Не получилось*/ ErrMessageBox("Ошибка открытия СОМ Wakeup.");  
            if (WasInited) InitUart(COM_Port);
            return 2; }  
// Пробуем получить DCB
    if ( !GetCommState( hComPort, &m_dcb ) )    { ErrMessageBox("Ошибка получения DCB Wakeup."); }  
 
    m_dcb.BaudRate = 200;   m_dcb.fBinary = TRUE;  m_dcb.fOutxCtsFlow=FALSE;      // CTS output flow control 
    m_dcb.fOutxDsrFlow=FALSE;      // DSR output flow control 
    m_dcb.fDtrControl = DTR_CONTROL_DISABLE; m_dcb.fDsrSensitivity = FALSE;     //  m_dcb.fTXContinueOnXoff=TRUE; // XOFF continues Tx 
    m_dcb.fOutX = FALSE;    m_dcb.fInX = FALSE;     
    m_dcb.fNull = FALSE;    
    m_dcb.fRtsControl = RTS_CONTROL_DISABLE;
    m_dcb.fAbortOnError = FALSE;  m_dcb.ByteSize = 8;     
    m_dcb.fParity=FALSE; m_dcb.Parity = NOPARITY;     // 0-4=no,odd,even,mark,space
    m_dcb.StopBits = ONESTOPBIT;  // 0,1,2 = 1, 1.5, 2 
    if(!SetCommState(hComPort, &m_dcb)) ErrMessageBox("Ошибка установки параметров СОМ (200bps)  Wakeup."); 
 
// Выдаем Wake-Up импульс: 25 мсек. затем пауза 50 мсек. 
    WakeupByte=0xF0;
    if ( !WriteFile(hComPort, &WakeupByte,1,(LPDWORD)&Actual,(LPOVERLAPPED)NULL ) ) ErrMessageBox("Ошибка Write in COM in WriteBytes() in Wakeup."); 
    Sleep(25);
    
    if (DeleteFile(pcComPort))  ErrMessageBox("Ошибка закрытья COM порта Wakeup.");   
    pcComPort = NULL;
    if ( !CloseHandle( hComPort ) ) ErrMessageBox("Ошибка закрытья COM порта Wakeup.");  
    hComPort = 0; 
 
    if (WasInited) {InitUart(COM_Port); }
 
    return 0;
}
 
unchar CRC;
 
/************************************************************************/
/*              Процедура приема байта из последовательного порта.      */
/*                                                                      */
/* unchar   ParseByte(unchar RByte)                                 */
/* Принимает:      Считанный байт.                                        */
/* Возвращает:        0   - Сообщение еще не принято                     */
/*                  1   - сообщение не к тестеру Dst!=0xF1               */
/*                  2   - сообщение не от МИКАС DST!=0x10             */
/*                  3   - Плохая контрольная сумма                        */
/*                  255 -           */
/*************************************************************************/
unchar  uart::ParseByteGAZ(unchar RByte)
{
    BytesReceived++;
    CRC+=RByte;
// Сохраним принятый байт в буфер.
    if (Was40==TRUE) {  rMessage[RMess_Ptr-1]+=RByte; Was40=FALSE;  return 0; }
    else    {rMessage[RMess_Ptr++]=RByte; RMess_Len++;}
    if (RByte == 0x40)  { Was40=TRUE; return 0; }
//  if (RMess_Ptr < 3) return 0; // Заголовок еще не принят возвращаемся.
    if (RByte == 0x0D)  
    {   // Все сообщение принято.
        FramesReceived++;
        if ((signed char)CRC!=0x0D) { BadCRC++; RefreshReceive(); return 3; }
        // Контрольная суммы Ок. Копируем полезную информацию в буфер
        return (char)0xFF;
    }
    return 0;
}
 
/************************************************************************/
/*              Процедура приема байта из последовательного порта.      */
/*                                                                      */
/* char ReceiveByte(unchar RByte)                                       */
/* Принимает:      Байт считанный из UART                               */
/* Возвращает:        0   - если прим кадра не завешен                  */
/*                  1   - если принято сообщение не для тестера         */
/*                  2   - если принято сообщение не от МИКАС           */
/*                  3   - если принято сообщение с ошибкой CRC          */
/*                  255 - если принято сообщение нормальное сообщение    */
/*************************************************************************/
 
unchar uart::ReadByte()
{   
    unchar buf[2];
    DWORD   Actual;
    TimeIsOut=FALSE;
    if ( !ReadFile(hComPort, buf,(DWORD)1,(LPDWORD)&Actual,(LPOVERLAPPED)NULL ) ) 
    { ErrMessageBox("Ошибка Read from COM in ReadByte()."); TimeIsOut=TRUE; return 0xFF;}
    if (Actual==0) TimeIsOut=TRUE;
return buf[0];
}
 
 
void uart::SetRxTimeOut(unsigned short Time) {  Timeout=Time;   FrameNotReceived=FALSE; }
 
 /***********************************************************************/
 /*                                                                     */
 /*                 Процедура запуска приемника UART.                  */
 /*                                                                     */
 /* void ReceiveBytes(void)                                             */
 /* Принимает:     ничего не принимает.                               */
 /* Возвращает:       .                                                   */
 /*                                                                     */
 /***********************************************************************/
       
void uart::ReceiveBytes(void)   
{
    unchar  Byte, State;
    unsigned long Time;
    CRC=0;
    memset(rMessage,0,BUFF_LEN-1);
    Time=0; RefreshReceive();   State=0; FrameNotReceived=FALSE;
    while ( State != 0xFF  ) 
    {   Byte=ReadByte();
    if ( !TimeIsOut ) { State=ParseByteGAZ(Byte); Time=0;}
        else { Time+=RxTimeout; //sprintf((char *)&t[0],"%ic.",Time); m_wndStatusBar.SetPaneText( 1, (LPCTSTR) &t, TRUE );
            if (Time>=Timeout)  {FrameNotReceived=TRUE; break;}
        }
    }
}
 
 
void uart::WriteBytes(unchar *Message_P,unchar Len) 
{
    unchar  buf[BUFF_LEN+2];
    DWORD   Actual;
//  memset(&buf,0,BUFF_LEN-1)
    sMess_Len=Len;
    if ( !WriteFile(hComPort, Message_P,Len,(LPDWORD)&Actual,(LPOVERLAPPED)NULL ) ) 
    { 
        if (Actual!=Len) ErrMessageBox("Ошибка Cant Write all bytes to COM in WriteBytes()."); 
        else    ErrMessageBox("Ошибка Write in COM in WriteBytes()."); 
        return; 
    } 
    // Читаем назад
    Sleep(3);
    if ( !ReadFile(hComPort, buf,Len,(LPDWORD)&Actual,(LPOVERLAPPED)NULL ) ) 
    {
        ErrMessageBox("Ошибка Read echo from COM in WriteBytes()."); return; 
    } 
    if (Actual!=Len) 
        ErrMessageBox("Ошибка Cant read all bytes from COM in WriteBytes()."); 
    else {if (memcmp(Message_P,buf,Len))        
            {   ErrMessageBox("Ошибка считали не то что писали COM in WriteBytes()."); return; } 
 
    }
}
 
 
/************************************************************************/
/*              Процедура посылки кадра в последовательный порт.      */
/*                                                                      */
/* char SendBytes(unchar Len)                                   */
/* Принимает:      Байт длинны посылки                                    */
/*                  Данные сообщения должны быть помещены              */
/*                     в буфер Message с нулевого смещения.              */
/* Возвращает:        0   -                   */
/*                  1 -     ошибка длинны                               */
/*                  255 - если сообщение полностью послано             */
/*************************************************************************/
unchar  uart::SendBytesGAZ(unchar Len)
{
    unchar i, CRC, n;
 
    n=Len;
    memset(&sMessage[n],0,BUFF_LEN-1-n);
    if ( (n==0) || (n>(BUFF_LEN-5)) ) {return 1;}
 
    for ( i=0; i!=n; i++ ) 
    { 
        if (sMessage[i]==0x0D) {n++; memmove(&sMessage[i+1], &sMessage[i], (n-i)); sMessage[i++]=0x40; sMessage[i]=0xCD; } 
        if (sMessage[i]==0x40) {n++; memmove(&sMessage[i+1], &sMessage[i], (n-i)); sMessage[i++]=0x40; sMessage[i]=0x00; } 
    }
 
    sMessage[n+1]=0x0D;
    // Вычисляем CRC и кладем ее в конец сообщения
    for ( i=CRC=0; i!=n; i++ ) CRC+=sMessage[i];
    sMessage[n]=-(signed char)CRC;
    //n++;
    WriteBytes(&(sMessage[0]),n+2);
    return 0;
}