C语言 做串口通讯程序
C语言串口通信助手代码
![C语言串口通信助手代码](https://img.taocdn.com/s3/m/05f571c6d5bbfd0a7956733c.png)
该程序全部由C写成没有C++ 更没用MFC完全是自娱自乐给需要的人一个参考#include "stdafx.h"#include <windowsx.h>#include "resource.h"#include "MainDlg.h"#include <windows.h>#include <stdio.h>#include <stdlib.h>HANDLE hComm;//用于获取串口打开函数的返回值(句柄或错误值)OVERLAPPED m_ov;COMSTAT comstat;DWORD m_dwCommEvents;TCHAR cRecs[200],cSends[100]; //接收字符串发送字符串char j=0,*cCom; //接收用统计数据大小变量端口选择BOOL WINAPI Main_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){switch(uMsg){HANDLE_MSG(hWnd, WM_INITDIALOG, Main_OnInitDialog); HANDLE_MSG(hWnd, WM_COMMAND, Main_OnCommand); HANDLE_MSG(hWnd,WM_CLOSE, Main_OnClose);}return FALSE;}/*系统初始化函数*/BOOL Main_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam){HWND hwndCombo1=GetDlgItem(hwnd,IDC_COMBO1);ComboBox_InsertString(hwndCombo1,-1,TEXT("COM1"));ComboBox_InsertString(hwndCombo1,-1,TEXT("COM2"));ComboBox_InsertString(hwndCombo1,-1,TEXT("COM3"));ComboBox_InsertString(hwndCombo1,-1,TEXT("COM4"));ComboBox_InsertString(hwndCombo1,-1,TEXT("COM5"));ComboBox_SetCurSel(hwndCombo1,0);void CALLBACK TimerProc (HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime);SetTimer(hwnd,1,1000,TimerProc);return TRUE;}/*监视串口错误时使用的函数*/boolProcessErrorMessage(char* ErrorText){char *Temp = new char[200];LPVOID lpMsgBuf;FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |FORMAT_MESSAGE_FROM_SYSTEM,NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language(LPTSTR) &lpMsgBuf,NULL);sprintf(Temp, "WARNING: %s Failed with the following error:\n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, "com2"); MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP); LocalFree(lpMsgBuf);delete[] Temp;return true;}boolopenport(char *portname)//打开串口{hComm = CreateFile(portname, //串口号“com1”“com2” 调用方法:bool open; open=openport("com2");GENERIC_READ | GENERIC_WRITE, //允许读写0, //通讯设备必须以独占方式打开0, //无安全属性OPEN_EXISTING, //通讯设备已存在FILE_FLAG_OVERLAPPED, //异步I/O0); //通讯设备不能用模板打开if (hComm == INVALID_HANDLE_VALUE) //如果被占用或是没有打开时返回的是这个错误代码CloseHandle(hComm);return FALSE;}elsereturn true;}boolsetupdcb(intrate_arg)//设置port的属性{DCB dcb;int rate= rate_arg;memset(&dcb,0,sizeof(dcb));if(!GetCommState(hComm,&dcb))//获取当前DCB配置return FALSE;// set DCB to configure the serial portdcb.DCBlength = sizeof(dcb);dcb.BaudRate = rate;dcb.Parity = NOPARITY; //奇偶校验值0~4分别对应无校验、奇校验、偶校验、校验置位、校验清零dcb.fParity = 0; //为1的话激活奇偶校验检查dcb.StopBits = ONESTOPBIT;//停止位个数,0~2分别对应1位、1.5位、2位停止位dcb.ByteSize = 8; //数据位数dcb.fOutxCtsFlow = 0;dcb.fOutxDsrFlow = 0;dcb.fDtrControl = DTR_CONTROL_DISABLE; dcb.fDsrSensitivity = 0;dcb.fRtsControl = RTS_CONTROL_DISABLE; dcb.fOutX = 0;dcb.fInX = 0;dcb.fErrorChar = 0;dcb.fBinary = 1;dcb.fNull = 0;dcb.fAbortOnError = 0;dcb.wReserved = 0;dcb.XonLim = 2;dcb.XoffLim = 4;dcb.XonChar = 0x13;dcb.XoffChar = 0x19;dcb.EvtChar = 0;// set DCBif(!SetCommState(hComm,&dcb))return false;elsereturn true;}/*串口读取相关时间设置*/boolsetuptimeout(DWORDReadInterval,DWORDReadTotalMultiplier,DWORDReadTotalconstant,DW ORDWriteTotalMultiplier,DWORDWriteTotalconstant){COMMTIMEOUTS timeouts;timeouts.ReadIntervalTimeout=ReadInterval; //读取两个字节间隔最大值mS如超过立即返回不再读取timeouts.ReadTotalTimeoutConstant=ReadTotalconstant; //如果同下面一个都为0 则无论是否读到数据都返回// 可以毫秒为单位指定一个乘数,该乘数用来计算读操作的总限时时间timeouts.ReadTotalTimeoutMultiplier=ReadTotalMultiplier; // 以毫秒为单位指定一个常数,用于计算读操作的总限时时间0表示不限时timeouts.WriteTotalTimeoutConstant=WriteTotalconstant;// 写操作延时同上timeouts.WriteTotalTimeoutMultiplier=WriteTotalMultiplier;if(!SetCommTimeouts(hComm, &timeouts))return false;elsereturn true;}intClearn() //清除buff中的内容并返回buff中现有数据量的大小并读取错误原因{DWORD dwError = 0;DWORD BytesRead = 0;ClearCommError(hComm, &dwError, &comstat);return comstat.cbInQue; //返回buff中数据量}/*串口数据接收读取函数*/void ReceiveChar(){BOOL bRead = TRUE;BOOL bResult = TRUE;DWORD dwError = 0;DWORD BytesRead = 0;char i=0,n;char RXBuff;j=0;while (i-n){n=i;Sleep(10);bResult = ClearCommError(hComm, &dwError, &comstat); i=(char)comstat.cbInQue;for (;i>0;i--){if (bRead)bResult = ReadFile(hComm, // Handle to COMM port &RXBuff, // RX Buffer Pointer1, // Read one byte&BytesRead, // Stores number of bytes read&m_ov); // pointer to the m_ov structure// printf("%c",RXBuff);cRecs[j++]=(char)RXBuff;if (!bResult){switch (dwError = GetLastError()){case ERROR_IO_PENDING:{bRead = FALSE;break;}default: break;}elsebRead = TRUE; // close if (bRead)if (!bRead){bRead = TRUE;bResult = GetOverlappedResult(hComm, // Handle to COMM port&m_ov, // Overlapped structure&BytesRead, // Stores number of bytes readTRUE); // Wait flag}}}boolWriteChar(char* m_szWriteBuffer,DWORDm_nToSend) //写字符的函数{BOOL bWrite = TRUE;BOOL bResult = TRUE;DWORD BytesSent = 0;HANDLE m_hWriteEvent;ResetEvent(m_hWriteEvent);if (bWrite){m_ov.Offset = 0;m_ov.OffsetHigh = 0;// Clear bufferbResult = WriteFile(hComm, // Handle to COMM Portm_szWriteBuffer, // Pointer to message buffer in calling finction m_nToSend, // Length of message to send&BytesSent, // Where to store the number of bytes sent&m_ov ); // Overlapped structureif (!bResult){DWORD dwError = GetLastError();switch (dwError){case ERROR_IO_PENDING:{// continue to GetOverlappedResults()BytesSent = 0;bWrite = FALSE;break;}default:// all other error codesbreak;}}} // end if(bWrite)if (!bWrite){bWrite = TRUE;bResult = GetOverlappedResult(hComm, // Handle to COMM port &m_ov, // Overlapped structure&BytesSent, // Stores number of bytes sentTRUE); // Wait flag// deal with the error codeif (!bResult){printf("GetOverlappedResults() in WriteFile()");}} // end if (!bWrite)// Verify that the data size send equals what we tried to send if (BytesSent != m_nToSend){printf("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)m_szWriteBuffer));}return true;}/*window时间函数回调*/void CALLBACK TimerProc (HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime){SYSTEMTIME time; //定义机构体变量timeGetLocalTime(&time); //取系统时间以指针方式TCHAR strTime[256]; //程序只有一个作用wsprintf(strTime,"%04d-%02d-%02d %02d:%02d:%02d",time.wYear, //就是读取系统时间time.wMonth,time.wDay,time.wHour,time.wMinute,time.wSecond);//然后写进strTimeSetDlgItemText(hwnd,IDC_TIME,strTime); //这个字符串}void Main_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify){switch(id){case IDC_SEND:{GetDlgItemText (hwnd,IDC_EDIT2,cSends,sizeof(cSends)); unsigned n=sizeof(cSends); //n是通知串口将发送字节的长度char send[100];wsprintf (send,"%s",cSends);WriteChar(send,n-1);SetCommMask(hComm, EV_RXCHAR); //监视串口是否接收有数据ReceiveChar(); //读取串口sbuff中数据cRecs[j]='\0'; //将cRecs转为字符串SetDlgItemText(hwnd,IDC_EDIT1,cRecs);} break;/*case IDC_RECEIVE: //暂时未用采用直接显示的方式{}break;*/case IDC_CHECK:{intctr;HWND hwndCombo1=GetDlgItem(hwnd,IDC_COMBO1);ctr = ComboBox_GetCurSel(hwndCombo1);switch (ctr){case 0:cCom="com1";break;case 1:cCom="com2";break;case 2:cCom="com3";break;case 3:cCom="com4";break;case 4:cCom="com5";break;default: cCom="com1";break;}if (openport(cCom)){ SetDlgItemText(hwnd,IDC_EDIT3,"OK !");MessageBox(hwnd,"串口打开成功!","",0); }elseSetDlgItemText(hwnd,IDC_EDIT3,"FAIL");if(setupdcb(9600)&&setuptimeout(1024,0,0,20,1000)) //初始化串口属性波特率9600SetDlgItemText(hwnd,IDC_EDIT4,"串口属性设置成功");elseSetDlgItemText(hwnd,IDC_EDIT4,"串口初始化失败!"); PurgeComm(hComm, PURGE_RXCLEAR | PURGE_TXCLEAR |PURGE_RXABORT | PURGE_TXABORT);}default:break;}}void Main_OnClose(HWND hwnd) {EndDialog(hwnd, 0);}。
51单片机的串口通信程序(C语言)
![51单片机的串口通信程序(C语言)](https://img.taocdn.com/s3/m/e10b7dfb5ebfc77da26925c52cc58bd630869373.png)
51单片机的串口通信程序(C语言) 51单片机的串口通信程序(C语言)在嵌入式系统中,串口通信是一种常见的数据传输方式,也是单片机与外部设备进行通信的重要手段之一。
本文将介绍使用C语言编写51单片机的串口通信程序。
1. 硬件准备在开始编写串口通信程序之前,需要准备好相应的硬件设备。
首先,我们需要一块51单片机开发板,内置了串口通信功能。
另外,我们还需要连接一个与单片机通信的外部设备,例如计算机或其他单片机。
2. 引入头文件在C语言中,我们需要引入相应的头文件来使用串口通信相关的函数。
在51单片机中,我们需要引入reg51.h头文件,以便使用单片机的寄存器操作相关函数。
同时,我们还需要引入头文件来定义串口通信的相关寄存器。
3. 配置串口参数在使用串口通信之前,我们需要配置串口的参数,例如波特率、数据位、停止位等。
这些参数的配置需要根据实际需要进行调整。
在51单片机中,我们可以通过写入相应的寄存器来配置串口参数。
4. 初始化串口在配置完串口参数之后,我们需要初始化串口,以便开始进行数据的发送和接收。
初始化串口的过程包括打开串口、设置中断等。
5. 数据发送在串口通信中,数据的发送通常分为两种方式:阻塞发送和非阻塞发送。
阻塞发送是指程序在发送完数据之后才会继续执行下面的代码,而非阻塞发送是指程序在发送数据的同时可以继续执行其他代码。
6. 数据接收数据的接收与数据的发送类似,同样有阻塞接收和非阻塞接收两种方式。
在接收数据时,需要不断地检测是否有数据到达,并及时进行处理。
7. 中断处理在串口通信中,中断是一种常见的处理方式。
通过使用中断,可以及时地响应串口数据的到达或者发送完成等事件,提高程序的处理效率。
8. 串口通信实例下面是一个简单的串口通信实例,用于在51单片机与计算机之间进行数据的传输。
```c#include <reg51.h>#include <stdio.h>#define BAUDRATE 9600#define FOSC 11059200void UART_init(){TMOD = 0x20; // 设置定时器1为模式2SCON = 0x50; // 设置串口为模式1,允许接收TH1 = 256 - FOSC / 12 / 32 / BAUDRATE; // 计算波特率定时器重载值TR1 = 1; // 启动定时器1EA = 1; // 允许中断ES = 1; // 允许串口中断}void UART_send_byte(unsigned char byte){SBUF = byte;while (!TI); // 等待发送完成TI = 0; // 清除发送完成标志位}unsigned char UART_receive_byte(){while (!RI); // 等待接收完成RI = 0; // 清除接收完成标志位return SBUF;}void UART_send_string(char *s){while (*s){UART_send_byte(*s);s++;}}void main(){UART_init();UART_send_string("Hello, World!"); while (1){unsigned char data = UART_receive_byte();// 对接收到的数据进行处理}}```总结:通过以上步骤,我们可以编写出简单的51单片机串口通信程序。
C语言串口通信-源代码
![C语言串口通信-源代码](https://img.taocdn.com/s3/m/78bd6f6cdcccda38376baf1ffc4ffe473368fdfb.png)
C语言串口通信-源代码#include<tdio.h>#include<do.h>#include<conio.h>#include<tring.h>#defineCOM2320某2f8#defineCOMINT0某0b#defineMa某BufLen500#definePort82590某20#defineEofInt0某20taticcharintvectnum;taticunignedcharmakb;taticunignedcharBuffer[Ma某BufLen];taticintCharInBuf,CircIn,CircOut;taticvoid(interruptfar某OldAyncInt)();taticvoidinterruptfarAyncInt(void);unignedcharData,unignedcharStop,unignedcharParity){ unignedcharHigh,Low;intf;intvectnum=IntVectNum;CharInBuf=0;CircIn=0;CircOut=0;diable();OldAyncInt=getvect(IntVectNum);etvect(IntVectNum,Ay ncInt);enable();makb=inp(Port8259+1);if(IntVectNum==0某0c)outp(Port8259+1,makb&0某ef);eleoutp(Port8259+1,makb&0某f7);}taticvoidinterruptfarAyncInt(void){diable();if(CharInBuf<Ma某BufLen)if(CircIn<Ma某BufLen-1)CircIn++;eleCircIn=0;if(CircIn==CircOut)CircOut++;eleCharInBuf++;enable();outp(Port8259,EofInt);}voidRetore(void)etvect(intvectnum,OldAyncInt);outp(Port8259+1,makb);}intGetCharInBuf(unignedchar某Char) {intFlag;Flag=-1;if(CharInBuf>0){(某Char)=Buffer[CircOut];if(CircOut<Ma某BufLen-1)CircOut++; eleCircOut=0;CharInBuf--;Flag=0;}returnFlag;}intSendChar(unignedcharChar)return0;}main(){inti,c;unignedcharInChar;Init_COM(COM232,COMINT,1200,8,1,0); while(1){if(kbhit()){if((InChar=getch())==27)break; elewhile(SendChar(InChar));}if(GetCharInBuf(&InChar)==0)printf("%c",InChar);}Retore();}接收程序:#include<do.h>#include<ftream.h>#include<conio.h>#include<tdio.h>#include<tdlib.h>#include<math.h>#defineR某D0//接收voidInt(){unignedcharkey,key2;if(peek(0某40,port某2)==0){e某it(1);}ele{};Getportaddr(port);//得到串口地址SerInit(SER_BAUD_9600,SER_PARITY_EVEN|SER_BITS_8|SER_STOP_1) ;//初始化串口,设置波特率等SerOpen();do{if(kbhit()){key2=getch();if(key2==27){break;}};key=getb();if(key!=0某ff){printf("%某\t",key);FILE某fp;fp=fopen("C:\\Receivedata.dat","ab");//可选择接收数据的存放文件路径和文件名if(fp==NULL)printf("Fileopenerror!");//fputc(key,fp);fwrite(&key,izeof(unignedchar),1,fp);fcloe(fp);}}while(key2!=27);SerCloe();//printf("%dcharhabeenreceived\n",incount); //printf("%dcharhabeenended\n",outcount);//printf("\num=%d\n",um);}{printf("PleaeinputthereceiveCOMnum:(1~4)\n"); Cloe_Serial(intport_bae){outp(port_bae+SER_MCR,0);outp(port_bae+SER_IER,0);outp(PIC_IMR,old_int_mak);if(port_bae==COM_1){_do_etvect(INT_SER_PORT_0,Old_Ir);}ele{_do_etvect(INT_SER_PORT_1,Old_Ir);}}/某-------------发送应用----------------某/ voidmain(intargc,char某argv[]){charch,pre;intdone=0;FILE某fp;argc=2;if(argc<2){printf("\nUage:diplayfilename.wav!!!");//e某it(1);}if((fp=fopen(argv[1],"r+b"))==NULL){printf("cannotopenthefile\n");//e某it(0);}feek(fp,0,SEEK_SET);Open_Serial(COM_1,SER_BAUD_9600,SER_PARITY_EVEN|SER_STOP_1);printf("preanykeytobeginending");getch();//Serial_Write('');//该语句可用于发送单个字符while(!done&&ch!=EOF)//发送文件开始{ch=fgetc(fp);SER_BITS_8|//if(ch==EOF)Serial_Write(27);Serial_Write(ch);delay(30);if( kbhit()){pre=getch();if(pre==27){Serial_Write(27);done=1;}}}Cloe _Serial(COM_1);fcloe(fp);}下面介绍最重要的MFC:CWnd:窗口,它是大多数“看得见的东西”的父类(Window里几乎所有看得见的东西都是一个窗口,大窗口里有许多小窗口),比如视图CView、框架窗口CFrameWnd、工具条CToolBar、对话框CDialog、按钮CButton,etc;一个例外是菜单(CMenu)不是从窗口派生的。
用C编写的RS232串口通信程序
![用C编写的RS232串口通信程序](https://img.taocdn.com/s3/m/2bef5719a300a6c30c229f89.png)
void main(){delayms(100);init(); //初始化系统delayms(100);init_wdt(); //初始化看门狗while(1){while(!RI_0) //是否收到数据{clr_wdt();}RI_0=0; //清除接收中断标志buffer=S0BUF;if(buffer==0x5a) //检测祯头0start0=1;if(buffer==0x54) //检测祯头1start1=1;if(buffer==0x5a) //检测祯尾0end0=1;if(buffer==0xfe) //检测祯尾1end1=1;if((start0==1)&(start1==1)){buff[i]=buffer; //从祯头1开始存储数据i++;}if((end0==1)&(end1==1)) //是否已经接收祯尾{count=i; //数据长度为count个i=1;if((buff[2]==0x03)&(count==107)) //是否422指令 {buff[0]=0x5a; //重填祯头0buff[count-4]=0; //校验和清零for(k=2;k<(count-4);k++) //计算校验和{buff[count-4]+=buff[k];}for(k=0;k<count;k++) //从祯头1开始循环发送{S0BUF=buff[k];while(!TI_0); //等待发送完成TI_0=0; //清除发送中断标志}reset();}else if((buff[2]==0x05)&(count==7)) //是否AD测试指令{sendad();reset();}else if((buff[2]==0x18)&(count==7)) //是否发送时序信号指令{sendpaulse();reset();}else //如果接收错误,则恢复各标志位为初始状态以便下次接收 {reset();}}}}void reset(){start0=0; //祯头祯尾标志位清零start1=0;end0=0;end1=0;for(k=0;k<count;k++){buff[k]=0x00; //缓冲区清零}count=0; //计数清零}。
c语言怎么写串口通信编程 -回复
![c语言怎么写串口通信编程 -回复](https://img.taocdn.com/s3/m/031887fb970590c69ec3d5bbfd0a79563c1ed42a.png)
c语言怎么写串口通信编程 -回复在C语言中进行串口通信编程,你需要了解串口的基本原理以及相关的函数和库。
串口通信是一种通过串行数据传输进行通信的方式,常用于嵌入式系统中与外部设备进行数据交互。
本文将以步骤的形式来介绍如何在C语言中进行串口通信编程。
步骤一:了解串口的基本原理在开始串口通信编程之前,你需要了解串口的基本原理。
串口是通过发送和接收数据位的序列来进行通信的。
串口通信需要考虑的一些参数包括波特率(即数据传输速率)、数据位数、校验位和停止位等。
波特率指的是每秒钟传输的位数,可以是常用的9600、19200、38400等。
步骤二:选择合适的串口库在C语言中,你可以选择使用合适的串口库来简化串口通信的编程工作。
常见的串口库包括Windows系统中的WinAPI、Linux系统中的termios库等。
选择库的时候,需根据你所使用的操作系统和开发环境进行选择。
步骤三:打开串口在开始使用串口进行通信之前,需要先打开串口。
使用串口库的函数,可以根据需要选择打开特定的串口,一般通过指定串口名称或者端口号来进行打开。
打开串口的函数可能返回一个文件描述符或者句柄,用于后续的读写操作。
步骤四:配置串口参数打开串口之后,需要进行串口参数的配置。
这包括波特率、数据位数、校验位和停止位等参数的设置。
一般通过调用相应的函数,将需要设置的参数传递给串口库,以完成参数的配置。
步骤五:读取串口数据配置完串口参数后,你可以开始读取串口数据。
通过调用读取函数,你可以从串口接收缓冲区中获取数据,并进一步进行处理。
读取函数可能会阻塞程序执行,直到有数据可读取为止。
步骤六:发送串口数据与读取串口数据相对应的是发送串口数据。
通过调用相应的发送函数,你可以将你要发送的数据写入串口发送缓冲区,等待发送。
发送函数可能会阻塞程序执行,直到数据成功发送。
步骤七:关闭串口在程序结束时,需要关闭已经打开的串口。
通过调用相应的函数,可以完成串口的关闭。
C语言实现串口通信
![C语言实现串口通信](https://img.taocdn.com/s3/m/b4eec85f5e0e7cd184254b35eefdc8d377ee1416.png)
C语言实现串口通信在使用系统调用函数进行串口通信之前,需要打开串口设备并设置相关参数。
打开串口设备可以使用open(函数,设置串口参数可以使用termios结构体和tcsetattr(函数。
以下是一个简单的串口通信接收数据的示例代码:```c#include <stdio.h>#include <stdlib.h>#include <fcntl.h>#include <unistd.h>#include <termios.h>int mainint fd; // 串口设备文件描述符char buff[255]; // 存储接收到的数据int len; // 接收到的数据长度//打开串口设备fd = open("/dev/ttyS0", O_RDONLY);if (fd < 0)perror("Failed to open serial port");return -1;}//设置串口参数struct termios options;tcgetattr(fd, &options);cfsetspeed(&options, B1200); // 设置波特率为1200 tcsetattr(fd, TCSANOW, &options);//接收数据while (1)len = read(fd, buff, sizeof(buff)); // 从串口读取数据if (len > 0)buff[len] = '\0'; // 将接收到的数据转为字符串printf("Received data: %s\n", buff);}}//关闭串口设备close(fd);return 0;```这段代码首先通过open(函数打开串口设备文件"/dev/ttyS0",然后使用tcgetattr(函数获取当前设置的串口参数,接着使用cfsetspeed(函数设置波特率为1200,最后使用tcsetattr(函数将设置好的串口参数写回。
c语言串口通信范例完整版
![c语言串口通信范例完整版](https://img.taocdn.com/s3/m/6ed94c4fed630b1c59eeb590.png)
c语言串口通信范例标准化管理处编码[BBX968T-XBB8968-NNJ668-MM9N]一个c语言的串口通信程序范例标签:分类:最近接触一个项目,用HL-C1C激光位移传感器+易控组态软件完成生产线高度跳变检测,好久没有接触c c#,一些资料,找来做个记录,也许大家用的着#include <>#include <>#include <>#include <>#define COM232 0x2f8#define COMINT 0x0b#define MaxBufLen 500#define Port8259 0x20#define EofInt 0x20static int comportaddr;static char intvectnum;static unsigned char maskb;static unsigned char Buffer[MaxBufLen];static int CharsInBuf,CircIn,CircOut;static void (interrupt far *OldAsyncInt)();static void interrupt far AsyncInt(void);void Init_COM(int ComPortAddr, unsigned char IntVectNum, int Baud, unsigned char Data, unsigned char Stop, unsigned char Parity) {unsigned char High,Low;int f;comportaddr=ComPortAddr;intvectnum=IntVectNum;CharsInBuf=0;CircIn=0;CircOut=0;f=(Baud/100);f=1152/f; High=f/256;Low=f-High*256;outp(ComPortAddr+3,0x80);outp(ComPortAddr,Low);outp(ComPortAddr+1,High);Data=(Data-5)|((Stop-1)*4);if(Parity==2) Data=Data|0x18;else if(Parity==1) Data=Data|0x8; outp(ComPortAddr+3,Data);outp(ComPortAddr+4,0x0a);outp(ComPortAddr+1,0x01);disable();OldAsyncInt=getvect( IntVectNum ); setvect( IntVectNum, AsyncInt ); enable();maskb=inp(Port8259+1);if(IntVectNum==0x0c)outp(Port8259+1,maskb&0xef); else outp(Port8259+1,maskb&0xf7);}static void interrupt far AsyncInt(void){disable();if(CharsInBuf<MaxBufLen)Buffer[CircIn]=inp(comportaddr);if(CircIn<MaxBufLen-1) CircIn++;else CircIn=0;if(CircIn==CircOut) CircOut++;else CharsInBuf++;enable();outp(Port8259,EofInt);}void Restore(void){setvect(intvectnum,OldAsyncInt);outp(Port8259+1,maskb);}int GetCharInBuf(unsigned char *Char) {int Flag;Flag=-1;if(CharsInBuf>0){(*Char)=Buffer[CircOut];if(CircOut<MaxBufLen-1)CircOut++;else CircOut=0;CharsInBuf--;Flag=0;}return Flag;}int SendChar(unsigned char Char){if((inp(comportaddr+5)&0x20)==0) return -1; outp(comportaddr,Char);return 0;}main(){int i,c;unsigned char InChar;Init_COM(COM232,COMINT,1200,8,1,0);while(1){if(kbhit()){if((InChar=getch())==27)break; else while(SendChar(InChar)); }if(GetCharInBuf(&InChar)==0)printf("%c",InChar);}Restore();}接收程序:#include <>#include <>#include <>#include <>#include <>#include <>#define RXD 0 .);void putb(unsigned char ch).){unsigned char ch;ch=inportb(portaddr+RXD);putb(ch);incount++; n");exit(1);}else{printf("The used port is :COM%d\n",ComNum); };Getportaddr(port); .#else#define __CPPARGS#endif#define SER_RBF 0#define SER_THR 0#define SER_IER 1#define SER_IIR 2#define SER_LCR 3#define SER_MCR 4#define SER_LSR 5#define SER_MSR 6#define SER_DLL 0#define SER_DLH 1#define SER_BAUD_1200 96 #define SER_BAUD_2400 48 #define SER_BAUD_9600 12 #define SER_BAUD_19200 6 #define SER_GP02 8#define COM_1 0x3F8#define COM_2 0x2F8 /*/ base port address of port 1*/#define COM_3 0x3E8#define COM_4 0x2E8#define SER_STOP_1 0 /*/ 1 stop bit per character*/#define SER_STOP_2 4 /*/ 2 stop bits per character*/#define SER_BITS_5 0 /*/ send 5 bit characters*/#define SER_BITS_6 1 /*/ send 6 bit characters*/#define SER_BITS_7 2 /*/ send 7 bit characters*/#define SER_BITS_8 3 /*/ send 8 bit characters*/#define SER_PARITY_NONE 0 /*/ no parity*/#define SER_PARITY_ODD 8 /*/ odd parity*/#define SER_PARITY_EVEN 24 /*/ even parity*/#define SER_DIV_LATCH_ON 128 /*/ used to turn reg 0,1 into divisor latch*/ #define PIC_IMR 0x21 /*/ pic's interrupt mask reg.*/#define PIC_ICR 0x20 /*/ pic's interupt control reg.*/#define INT_SER_PORT_0 0x0C /*/ port 0 interrupt com 1 & 3*/#define INT_SER_PORT_1 0x0B /*/ port 0 interrupt com 2 & 4*/#define SERIAL_BUFF_SIZE 128 /*/ current size of circulating receivebuffer*/void interrupt far (*Old_Isr)(__CPPARGS); /*/ holds old com port interrupt handler*/char ser_buffer[SERIAL_BUFF_SIZE]; /*/ the receive buffer*/int ser_end = -1,ser_start=-1; /*/ indexes into receive buffer*/int ser_ch, char_ready=0; /*/ current character and ready flag*/int old_int_mask; /*/ the old interrupt mask on the PIC*/int open_port; /*/ the currently open port*/int serial_lock = 0; /*/ serial ISR semaphore so the buffer*//*/ isn't altered will it is being written*//*/ to by the ISR*//*-------------写串口-----------------*/void interrupt far Serial_Isr(__CPPARGS){serial_lock = 1;ser_ch = inp(open_port + SER_RBF);if (++ser_end > SERIAL_BUFF_SIZE-1)ser_end = 0;ser_buffer[ser_end] = ser_ch;++char_ready;outp(PIC_ICR,0x20);serial_lock = 0;}int Ready_Serial(){return(char_ready);}/*--------------读串口--------------*/ int Serial_Read(){int ch;while(serial_lock){}if (ser_end != ser_start){if (++ser_start > SERIAL_BUFF_SIZE-1)ser_start = 0;ch = ser_buffer[ser_start];printf("%x",ch);if (char_ready > 0)--char_ready;return(ch);}elsereturn(0);}/*--------------写串口-----------------*/ Serial_Write(char ch){while(!(inp(open_port + SER_LSR) & 0x20)){}asm clioutp(open_port + SER_THR, ch);asm sti}/*-----------初始化串口---------------*/Open_Serial(int port_base, int baud, int configuration) {open_port = port_base;disable();outp(port_base + SER_LCR, SER_DIV_LATCH_ON);outp(port_base + SER_DLL, baud);outp(port_base + SER_DLH, 0);outp(port_base + SER_LCR, configuration);outp(port_base + SER_MCR, SER_GP02);outp(port_base + SER_IER, 1);if (port_base == COM_1 || port_base==COM_3){Old_Isr = _dos_getvect(INT_SER_PORT_0);_dos_setvect(INT_SER_PORT_0, Serial_Isr);printf("\nOpening Communications Channel Com Port #1/3...\n");}else{Old_Isr = _dos_getvect(INT_SER_PORT_1);_dos_setvect(INT_SER_PORT_1, Serial_Isr);printf("\nOpening Communications Channel Com Port #2/4...\n");}old_int_mask = inp(PIC_IMR);outp(PIC_IMR, (port_base==COM_1) (old_int_mask & 0xEF) : (old_int_mask & 0xF7 ));enable();/*-------------关闭串口--------------*/Close_Serial(int port_base){outp(port_base + SER_MCR, 0);outp(port_base + SER_IER, 0);outp(PIC_IMR, old_int_mask );if (port_base == COM_1){_dos_setvect(INT_SER_PORT_0, Old_Isr);printf("\nClosing Communications Channel Com Port #1.\n"); }else{_dos_setvect(INT_SER_PORT_1, Old_Isr);printf("\nClosing Communications Channel Com Port #2.\n");}/*-------------发送应用----------------*/ void main(int argc,char *argv[]){char ch,press;int done=0;FILE *fp;argc=2;//argv[1]="c:\\";if(argc<2){printf("\nUsage:display !!!");// exit(1);}if((fp=fopen(argv[1],"r+b"))==NULL)printf("cannot open the file\n");// exit(0);}fseek(fp, 0, SEEK_SET);Open_Serial(COM_1,SER_BAUD_9600,SER_PARITY_EVEN| SER_BITS_8 | SER_STOP_1); printf("com:1;bps:9600;parity:even;bits:8;stop bit:1");printf("press any key to begin sending");getch();//Serial_Write(''); //该语句可用于发送单个字符while(!done&&ch != EOF) //发送文件开始{ch = fgetc(fp);//if(ch==EOF) Serial_Write(27);Serial_Write(ch);delay(30);if (kbhit()){press=getch();if (press==27){Serial_Write(27);done=1;}}}Close_Serial(COM_1);fclose(fp);}下面介绍最重要的MFC:CWnd:窗口,它是大多数“看得见的东西”的父类(Windows里几乎所有看得见的东西都是一个窗口,大窗口里有许多小窗口),比如视图CView、框架窗口CFrameWnd、工具条CToolBar、对话框CDialog、按钮CButton,etc;一个例外是菜单(CMenu)不是从窗口派生的。
串口通信之用C语言编写串口程序
![串口通信之用C语言编写串口程序](https://img.taocdn.com/s3/m/1e003954a36925c52cc58bd63186bceb19e8edb8.png)
串口通信之用C语言编写串口程序在当今,流行的编程软件种类繁多,它们编程方便、易于维护,但是在与硬件直接打交道和编制系统软件时却束手无策,于是C语言就有了用武之地。
C语言作为汇编语言与高级语言之间的一种过渡语言,兼有汇编语言的高效和高级语言的方便。
在通讯中,为了保证行运安全可靠,标准的串行口必须具有许多握手信号和状态信息。
这是因为通讯的各个计算机CPU速度不一样(这会导致“错帧”)以及发送机发送数据速度比接收机接收速度快(这会导致“过冲”)。
为解决这个问题,我们采用一个简单的握手信号,即发送机每次仅发送半个字节(低4位)的数据,而另外半个字节(高4位)则用来传送信息。
我们可以对信息位(高4位)进行如下简单的编码:0H:发送的是新的半个字节数据1H:重新发送上次传送错误的数据2H:文件名结束3H:文件结束这样,每当发送机发送一个字节以后,就等待接受机发回送信号,这回送信号就是发送机发送过来的那个字节。
发送机接收到回送信号后,把它与刚发送的字节相比较,如果相同,就发送新的半个字节,否则就重新发送。
新数据与旧数据通过信息位来区分。
下面就是用C 语言编写控制串行口的程序。
#include "dos.h"#include "stdlib.h"#include "stdio.h"#define PORT 0void SendFile(char *fname); /* 发送文件*/void Send(int s); /*发送一个字节*/void SendFileName(char *fname); /*发送文件名*/void ReceiveFile(); /*接收文件*/void GetFileName(char *f); /*接收文件名*/void InitPort(int port,unsigned char para); /*初始化端口*/ void SendPort(int port,char c); /*端口发送*/int ReadPort(int port); /*读端口字节*/int CheckState(int port); /*检查端口状态*/int Receive(int port,int *G); /*接收一个字节*/main(int argc,char *argv[]){if(argc<2){printf("Please input R(receive) or S(sent) parametre:"); exit(1);}InitPort(PORT,231);if(*argv[1]==''''S'''') /*检查选择的有效性*/SendFile(argv[2]);else if(*argv[1]==''''R'''')ReceiveFile();else{printf("Error parament.Please input again.");exit(1);}}void SendFile(char *fname){FILE *fp;int ch,s;if((fp=fopen(fname,"rb"))==NULL){printf("Can''''t open the file.\n");exit(1);}SendFileName(fname);do{ch=(int)getc(fp);if(ferror(fp)){printf("Error reading file.\n");break;}s=ch%16; /*取文件中一个字节的低4位*/ Send(s);s=ch/16; /*取文件中一个字节的高4位*/ Send(s);}while(!feof(fp));s=46; /*发送文件结束信息*/Send(s);Send(s);fclose(fp);}void Send(s)int s;{int G;SendPort(PORT,s);G=ReadPort(PORT); /*等待握手信号*/ if(s!=G)s=s+16;do{SendPort(PORT,s);G=ReadPort(PORT);/*等待握手信号*/}while(s!=G);}void SendFileName(fname)char *fname;{int s,ch;printf("Now transmit the file.Please wait..."); while(*fname){ch=(int)fname++;s=ch%16; /*取文件名中一个字节的低4位*/ Send(s);s=ch/16;Send(s); /*取文件名中一个字节的低4位*/}s=32; /*发送文件名结束标志*/Send(s);Send(s);}void ReceiveFile(){FILE *fp;char ch;int G1,G2,G3;char fname[15];GetFileName(fname);printf("Receiving file %s.\n",fname); remove(fname);if((fp=fopen(fname,"wb"))==NULL){printf("Can''''t open output file.\n");exit(1);}/*循环为检测每次接受的数据是否为新数据,如果不是,*//*则用此次接收的数据覆盖上次接收的数据*/G1=ReadPort(PORT);G2=Receive(PORT,&G1);do{G3=Receive(PORT,&G2);ch=(char)(G1%16+G2*16);/*恢复分开的数据,组合高4位和低4位*/putc(ch,fp);if(ferror(fp)){printf("\nError writing file.");exit(1);}G2=Receive(PORT,&G3);G1=G3;}while(G1/16!=48);printf("\nTransmit finished.");fclose(fp);}int Receive(port,G)int port,*G;{int GM;SendPort(port,*G);GM=ReadPort(port);if(GM/16==0)return GM;else if(GM/16==1){do{*G=GM;SendPort(port,GM);GM=ReadPort(port);}while(GM/16==1);}return GM;}void GetFileName(char *f){int G1,G2,G3;char ch;G1=ReadPort(PORT);G2=ReadPort(PORT);do{G3=Receive(PORT,&G3);ch=(char)(G1%16+G2/16);*f=ch;*f++;G2=Receive(PORT,&G3);G1=G3;}while(G1/16!=32);printf("File name transmit finished.\n"); }void InitPort(port,para)int port;unsigned char para;{union REGS reg;reg.x.dx=port;reg.h.ah=0;reg.h.al=para;int86(0x14,?,?);}void SendPort(port,c)int port;char c;{union REGS reg;reg.x.dx=port;reg.h.al=c;reg.h.ah=1;int86(0x14,?,?);if(reg.h.ah&128){printf("\nSend mistakes!");exit(1);}}int ReadPort(port)int port;{union REGS reg;while(!(CheckState(port)&256)){if(kbhit()){/*如端口长期无数据可人为终止等待*/ printf("Press any key to exit.");getch();exit(1);}}reg.x.dx=port;reg.h.ah=2;int86(0x14,?,?);if(reg.h.ah&128){printf("\nRead mistake!");exit(1);}return reg.h.al;}int CheckState(port)int port;{union REGS reg;reg.x.dx=port;reg.h.ah=3;int86(0x14,?,?);return reg.x.ax;}在当今,流行的编程软件种类繁多,它们编程方便、易于维护,但是在与硬件直接打交道和编制系统软件时却束手无策,于是C语言就有了用武之地。
串口通信c 语言程序
![串口通信c 语言程序](https://img.taocdn.com/s3/m/582b4161f5335a8102d2200e.png)
串口通信c 语言程序#include "c8051f020.h"#include <intrins.h>/********函数声明********/void SYSCLK_Init (void); //*单片机时钟初始化void PORT_Init (void); // 初始化IO口void Uart0_Init(void); //串口0 初始化//**** 变量及I/O口定义*********unsigned char data aaa[5]_at_ 0x30;unsigned char data BBB[5]_at_ 0x40;unsigned char data EEE _at_ 0x50;int k;//*********单片机时钟初始化***********//void SYSCLK_Init (void){int i; // delay counterOSCXCN = 0x65; // start external oscillator with// 18.432MHz crystalfor (i=0; i < 256; i++) ; // Wait for osc. to start upwhile (!(OSCXCN & 0x80)) ; // Wait for crystal osc. to settleOSCICN = 0x88; // select external oscillator as SYSCLK// source and enable missing clock// detector}//***************//初始化IO口*************************//void PORT_Init (void){XBR0 = 0x07; // Enable SMBus, SPI0, and UART0XBR1= 0x02; //交叉开关允许XBR2 = 0x40; // Enable crossbar and weak P74OUT=0x04 ;pull-ups}//***************串口0 初始化**************//void Uart0_Init(void){TMOD = 0x20; // TMOD: 定时器1, 模式2, 8位重载SCON0 = 0x40; // SCON0: 模式1, 8位UART,PCON = 0x80; // SMOD00 = 1TH1= 0x70;TL1= 0x70;CKCON=0x10; // T1时钟为系统时钟12分频TR1=1; //计数器1开始计时, 打开串口Uart0 }//************主程序****************************//void main (void){WDTCN = 0xde;WDTCN = 0xad; //关看门狗SYSCLK_Init (); //初始化时钟PORT_Init (); //初始化IO口Uart0_Init(); //串口0 初始化aaa[0]=0x011;aaa[1]=0x022;aaa[2]=0x033;aaa[3]=0x044;aaa[4]=0x055;aaa[5]=0x066;P5=0x40;//485发送for(k=0;k<=5;k++){SBUF0=aaa[k];while(TI0!=1);TI0=0;}P5=0x0;//485接收REN0=1;for(k=0;k<=5;k++){while(RI0!=1);RI0=0;BBB[k]=SBUF0 ;}while(1) ;}。
基于C语言的RS232串口通信的设计
![基于C语言的RS232串口通信的设计](https://img.taocdn.com/s3/m/fae2b34278563c1ec5da50e2524de518964bd3f0.png)
基于C语言的RS232串口通信的设计RS232是一种常见的串行通信接口,广泛用于计算机与外部设备之间的数据传输。
RS232串口通信涉及到多个方面的设计,包括串口参数设置、数据的发送与接收等。
本文将以C语言为基础,介绍如何设计一个基于RS232串口通信的程序。
接下来,我们需要编写数据发送和接收的函数。
数据的发送包括两个步骤:打开串口和发送数据。
首先,我们需要打开串口,并设置好相应的参数。
在C语言中,可以通过打开文件的方式来打开串口设备文件。
例如,可以使用`fopen(`函数打开串口设备文件:```FILE* serial_port = fopen("/dev/ttyS0", "w");if(serial_port == NULL)printf("Failed to open the serial port.\n");return -1;```然后,我们可以使用`fprintf(`函数将数据写入串口设备文件,实现数据的发送:```fprintf(serial_port, "Hello, RS232!\n");```数据的接收与数据的发送类似,也包括两个步骤:打开串口和接收数据。
我们仍然可以使用`fopen(`函数打开串口设备文件,并设置好相应的参数。
然后,可以使用`fgets(`函数从串口设备文件中读取数据:```char buffer[1024];fgets(buffer, sizeof(buffer), serial_port);printf("Received Data: %s", buffer);```需要注意的是,当数据到达串口时,我们需要设置好超时时间,以免数据接收阻塞程序执行。
在C语言中,可以通过设置串口设备文件的文件描述符来设置超时时间。
最后,我们需要在程序中循环调用数据发送和接收的函数,实现数据的循环传输。
c串口编程实例
![c串口编程实例](https://img.taocdn.com/s3/m/cd3e27295e0e7cd184254b35eefdc8d376ee143c.png)
c串口编程实例C串口编程实例C串口编程是指使用C语言进行串口通信的编程方法。
串口通信是指通过串行接口进行数据传输的方式,常用于计算机与外部设备之间的数据交互。
C串口编程可以实现计算机与外部设备的数据传输和控制,具有广泛的应用场景。
一、串口基础知识在进行C串口编程之前,首先需要了解一些串口的基础知识。
串口通信一般使用RS232C标准,其通信原理是通过发送和接收数据位来实现数据传输。
串口通信有多种参数需要设置,包括波特率、数据位、停止位、奇偶校验等。
在C串口编程中,需要根据具体的串口配置参数来进行编程。
二、C串口编程步骤1. 打开串口在C串口编程中,首先需要打开串口。
通过调用相关的函数,可以打开指定的串口,并获取串口的文件描述符。
2. 配置串口参数打开串口后,需要进行串口参数的配置。
通过调用相关的函数,可以设置串口的波特率、数据位、停止位、奇偶校验等参数。
3. 读取串口数据配置好串口参数后,就可以通过读取串口数据的方式来获取外部设备发送的数据。
通过调用相关的函数,可以从串口缓冲区中读取数据,并存储到指定的变量中。
4. 发送串口数据除了读取串口数据,C串口编程还可以实现发送数据到外部设备的功能。
通过调用相关的函数,可以将指定的数据发送到串口缓冲区,并通过串口发送给外部设备。
5. 关闭串口在C串口编程结束后,需要关闭串口。
通过调用相关的函数,可以关闭指定的串口,并释放相关资源。
三、C串口编程实例下面是一个简单的C串口编程实例,实现了从串口读取数据并将数据打印出来的功能:```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <fcntl.h>#include <termios.h>int main(){int fd;char buffer[255];// 打开串口fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY); if (fd == -1){perror("打开串口失败");exit(EXIT_FAILURE);}// 配置串口参数struct termios options;tcgetattr(fd, &options);cfsetispeed(&options, B9600);cfsetospeed(&options, B9600);options.c_cflag |= (CLOCAL | CREAD);options.c_cflag &= ~PARENB;options.c_cflag &= ~CSTOPB;options.c_cflag &= ~CSIZE;options.c_cflag |= CS8;tcsetattr(fd, TCSANOW, &options);// 读取串口数据并打印while (1){int count = read(fd, buffer, sizeof(buffer));if (count > 0){buffer[count] = '\0';printf("收到数据:%s\n", buffer);}}// 关闭串口close(fd);return 0;}```以上代码通过打开串口、配置串口参数、读取串口数据和关闭串口的方式实现了简单的C串口编程。
模拟串口的三种方法及C语言
![模拟串口的三种方法及C语言](https://img.taocdn.com/s3/m/766f25fcf021dd36a32d7375a417866fb84ac0de.png)
模拟串口的三种方法及C语言模拟串口是软件中模拟实现串口通信的一种方法,它是在电脑上通过软件模拟两个串口之间的传输,用来测试、调试串口相关的应用程序。
本文将介绍三种常见的模拟串口的方法,并提供C语言代码示例。
1.使用虚拟串口软件虚拟串口软件是一种用于模拟串口通信的应用程序。
它创建了虚拟的串口设备,使其在电脑上模拟出真实的串口通信环境。
通过虚拟串口软件,可以实现串口的模拟收发数据,可以连接到串口测试工具、串口调试工具或者自己编写的串口通信程序上。
以下是一个使用虚拟串口软件模拟串口通信的C语言代码示例:```c#include <stdio.h>#include <windows.h>int mai//打开虚拟串口//检测串口是否成功打开printf("Error in opening serial port\n");return 1;}//进行串口通信操作,如发送、接收数据//关闭串口return 0;```在这个示例中,我们使用了Windows操作系统的函数`CreateFile`来打开一个虚拟串口,这里的串口名称是"COM1"。
然后可以调用相关函数进行串口通信操作,最后用`CloseHandle`函数关闭串口。
2.使用串口驱动模拟在一些情况下,可以通过修改电脑的串口驱动程序来模拟串口通信。
这种方法需要更深入的了解操作系统的底层机制,并进行驱动程序的开发和修改。
通过修改串口驱动程序,可以模拟出一个虚拟的串口设备,通过这个设备进行串口通信。
以下是一个简单的C语言代码示例,用于修改串口驱动程序来模拟串口通信:```c#include <stdio.h>#include <fcntl.h>#include <unistd.h>int maiint fd;//打开串口设备fd = open("/dev/ttyS0", O_RDWR);//检测串口是否成功打开if (fd < 0)printf("Error in opening serial port\n");return 1;}//进行串口通信操作,如发送、接收数据//关闭串口设备close(fd);return 0;```在这个示例中,我们使用了Linux操作系统的函数`open`来打开一个串口设备,这里的设备名称是"/dev/ttyS0"。
c语言串口通信范例
![c语言串口通信范例](https://img.taocdn.com/s3/m/dd236852b52acfc788ebc932.png)
一个 c 语言的串口通信程序范例标签:分类:技术笔记c 语言串口通信通信程序it最近接触一个项目,用HL-C1C激光位移传感器+易控组态软件完成生产线高度跳变检测,好久没有接触 c c# ,一些资料,找来做个记录,也许大家用的着#include <stdio.h>#include <dos.h>#include <conio.h>#include <string.h>#define COM232 0x2f8#define COMINT 0x0b#define MaxBufLen 500#define Port8259 0x20#define EofInt 0x20static int comportaddr;static char intvectnum;static unsigned char maskb;static unsigned char Buffer[MaxBufLen];static int CharsInBuf,CircIn,CircOut;static void (interrupt far *OldAsyncInt)();static void interrupt far AsyncInt(void);void Init_COM(int ComPortAddr, unsigned char IntVectNum, int Baud,unsigned char Data, unsigned char Stop, unsigned char Parity) { unsigned char High,Low;int f;comportaddr=ComPortAddr;intvectnum=IntVectNum;Charsl nBuf=O;Circl n=0;CircOut=0;叮叮小文库f=(Baud/100);f=1152/f; High=f/256;Low=f-High*256;outp(ComPortAdd 叶3,0x80); outp(ComPortAddr,Low);outp(ComPortAdd r+1,High);Data=(Data-5)|((Stop-1)*4);if(Parity==2) Data=Data|0x18;else if(Parity==1) Data=Data|0x8;outp(ComPortAdd 叶3,Data);outp(ComPortAdd 叶4,0x0a);outp(ComPortAdd 叶1,0x01);disable();OldAs yncln t=getvect( In tVectNum );setvect( In tVectNum, Asynclnt );en able();maskb=i np(Port8259+1);if(I ntVectNum==0x0c)outp(Port8259+1,maskb&0 xef); elseoutp(Port8259+1,maskb&0 xf7);}static void in terrupt far Asyn cI nt(void){disable();if(CharsI nBufvMaxBufLe n)Buffer[CircI n]=i np(comportaddr);if(CircIn<MaxBufLen-1) CircIn++;else Circln=0;if(CircI n==CircOut) CircOut++;else Chars In Buf++;en able();outp(Port8259,Eofl nt);}void Restore(void)叮叮小文库{setvect(i ntvect num ,OldAs yncln t); outp(Port8259+1,maskb);}int GetCharI nBuf(u nsig ned char *Char){int Flag;Flag=-1;if(Charsl nBuf>0){(*Char)=Buffer[CircOut];if(CircOut<MaxBufLe n-1)CircOut++; else CircOut=0;CharsI nBuf--;Flag=0;}return Flag;}int Sen dChar( un sig ned char Char){if((inp(comportaddr+5)&0x20)==0) return -1; outp(comportaddr,Char);return 0;}mai n(){int i,c;un sig ned char In Char;In it_COM(COM232,COMINT,12OO,8,1,O);while(1){if(kbhit()){if((I nChar=getch())==27)break; else while(Se ndChar(I nChar));}if(GetCharl nBuf(&ln Char)==0)prin tf("%c",l nChar);}Restore。
VC实现串口通信项目源码
![VC实现串口通信项目源码](https://img.taocdn.com/s3/m/777a3244e97101f69e3143323968011ca300f7d2.png)
VC实现串口通信项目源码以下是一个简单的串口通信项目的VC实现源码,包括了串口初始化、发送数据、接收数据等基本功能。
```#include <Windows.h>#include <stdio.h>#define BUFFER_SIZE 1024HANDLE hSerial;//初始化串口参数BOOL InitSerialPort//打开串口hSerial = CreateFile("\\\\.\\COM1", GENERIC_READ ,GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);if (hSerial == INVALID_HANDLE_VALUE)printf("Failed to open serial port\n");return FALSE;}//配置串口参数DCB dcbSerialParams = { 0 };dcbSerialParams.DCBlength = sizeof(dcbSerialParams); printf("Failed to get serial port state\n"); CloseHandle(hSerial);return FALSE;}dcbSerialParams.BaudRate = CBR_9600; // 波特率为9600 dcbSerialParams.ByteSize = 8; // 8位数据位dcbSerialParams.Parity = NOPARITY; // 无奇偶校验dcbSerialParams.StopBits = ONESTOPBIT;// 1位停止位printf("Failed to set serial port state\n"); CloseHandle(hSerial);return FALSE;}//设置超时操作CloseHandle(hSerial);return FALSE;}return TRUE;//发送数据BOOL SendData(const char* data)DWORD bytesWritten;if (!WriteFile(hSerial, data, strlen(data), &bytesWritten, NULL))printf("Failed to send data\n");CloseHandle(hSerial);return FALSE;}return TRUE;//接收数据BOOL ReceiveData(char* buffer, DWORD size)DWORD bytesRead;if (!ReadFile(hSerial, buffer, size, &bytesRead, NULL))printf("Failed to receive data\n");CloseHandle(hSerial);return FALSE;}return TRUE;if (!InitSerialPort()return 1;}char sendBuffer[BUFFER_SIZE];char receiveBuffer[BUFFER_SIZE];//发送数据printf("Enter data to send: ");gets_s(sendBuffer, BUFFER_SIZE);if (!SendData(sendBuffer))return 1;}//接收数据printf("Receiving data...\n");if (!ReceiveData(receiveBuffer, BUFFER_SIZE)) return 1;}printf("Received data: %s\n", receiveBuffer); CloseHandle(hSerial);```这个项目使用了Windows的串口通信API函数来实现串口的初始化、发送数据和接收数据操作。
C语言实现串口通信
![C语言实现串口通信](https://img.taocdn.com/s3/m/e12ce03000f69e3143323968011ca300a6c3f63d.png)
C语言实现串口通信串口通信是一种常见的数据传输方式,用于在计算机和外部设备之间传递数据。
C语言提供了丰富的库函数和操作符,可以方便地实现串口通信。
本文将介绍C语言实现串口通信的基本原理和步骤。
首先,需要了解串口通信的基本概念。
串口是计算机与外部设备之间进行数据传输的接口,它包括发送和接收两根数据线。
串口通信的数据传输是通过串口的发送和接收缓冲区来完成的。
数据从发送缓冲区发送到外部设备,外部设备将数据发送到接收缓冲区,计算机通过读取接收缓冲区来获取数据。
在C语言中实现串口通信需要使用操作系统提供的串口API,这些API包含了一系列函数用于打开串口、配置串口参数、发送和接收数据等操作。
常见的串口API包括Windows的WinAPI、Linux的termios等。
首先,需要打开串口。
在Windows下,可以使用CreateFile函数打开串口设备文件,并返回一个句柄用于后续操作。
在Linux下,可以使用open函数打开串口设备文件,并返回一个文件描述符。
然后,可以使用串口的发送函数发送数据。
发送函数通常传入一个缓冲区和数据长度作为参数,将数据发送到串口发送缓冲区。
在Windows下,可以使用WriteFile函数发送数据。
在Linux下,可以使用write函数发送数据。
最后,可以使用串口的接收函数接收数据。
接收函数通常传入一个缓冲区和数据长度作为参数,将串口接收缓冲区的数据读取到缓冲区中。
在Windows下,可以使用ReadFile函数接收数据。
在Linux下,可以使用read函数接收数据。
值得注意的是,在实际的串口通信过程中,还需要处理异常情况,如超时、错误校验等。
可以使用循环和条件语句结合错误处理函数来处理这些异常情况,以确保数据的可靠传输。
综上所述,C语言实现串口通信需要使用操作系统提供的串口API,并按照一定的步骤进行配置和操作。
通过了解串口通信的基本原理和API 函数的使用,可以实现稳定、可靠的串口通信功能。
c语言怎么写串口通信编程
![c语言怎么写串口通信编程](https://img.taocdn.com/s3/m/ecd6c3d5dbef5ef7ba0d4a7302768e9951e76e3a.png)
c语言怎么写串口通信编程串口通信是一种广泛应用于嵌入式系统和电子设备之间的通信方式。
无论是嵌入式开发还是电子设备控制,串口通信都是常见的需求。
在C语言中,实现串口通信需要通过操作串口的硬件寄存器和使用相应的通信协议来实现数据的发送和接收。
本文将一步一步介绍如何使用C语言编写串口通信程序。
第一步:打开串口要开始串口通信,首先需要打开串口。
在C语言中,可以使用文件操作函数来打开串口设备。
通常,串口设备被命名为/dev/ttyS0,/dev/ttyS1等,具体名称取决于系统。
下面是一个打开串口设备的示例代码:cinclude <stdio.h>include <fcntl.h>include <termios.h>int open_serial_port(const char *port) {int fd = open(port, O_RDWR O_NOCTTYO_NDELAY);if (fd == -1) {perror("open_serial_port");return -1;}设置串口属性struct termios options;tcgetattr(fd, &options);cfmakeraw(&options);cfsetspeed(&options, B9600);tcsetattr(fd, TCSANOW, &options);return fd;}int main() {const char *port = "/dev/ttyS0";int fd = open_serial_port(port);if (fd == -1) {打开串口失败,处理错误return -1;}串口已打开,可以进行数据的读写操作return 0;}在上面的代码中,open_serial_port函数用于打开指定的串口设备并进行一些必要的设置。
c调用串口
![c调用串口](https://img.taocdn.com/s3/m/471cce0a777f5acfa1c7aa00b52acfc789eb9f1e.png)
c调用串口在C语言中,可以使用串口通信库来访问串口。
以下是一个简单的C程序,它使用串口通信库来打开串口,发送数据,然后读取串口返回的数据。
```c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <fcntl.h>#include <termios.h>int main() {int fd;struct termios options;char buffer[256];int n;// 打开串口设备文件fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);if (fd == -1) {perror("open");exit(1);}// 配置串口选项tcgetattr(fd, &options);cfsetispeed(&options, B9600);cfsetospeed(&options, B9600);options.c_cflag |= CLOCAL;options.c_cflag &= ~CSIZE;options.c_cflag |= CS8;options.c_cflag &= ~PARENB;options.c_cflag &= ~CSTOPB;options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); options.c_iflag &= ~(IXON | IXOFF | IXANY); options.c_oflag &= ~OPOST;tcsetattr(fd, TCSANOW, &options);// 发送数据strcpy(buffer, "Hello, world!\n");n = write(fd, buffer, strlen(buffer));if (n < 0) {perror("write");exit(1);}// 读取数据memset(buffer, 0, sizeof(buffer));n = read(fd, buffer, sizeof(buffer));if (n < 0) {perror("read");exit(1);} else if (n == 0) {printf("No data received.\n");exit(1);} else {buffer[n] = '\0';printf("Received: %s\n", buffer);}// 关闭串口设备文件close(fd);return 0;}```这个程序打开名为`/dev/ttyS0`的串口设备文件,配置串口选项为9600波特率、8位数据、无校验位、1位停止位,然后发送一个字符串"Hello, world!\n",并读取串口返回的数据。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、引言:
现在在工业现场很少有人再用C语言做串口通讯程序了,但是基于DOS环境的程序还是有它的优势的。
DOS系统的单任务环境是系统运行更加稳定、可靠;在一些追求很高的可靠性的系统中还是有一定的价值的。
本文通过C语言控制PLC实现简单的物料传送为例子。
二、硬件介绍:
1、CPM1A采用RS232串口通讯与上位机连接,在PLC的DM区中可以设定串口参数,本文采用默认值:
串口通信格式:
1位---起始位、9600---波特率、7位---数据位、2位---停止位、偶校验
2、C语言中用于串口读写的函数:bioscom,在bios.h头文件中。
Bioscom用法:bioscom(int cmd,char byte,int port)
Cmd的值:0 设置通信参数为btye值
1 发送一个字符到串口
2 从串口接收一个字符
3 返回串口端口的状态
byte的值:0x02 7数据位0x03 8位数据位
0x00 1个停止位0x04 2个停止位
0x00 无奇偶校验0x08奇校验
0x18偶校验0x80 1200波特率
0xA0 2400波特率0xC0 4800波特率
0xE0 9600波特率
注意:在对串口初始化时,上述参数值相或附给byte。
Port的值:0 端口1
1 端口2
三、完整源代码:
#include /* 此头函数请不要删除*/
#include
#include
#define F1 0x3B /*启动*/
#define F2 0x3C /*停止*/
#define F3 0x3D /*混料*/
#define F4 0x3E /*出料*/
#define F5 0x3F /*退出*/
#define PORT 0 /*定义端口号*/
#define SETTINGS (0x02|0x04|0x18|0xE0) /*设定参数*/
/* 定义发送字符函数send */
void sendPort(int port,char cc)
{
union{
char ch[2];
int status;
}port_status;
/*发送一个字符*/
port_status.status=bioscom(1,cc,port);
printf("%c",cc); /*判断发送是否正确*/
if(port_status.ch[1]&128)
{printf("Send data error detected in serial port"); printf("\r");
}
}
/* Check-Status 检查端口*/
int check_status(int port)
{
int status;
status=bioscom(3,0,port);
if(status & 0x100)return 0;
else return 1;
}
/*发送命令函数*/
void SendOder(char od[])
{
int i=0;
for(i=0;i<=16;i++)
sendPort(PORT,od[i]);
}
/*应用程序主体*/
main()
{
int key=1,i,m=1;
int check=1;
char a[20]="@00WR0000000144*"; /*启动00*/ char b[20]="@00WR0000000441*"; /*混料02*/ char c[20]="@00WR000000084D*"; /*出料03*/ char d[20]="@00WR0000000247*"; /*停止01*/ a[16]='\r';
b[16]='\r';
c[16]='\r';
d[16]='\r';
printf("启动:F1 \t混料:F2 \t出料:F3");
printf(" \t停止:F4 \t退出:F5\n");
bioscom(0,SETTINGS,PORT); /*初始化串口*/ while(check!=0) /*检查端口状态*/
{
m+=1;
check=check_status(PORT);
if(m>=1000)break;
}
while (1)
{
while (bioskey(1)==0);
key=bioskey(0);
key=key&0xFF?0:key>>8;
if(key==F1) /*启动命令*/
{
for(i=0;i<=16;i++)
{
sendPort(PORT,a[i]);
m=1;
while(check!=0)
{
m+=1;
check=check_status(PORT); /*检查端口状态*/ if(m>=3000)break;
}
}
}
else if(key==F4) /*停止命令*/
{
for(i=0;i<=16;i++)
{
sendPort(PORT,d[i]);
m=1;
while(check!=0)
{
m+=1;
check=check_status(PORT);
if(m>=3000)break;
}
}
}
else if(key==F2) /*混料命令*/
{
for(i=0;i<=16;i++)
{
sendPort(PORT,b[i]);
m=1;
while(check!=0)
{
m+=1;
check=check_status(PORT);
if(m>=3000)break;
}
}
}
else if(key==F3) /*出料命令*/
{
for(i=0;i<=16;i++)
{
sendPort(PORT,c[i]);
m=1;
while(check!=0)
{
m+=1;
check=check_status(PORT);
if(m>=3000)break;
}
}
}
else if(key==F5)exit(1); /*退出命令*/
}
getch(); /* 此语句请不要删除*/
}
四、结束语
RS232串口通讯在小型的控制系统同中还是应用广泛的,本文采用C语言控制,主要是给用户提供一个新的控制方式做选择。