【ESP32】通过串口控制直流电机

ESP32通过硬串口通信程序案例如下：

HardwareSerial Myserial(1)   //  D5 - 接TXD， D18 - 接RXD

char Speed_Off[8] =  {0x80,0x06,0x00,0x40,0x00,0x00,0x96,0x0F}  // 电机驱动板的 停止命令

char Speed_Align[8]= {0x80,0x06,0x00,0x40,0x03,0xe7,0xd6,0xb5}// 电机驱动板的正转命令

char Speed_Open[8] = {0x80,0x06,0x00,0x40,0xfc,0x19,0x16,0xc5}// 电机驱动板的反转命令

void Align(){

 for(int i =0i<8i++){

      Myserial.write(Speed_Align[i])         // 通过ESP32串口发送电机正转数据

  }

}

void Open(){

  for(int i =0i<8i++){

    Myserial.write(Speed_Open[i])     // 通过ESP32串口发送电机反转命令

  }

}

void MotorOff(){

  for(int i =0i<8i++){

    Myserial.write(Speed_Off[i])  // // 通过ESP32串口发送电机停止命令

  } 

}

void Delay_one(){

for(int i =0i <6i++){

  delay(1000)

  } 

}

void Delay_Two(){

for(int i =0i <12i++){

  delay(1000)

  } 

}

void setup() {

  // put your setup code here, to run once:

  Myserial.begin(9600,SERIAL_8E1,5,18)    // 配置串口参数

}

void loop() {

  //Myserial.println("Hello world!")

  delay(2000)

  Align()

  delay(2000)

  MotorOff()

  Delay_one()

  Open()

  delay(2000)

  MotorOff()

  Delay_Two()

}

采用RS232对接现场电脑的控制模式

有些电脑我们知道他有配置串口卡，带有RS232的，或者是没有RS232的电脑，我们也可以利用USB转串口来实现控制，这个控制方法怎么实现呢?采用中控的串口接电脑的串口，不过电脑要设置一个串口指令程序，要制作一个小软件才能够实现，当中控的串口发一条指令，电脑串口接收到指令的时候，电脑执行某些 *** 作。

采用红外控制方式来实现电脑的控制

电脑一般都没有红外遥控功能，而我们的中控系统有红外控制功能，怎么实现呢?利用USB转红外控制的模块，这种模块一般都比较便宜，可以实现中控系统来控制电脑的开关机，还可以调用电脑系统的特定播放器如千千静听，暴风影音的各种 *** 作，播放暂停上一首，下一首等等。

利用电源控制的闭合开关来实现控制

利用继电器的闭合以及端口的特点来实现电脑的开机和关机，不过这样子对电脑有一定的损伤，但是市场上大部分公司都是利用这种方案，直接断掉电脑的供电。

可以控制关机，不能控制开机

基本方法是使用CreateFile来建立一个串口文件，然后用overlap的方式进行读写

#define SERAIL_PORT_BUF_MAX (1024*8)

typedef HRESULT (*PFN_CMD_PARSE_DATA)(HANDLE hParseApp, LPCSTR szRspCmd, int nCmdLen)

class CUsbSrvApp// : public CWinApp

{

public:

CUsbSrvApp()

~CUsbSrvApp()

BOOL OnSendData(const char *szBuf, int nLen)// 发送数据

int ComConnect(CString strPort)// 连接COM口

HANDLE OpenComPort(CString strPort, int nBaudRate, int nDataBits, int nStopBits, int nParity, int nFlowCtrlType)// 打开串口

void Close()// 关闭串口

HANDLE m_hCom

BOOL m_bConnected

OVERLAPPED m_OverlappedRead

OVERLAPPED m_OverlappedWrite

CWinThread *m_pThread

PFN_CMD_PARSE_DATA m_pRspCmdFunc// 用来处理接受数据的CALLBACK

HANDLE m_hParseApp

}

CUsbSrvApp::CUsbSrvApp()

{

// TODO: add construction code here,

// Place all significant initialization in InitInstance

m_bConnected = false

m_hCom = NULL

m_pRspCmdFunc = NULL

}

