15,471
社区成员
发帖
与我相关
我的任务
分享serialport 类 上位机软件 接收下位机多条指令 显示不全 ，还慢
void m_page10::OnTimer(UINT_PTR nIDEvent) // 定时发送函数
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
switch (nIDEvent)
{
case 0:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); //串口1发送数据
break;
case 1:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); ////串口2发送数据
break;
case 2:
if (m_bSerialPortOpened[2])
{
m_SerialPort[2].WriteToPort(RS_ADC_SF6_Read, 7); //SF6 ADC 值
Sleep(20);
m_SerialPort[2].WriteToPort(RS_XS_Read, 7); ////协议 ////串口3发送数据
Sleep(20);
m_SerialPort[2].WriteToPort(RS_CX_Read, 7); //程序版本
Sleep(20);
m_SerialPort[2].WriteToPort(RS_XU_Read, 7); //序号
Sleep(20);
m_SerialPort[2].WriteToPort(RS_ADC_O2_Read, 7); // O2 ADC 值
//Sleep(20);
//m_SerialPort[2].WriteToPort(RS_T_CL_Read, 7); // 温度 值
//Sleep(20);
//m_SerialPort[2].WriteToPort(RS_H_CL_Read, 7); // 湿度 值
}
break;
case 3:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_XS_Read, 7); ////串口4发送数据
break;
case 4:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); ////串口5发送数据
break;
case 5:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); ////串口6发送数据
break;
case 6:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); ////串口7发送数据
break;
case 7:
if (m_bSerialPortOpened[nIDEvent])
m_SerialPort[nIDEvent].WriteToPort(RS_T_CL_Read, 7); ////串口8发送数据
break;
default:
break;
}
CDialog::OnTimer(nIDEvent);
}
LONG m_page10::OnCom(WPARAM ch, LPARAM port) //处理读取的指令包数据
{
CString str1,str2,str3,str4;
int count = ch;
Str2Hex(m_strRevData[port - 1], pSendBuf); //将16进制字符串 转换为字符数组
str1.Format("%02x", GetCheck((BYTE*)pSendBuf, count - 2));//计算校验
str2.Format("%02x", pSendBuf[count - 1]);
str3.Format("%02x", pSendBuf[count - 2]);
str2 += str3; //获取校验值
if (str1 == str2) //对比校验值是否正确
{
switch ((int)pSendBuf[1])
{
case 00:
if ((int)pSendBuf[2] == 01)
{
str2.Format("%02x", pSendBuf[7]);
str3.Format("%02x", pSendBuf[6]);
str2 += str3;
}
if ((int)pSendBuf[2] == 02)
{
}
if ((int)pSendBuf[2] == 03)
{
}
if ((int)pSendBuf[2] == 04)
{
}
if ((int)pSendBuf[2] == 05)
{
}
if ((int)pSendBuf[2] == 06)
{
}
if ((int)pSendBuf[2] == 07)
{
}
if ((int)pSendBuf[2] == 0x0A) //协议版本
{
CString price;
price.Format("%.1f", ( float)pSendBuf[5]/ 10);
SetDlgItemText(IDC_EDIT14, price);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
}
break;
case 01:
if ((int)pSendBuf[2] == 0x0A) //O2 ADC值
{
str2.Format("%02x", pSendBuf[6]);
str3.Format("%02x", pSendBuf[5]);
str2 += str3;
SetDlgItemText(IDC_EDIT5, str2);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
}
break;
case 02:
break;
case 03:
break;
case 86:
break;
case 87:
break;
case 88:
break;
case 89:
break;
case 0x8A:
break;
case 0x8B:
break;
case 0x8f:
break;
case 90:
break;
case 91:
break;
default:
break;
}
}
m_strRevData[port-1].Empty();//清空数组值
return 0;
}
LONG m_page10::OnComm(WPARAM ch, LPARAM port)
{
CString strTemp[8];
switch (port)
{
case 1: //串口 1 接收到数据
strTemp[0].Format("%02x ", ch);
m_strRevData[0] += strTemp[0];
SetDlgItemText(IDC_EDIT4, m_strRevData[0]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 2: //串口 2 接收到数据
strTemp[1].Format("%02x ",ch);
m_strRevData[1] += strTemp[1];
SetDlgItemText(IDC_EDIT4, m_strRevData[1]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 3: //串口 3 接收到数据
strTemp[2].Format("%02x ", ch);
m_strRevData[2] += strTemp[2];
//SetDlgItemText(IDC_EDIT13, m_strRevData[2]);
//UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 4: //串口 4 接收到数据
strTemp[3].Format("%02x ", ch);
m_strRevData[3] += strTemp[3]; //读取串口 4 的数据
SetDlgItemText(IDC_EDIT37, m_strRevData[3]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 5: //串口 5 接收到数据
strTemp[4].Format("%02x ", ch);
m_strRevData[4] += strTemp[4];//读取串口 5 的数据
SetDlgItemText(IDC_EDIT40, m_strRevData[4]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 6: //串口 6 接收到数据
strTemp[5].Format("%02x ", ch);
m_strRevData[5] += strTemp[5]; //读取串口 6 的数据
SetDlgItemText(IDC_EDIT45, m_strRevData[5]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 7: //串口 7 接收到数据
strTemp[6].Format("%02x ", ch);
m_strRevData[6] += strTemp[6]; //读取串口 7 的数据
SetDlgItemText(IDC_EDIT49, m_strRevData[6]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
case 8: //串口 8 接收到数据
strTemp[7].Format("%02x ", ch);
m_strRevData[7] += strTemp[7]; //读取串口 8 的数据
SetDlgItemText(IDC_EDIT54, m_strRevData[7]);
UpdateData(FALSE);//将接收到的字符显示到接受编辑框
break;
default:
break;
}
return 0;
}
接受事件函数
void CSerialPort::ReceiveChar(CSerialPort* port)
{
BOOL bRead = TRUE;
BOOL bResult = TRUE;
DWORD dwError = 0;
DWORD BytesRead = 0;
DWORD len = 0; // 记录数据包长度
COMSTAT comstat;
unsigned char RXBuff;
for (;;)
{
//add by liquanhai 2011-11-06 防止死锁
if(WaitForSingleObject(port->m_hShutdownEvent,0)==WAIT_OBJECT_0)
return;
// Gain ownership of the comm port critical section.
// This process guarantees no other part of this program
// is using the port object.
EnterCriticalSection(&port->m_csCommunicationSync);
// ClearCommError() will update the COMSTAT structure and
// clear any other errors.
///更新COMSTAT
bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
LeaveCriticalSection(&port->m_csCommunicationSync);
HWND hWnd = ::FindWindow(NULL, "红外SF6+氧气+温湿度四合一软件");
HWND hWnd1 = ::FindWindow(NULL, "参数修改");
// start forever loop. I use this type of loop because I
// do not know at runtime how many loops this will have to
// run. My solution is to start a forever loop and to
// break out of it when I have processed all of the
// data available. Be careful with this approach and
// be sure your loop will exit.
// My reasons for this are not as clear in this sample
// as it is in my production code, but I have found this
// solutiion to be the most efficient way to do this.
///所有字符均被读出，中断循环
if (comstat.cbInQue == 0)
{
// break out when all bytes have been read
::PostMessage(hWnd, WM_COMM_RXSTR, len, (LPARAM)port->m_nPortNr); //发送数据长度 和串口号
::PostMessage(hWnd1, WM_COMM_RXSTR, len, (LPARAM)port->m_nPortNr); //发送数据长度 和串口号
break;
}
EnterCriticalSection(&port->m_csCommunicationSync);
if (bRead)
{
///串口读出，读出缓冲区中字节
// Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
if (!bResult)
{
switch (dwError = GetLastError())
{
case ERROR_IO_PENDING:
{
// asynchronous i/o is still in progress
// Proceed on to GetOverlappedResults();
///异步IO仍在进行
bRead = FALSE;
break;
}
case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
{
port->m_hComm = INVALID_HANDLE_VALUE;
CString str;
str.Format((CString)"COM%d ERROR_ACCESS_DENIED，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
AfxMessageBox(str);
break;
}
case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
{
port->m_hComm = INVALID_HANDLE_VALUE;
break;
}
case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
{
port->m_hComm = INVALID_HANDLE_VALUE;
CString str;
str.Format((CString)"COM%d ERROR_BAD_COMMAND，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
AfxMessageBox(str);
break;
}
default:
{
// Another error has occured. Process this error.
port->ProcessErrorMessage("ReadFile()");
break;
//return;///防止读写数据时，串口非正常断开导致死循环一直执行。add by itas109 2014-01-09 与上面liquanhai添加防死锁的代码差不多
}
}
}
else///ReadFile返回TRUE
{
// ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
bRead = TRUE;
}
} // close if (bRead)
///异步IO操作仍在进行，需要调用GetOverlappedResult查询
if (!bRead)
{
bRead = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
&BytesRead, // Stores number of bytes read
TRUE); // Wait flag
// deal with the error code
if (!bResult)
{
port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
}
} // close if (!bRead)
LeaveCriticalSection(&port->m_csCommunicationSync);
// notify parent that a byte was received
//避免线程互相等待，产生死锁，使用PostMessage()代替SendMessage()
::PostMessage(hWnd, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM)port->m_nPortNr);
::PostMessage(hWnd1, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM)port->m_nPortNr);
//::SendMessage((port->m_pOwner), WM_COMM_RXCHAR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
} // end forever loop
}
...全文
请发表友善的回复…
发表回复
三岁、就很帅 2016-11-14
- 打赏
- 举报
我给你的建议没有这些问题 还快稳定 上手很容易 你花个1小时去看下demo 自己测试下 就好了
嘻嘻666 2016-11-14
- 打赏
- 举报
谢谢大神
发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
涨姿势了！[/quote]
什么意思
延时必须加吗？ 是不是232 转485 有延时 怎么改，改代码？ 这个问题困扰我好久了 ，这个延时很浪费资源
[/quote]知道大神说的意思啦，485是接收不能同时对吧，那怎么改 代码？
发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
涨姿势了！[/quote]
什么意思
延时必须加吗？ 是不是232 转485 有延时 怎么改，改代码？ 这个问题困扰我好久了 ，这个延时很浪费资源
[/quote]知道大神说的意思啦，485是接收不能同时对吧，那怎么改 代码？嘻嘻666 2016-11-14
- 打赏
- 举报
谢谢大神 发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
涨姿势了！[/quote]
什么意思
延时必须加吗？ 是不是232 转485 有延时 怎么改，改代码？ 这个问题困扰我好久了 ，这个延时很浪费资源
发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
涨姿势了！[/quote]
什么意思
延时必须加吗？ 是不是232 转485 有延时 怎么改，改代码？ 这个问题困扰我好久了 ，这个延时很浪费资源
赵4老师 2016-11-14
- 打赏
- 举报
涨姿势了！
schlafenhamster 2016-11-14
- 打赏
- 举报
Rs485 是 半工 的
RS232 是 全工的。
改了吧 。
嘻嘻666 2016-11-14
- 打赏
- 举报
谢谢大神 发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
发送我已经用了线程 就是接受 是一个一个字节循环接受的
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//增加延时给Rs485转换时间
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
每个字节都要延时20MS 接收到的每条指令都有8.9个字节 所以造成每条指令读取延时特特别长，这个怎么解决
嘻嘻666 2016-11-14
- 打赏
- 举报
if (bRead)
{
///串口读出，读出缓冲区中字节
Sleep(20);//必须增加延时 ，不然读不全
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
len++; //每读一个字节len值+1；
// deal with the error code
///若返回错误，错误处理
if (!bResult)
{
switch (dwError = GetLastError())
{
case ERROR_IO_PENDING:
{
// asynchronous i/o is still in progress
// Proceed on to GetOverlappedResults();
///异步IO仍在进行
bRead = FALSE;
break;
}
case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
{
port->m_hComm = INVALID_HANDLE_VALUE;
CString str;
str.Format((CString)"COM%d ERROR_ACCESS_DENIED，ReadFile() Error Code:%d", port->m_nPortNr, GetLastError());
AfxMessageBox(str);
break;
}
case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
{
port->m_hComm = INVALID_HANDLE_VALUE;
break;
}
case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
{
port->m_hComm = INVALID_HANDLE_VALUE;
CString str;
str.Format((CString)"COM%d ERROR_BAD_COMMAND，ReadFile() Error Code:%d", port->m_nPortNr, GetLastError());
AfxMessageBox(str);
break;
}
default:
{
// Another error has occured. Process this error.
port->ProcessErrorMessage("ReadFile()");
break;
//return;///防止读写数据时，串口非正常断开导致死循环一直执行。add by itas109 2014-01-09 与上面liquanhai添加防死锁的代码差不多
}
}
}
else///ReadFile返回TRUE
{
// ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
bRead = TRUE;
}
} // close if (bRead)
///异步IO操作仍在进行，需要调用GetOverlappedResult查询
if (!bRead)
{
bRead = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
&BytesRead, // Stores number of bytes read
TRUE); // Wait flag
// deal with the error code
if (!bResult)
{
port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
}
} // close if (!bRead)
LeaveCriticalSection(&port->m_csCommunicationSync);
// notify parent that a byte was received
//避免线程互相等待，产生死锁，使用PostMessage()代替SendMessage()
::PostMessage(hWnd, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM)port->m_nPortNr);
::PostMessage(hWnd1, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM)port->m_nPortNr);
//::SendMessage((port->m_pOwner), WM_COMM_RXCHAR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
} // end forever loop
}
发送已经改了，用了线程
但是 接收哪里用了延时 是一个一个字节读的 不然收不全 不知道这么解决
嘻嘻666 2016-11-14
- 打赏
- 举报
问题找到了 ，RS485是半双工，RS232是全双工。 半双工收发转换需要时间，这个没办法 必须延时。
嘻嘻666 2016-11-14
- 打赏
- 举报
谢谢大神！我仔细看看
赵4老师 2016-11-10
- 打赏
- 举报
仅供参考：
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
#include <windows.h>
#include <process.h>
#include <io.h>
#define MYVOID void
#define vsnprintf _vsnprintf
#else
#include <unistd.h>
#include <sys/time.h>
#include <pthread.h>
#define CRITICAL_SECTION pthread_mutex_t
#define MYVOID void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef _MSC_VER
void Lock(CRITICAL_SECTION *l) {
EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
struct tm *now;
struct timeb tb;
if (NULL==pszFmt||0==pszFmt[0]) return;
vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
ftime(&tb);
now=localtime(&tb.time);
sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
sprintf(timestr,"%02d:%02d:%02d",now->tm_hour ,now->tm_min ,now->tm_sec );
sprintf(mss,"%03d",tb.millitm);
printf("%s %s.%s %s",datestr,timestr,mss,logstr);
flog=fopen(logfilename1,"a");
if (NULL!=flog) {
fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
if (ftell(flog)>MAXLOGSIZE) {
fclose(flog);
if (rename(logfilename1,logfilename2)) {
remove(logfilename2);
rename(logfilename1,logfilename2);
}
} else {
fclose(flog);
}
}
}
void Log(const char *pszFmt,...) {
va_list argp;
Lock(&cs_log);
va_start(argp,pszFmt);
LogV(pszFmt,argp);
va_end(argp);
Unlock(&cs_log);
}
//Log}
#define ASIZE 200
#define BSIZE 240
#define CSIZE 2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX;
CRITICAL_SECTION cs_BBB;
struct FIFO_BUFFER {
int head;
int tail;
int size;
char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
int i,j,k;
char binstr[80];
Lock(&cs_HEX);
for (i=0;i<len;i++) {
if (0==(i%16)) {
sprintf(binstr,"%03d %04x -",cn,i);
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
} else if (15==(i%16)) {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
sprintf(binstr,"%s ",binstr);
for (j=i-15;j<=i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
} else {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
}
}
if (0!=(i%16)) {
k=16-(i%16);
for (j=0;j<k;j++) {
sprintf(binstr,"%s ",binstr);
}
sprintf(binstr,"%s ",binstr);
k=16-k;
for (j=i-k;j<i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
}
Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
lent=0;
Lock(cs);
if (fbuf->size>=len) {
lent=len;
if (fbuf->head+lent>BSIZE) {
len1=BSIZE-fbuf->head;
memcpy(buf ,fbuf->data+fbuf->head,len1);
len2=lent-len1;
memcpy(buf+len1,fbuf->data ,len2);
fbuf->head=len2;
} else {
memcpy(buf ,fbuf->data+fbuf->head,lent);
fbuf->head+=lent;
}
fbuf->size-=lent;
}
Unlock(cs);
return lent;
}
MYVOID thdB(void *pcn) {
char *recv_buf;
int recv_nbytes;
int cn;
int wc;
int pb;
cn=(int)pcn;
Log("%03d thdB thread begin...\n",cn);
while (1) {
sleep_ms(10);
recv_buf=(char *)Cbuf;
recv_nbytes=CSIZE;
wc=0;
while (1) {
pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
if (pb) {
Log("%03d recv %d bytes\n",cn,pb);
HexDump(cn,recv_buf,pb);
sleep_ms(1);
} else {
sleep_ms(1000);
}
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
#ifndef _MSC_VER
pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
Lock(cs);
lent=len;
if (fbuf->size+lent>BSIZE) {
lent=BSIZE-fbuf->size;
}
if (fbuf->tail+lent>BSIZE) {
len1=BSIZE-fbuf->tail;
memcpy(fbuf->data+fbuf->tail,buf ,len1);
len2=lent-len1;
memcpy(fbuf->data ,buf+len1,len2);
fbuf->tail=len2;
} else {
memcpy(fbuf->data+fbuf->tail,buf ,lent);
fbuf->tail+=lent;
}
fbuf->size+=lent;
Unlock(cs);
return lent;
}
MYVOID thdA(void *pcn) {
char *send_buf;
int send_nbytes;
int cn;
int wc;
int a;
int pa;
cn=(int)pcn;
Log("%03d thdA thread begin...\n",cn);
a=0;
while (1) {
sleep_ms(100);
memset(Abuf,a,ASIZE);
a=(a+1)%256;
if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
send_buf=(char *)Abuf;
send_nbytes=ASIZE;
Log("%03d sending %d bytes\n",cn,send_nbytes);
HexDump(cn,send_buf,send_nbytes);
wc=0;
while (1) {
pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
Log("%03d sent %d bytes\n",cn,pa);
HexDump(cn,send_buf,pa);
send_buf+=pa;
send_nbytes-=pa;
if (send_nbytes<=0) break;//
sleep_ms(1000);
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
#ifndef _MSC_VER
pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
InitializeCriticalSection(&cs_log);
InitializeCriticalSection(&cs_HEX);
InitializeCriticalSection(&cs_BBB);
#else
pthread_t threads[2];
int threadsN;
int rc;
pthread_mutex_init(&cs_log,NULL);
pthread_mutex_init(&cs_HEX,NULL);
pthread_mutex_init(&cs_BBB,NULL);
#endif
Log("Start===========================================================\n");
BBB.head=0;
BBB.tail=0;
BBB.size=0;
#ifdef _MSC_VER
_beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
_beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
#else
threadsN=0;
rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif
if (!access("No_Loop",0)) {
remove("No_Loop");
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
while (1) {
sleep_ms(1000);
if (No_Loop) break;//
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
sleep_ms(3000);
Log("End=============================================================\n");
#ifdef _MSC_VER
DeleteCriticalSection(&cs_BBB);
DeleteCriticalSection(&cs_HEX);
DeleteCriticalSection(&cs_log);
#else
pthread_mutex_destroy(&cs_BBB);
pthread_mutex_destroy(&cs_HEX);
pthread_mutex_destroy(&cs_log);
#endif
return 0;
}
赵4老师 2016-11-09
- 打赏
- 举报
可以考虑使用多进程。
嘻嘻666 2016-11-09
- 打赏
- 举报
就是不会写进程 不知道怎么把收发分开成两个进程
schlafenhamster 2016-11-09
- 打赏
- 举报
"发送用的sleep（20）延时""
不浪费时间吗 ？
m_idComDev=CreateFile(m_sPort, // com1,2
GENERIC_READ|GENERIC_WRITE,
0, // sharemode 0=no share
NULL, // &sa
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
NULL); // tempfile
FILE_FLAG_OVERLAPPED 异步 读写
嘻嘻666 2016-11-09
- 打赏
- 举报
接受没问题，但是就是接受太慢了 。还没接受完，新的就又发过来。 所以发送做了延时 但是延要最低要sleep（200），做的是实时显示气体传感器参数的上位机 。 界面要显示的参数很多 而且还要实时更新 大神们有没有 案例 关于 指令收发 的seriport类
嘻嘻666 2016-11-09
- 打赏
- 举报
发送用的sleep（20）延时 ，接收是一个字节一个字节接受，各位大神有么有 一次要发送20条指令给下位机， 所以造成读取换缓慢，大神们有没有以前写的 案例关于同时收发多条指令 的seriport
oyljerry 2016-11-09
- 打赏
- 举报
是不是接收的数据没有正确的处理。导致丢失了
嘻嘻666 2016-11-08
- 打赏
- 举报
要写的上位机要实现多串口同时接受数据，所以用啦这个类
三岁、就很帅 2016-11-08
- 打赏
- 举报
用MSCOMM串口编程吧 你可以百度看下资料 应该比你那个好用