CUsbSrvApp::~CUsbSrvApp()

{

}

//打开串口通信，并返回串口句柄

HANDLE CUsbSrvApp::OpenComPort(CString strPortName,

int nBaudRate,

int nDataBits,

int nStopBits,

int nParity,

int nFlowCtrlType)

{

DCB dcb

COMMTIMEOUTS CommTimeOuts

COMMCONFIG ComConfig

HANDLE hComPort

CString strPort

strPort.Format("\\\\.\\%s",strPortName)// COM口的文件名应该是 \\.\COMXX

//打开窗口其实就是创建一个文件

hComPort = CreateFile(strPort,

GENERIC_READ | GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE,

NULL,

OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,

NULL)

if (INVALID_HANDLE_VALUE == hComPort)

return INVALID_HANDLE_VALUE

// 设置一些COM口通讯参数和OVERLAP

CommTimeOuts.ReadIntervalTimeout = -1

CommTimeOuts.ReadTotalTimeoutConstant = 0

CommTimeOuts.ReadTotalTimeoutMultiplier = 0

CommTimeOuts.WriteTotalTimeoutConstant = 0

CommTimeOuts.WriteTotalTimeoutMultiplier = 0x1388

SetCommTimeouts( m_hCom, &CommTimeOuts )

SetDefaultCommConfig(strPortName, &ComConfig, sizeof(COMMCONFIG))

GetCommState(m_hCom, &dcb )

dcb.BaudRate = nBaudRate

dcb.ByteSize = nDataBits

dcb.StopBits = nStopBits

dcb.fParity = (NOPARITY != nParity)

dcb.Parity = nParity

//set the receive char

dcb.EvtChar = 0x0D

switch(nFlowCtrlType)

{

case 0: //no flow control

break

case 1://HARD_FLOW_CTRL:

dcb.fOutxCtsFlow = TRUE

dcb.fOutxDsrFlow = TRUE

dcb.fDtrControl = DTR_CONTROL_DISABLE

dcb.fDsrSensitivity = TRUE

dcb.fRtsControl = RTS_CONTROL_TOGGLE

break

case 2://SOFT_FLOW_CTRL:

dcb.fOutX = TRUE

dcb.fInX = TRUE

break

}

BuildCommDCB(_T("baud=115200 parity=N data=8 stop=1"),&dcb)

SetCommState(hComPort, &dcb )

SetCommMask(hComPort, 0)

SetCommMask(hComPort, EV_RXCHAR|EV_CTS|EV_DSR|EV_RLSD|EV_RING)

SetupComm( hComPort, SERAIL_PORT_BUF_MAX,SERAIL_PORT_BUF_MAX)

//clear read and write buffer

PurgeComm( hComPort, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR )

return hComPort

}

void CUsbSrvApp::Close()

{

if(m_bConnected)

{

m_bConnected = false

CloseHandle(m_hCom)

m_hCom = NULL

}

}

// 这个线程是监视串口数据，一旦有数据则读取并调用CALLBACK通知客户端

UINT ReceiveComData(LPVOID pParam)

{

CUsbSrvApp *pUsbSrv = (CUsbSrvApp *)pParam

HANDLE hComPort = pUsbSrv->m_hCom

DWORD dwEvtMask=0

DWORD dwErrorFlags

SetCommMask( hComPort, EV_RXCHAR)

OVERLAPPED osRead

osRead.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL)

DWORD dwTransfer = 0

while(pUsbSrv->m_bConnected)

{

if( !WaitCommEvent( hComPort, &dwEvtMask,&osRead))

{

if( GetLastError()== ERROR_IO_PENDING)

{

WaitForSingleObject(osRead.hEvent, INFINITE)

if(dwEvtMask&EV_RXCHAR==EV_RXCHAR)

{

COMSTAT ComStat={0}

DWORD dwReadLen = 0

DWORD dwBytesRead = 0

DWORD dwTotalLen = 0

ClearCommError(hComPort, &dwErrorFlags, &ComStat )

dwTotalLen = ComStat.cbInQue

dwReadLen = (SERAIL_PORT_BUF_MAX >dwTotalLen)?dwTotalLen:SERAIL_PORT_BUF_MAX

BYTE *pBuf = new BYTE[dwTotalLen+1]

memset(pBuf, 0 , dwTotalLen+1)

DWORD nReadBufLen=0

while(dwTotalLen>0)

{

if(FALSE == ReadFile( hComPort, pBuf+nReadBufLen,dwReadLen, &dwBytesRead,&pUsbSrv->m_OverlappedRead))

{

if(GetLastError() == ERROR_IO_PENDING)

{

GetOverlappedResult(hComPort,&osRead, &dwTransfer, TRUE )

}

break

}

nReadBufLen +=dwBytesRead

dwTotalLen -=dwBytesRead

dwReadLen -= dwBytesRead

dwReadLen = (SERAIL_PORT_BUF_MAX>dwReadLen)?dwReadLen:SERAIL_PORT_BUF_MAX

}

if(pUsbSrv->m_pRspCmdFunc!=NULL&&nReadBufLen!=0)

{

pUsbSrv->m_pRspCmdFunc(pUsbSrv->m_hParseApp, (char*)pBuf,nReadBufLen)

}

delete pBuf

ClearCommError(hComPort, &dwErrorFlags, &ComStat )

int len =0//= m_retList.GetSize()

}//endif if(dwEvtMask&EV_RXCHAR==EV_RXCHAR)

}//endif if( GetLastError()== ERROR_IO_PENDING)

}//endif if( !WaitCommEvent( hComPort, &dwEvtMask,&o))

else

{

if(GetLastError() == ERROR_IO_PENDING) {

GetOverlappedResult(hComPort, &osRead, &dwTransfer, TRUE )// sleep thread

}

}

Sleep(1)

} //endwhile while(m_bConnected)

return 0

}

int CUsbSrvApp::ComConnect(CString strPort)

{

int nBaudRate = 115200

int nDataBits = 8

int nStopBits = 1

int nParity = 0

int nFlowCtrl = 1

if (NULL != m_hCom || m_bConnected)

{

return 0

}

m_hCom = OpenComPort(strPort,nBaudRate,nDataBits,nStopBits,nParity,nFlowCtrl)

if( INVALID_HANDLE_VALUE == m_hCom)

{

m_hCom = NULL

return 0

}

memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) )

memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) )

m_OverlappedRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL )

m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL )

m_pThread = AfxBeginThread( ReceiveComData,(void*)this,THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED ,NULL )

if( NULL == m_pThread )

{

CloseHandle( m_hCom )

m_hCom = NULL

return FALSE

}

else

{

m_bConnected = TRUE

m_pThread->ResumeThread( )

}

return TRUE

}

int CUsbSrvApp::OnSendData(const char *szBuf, int nLen)

{

BOOL bWriteStat

BOOL bWrite = TRUE

DWORD dwBytesWrite = 0

DWORD dwBytesWritten = 0

int dwByteswrittenTotal = 0

if (NULL == m_hCom)

return 0

int nSentTimes=0

while(dwByteswrittenTotal<nLen&&nSentTimes<10)

{

nSentTimes++

dwBytesWrite = nLen-dwByteswrittenTotal

bWriteStat = WriteFile( m_hCom, szBuf+dwByteswrittenTotal, dwBytesWrite, &dwBytesWritten, &m_OverlappedWrite )

if( !bWriteStat)

{

if ( GetLastError() == ERROR_IO_PENDING )

{

dwBytesWritten = 0

bWrite = FALSE

}

}

if (!bWrite)

{

bWrite = TRUE

bWriteStat = GetOverlappedResult(m_hCom, // Handle to COMM port

&m_OverlappedWrite, // Overlapped structure

&dwBytesWritten, // Stores number of bytes sent

TRUE)// Wait flag

//deal with the error code

}

dwByteswrittenTotal += dwBytesWritten

}

if(dwByteswrittenTotal<nLen)

return 0

else

return 1

}

---