串口实时输出文件命令

Ⅰ 如何用cmd窗口（或者批处理.bat文件）向串口（serial port）发送数据

1、首先选择对应的por选择匹配的baud rat，输入输出应该可以实现了。

Ⅱ vmware虚拟机如何使用串口

如何开启VMware串口
先前在玩GEC2410时，有个想法，就是在linux下进行调试，由于目标板上电或复位时会发送信息给PC机的串口，这已在windows下实现过，于是想在linux下看看效果，可是当时我在linux下设好串口后，发现一点反应都没有，当时以为是自己没有安装交叉编译环境，于是昨天晚上把嵌入式 linux下的交叉编译环境装好后，心想这下应该可以拉，没想到我上电目标板，linux下的串口一直没有反应，郁闷，怎么这样呢，既然不适交叉编译环境的原因，总得有个原因吧，于是我上网搜，先前我也够笨的，怎么就不知道上网查呢，呵呵，原来是我没有把VMware的串口打开，呵呵，马上关机[关虚拟机下的系统]，在VM->Setting......->点击ADD，把串口加进来，呵呵设置时尽量不要用自动检测，要选中串口，反正即使你的虚拟系统启动后可以随便改的，同时要把串口设为启动时就连接拉，这样，linux下的串口在目标板上电或复位后收到和windows下一样的数据，哈哈，爽！

环境：

宿主机：Windows7 VMware7.1

虚拟机：Fedora12

VMware的串口：

一个虚拟机最多可以添加四个虚拟串口，有如下几个方法配置虚拟串口：

连接一个虚拟串口到宿主机的物理串口。

连接一个虚拟串口到宿主机上的一个文件。

在两个虚拟机之间建立一个直接的连接，或者将虚拟机的串口与宿主机的应用程序连接。

为虚拟机添加串口

首先要保证虚拟机处于关机（power off)状态，选择菜单中的VM -> Settings... ，在Hardware标签页中点击Add按钮，在Add Hardware Wizard对话框中选择Serial Port，点击next，如图：

然后要选择Serial port type，共有三种类型：

1.如果你要使用宿主机的物理串口设备，选择Use physical serial port on the host，然后点击next，选择你要使用的物理串口即可。

2.如果想要将串口数据输出到一个文件，选择 Output to file，然后next，选择输出文件，该文件是一个txt文本文件。启动虚拟机后做个测试，在命令行中执行:

echo "asdf" >> /dev/ttyS0,

然后打开输出文件，即可看到串口输出的字符串asdf。

3.使用named pipe可以实现两个虚拟机或虚拟机与宿主机的应用程序通过串口连接。选择Output to named pipe，点击next，进入如下界面：

输入管道名，对于windows宿主机，管道名格式为 //./pipe/ ，必须以 //./pipe/开头。

输出调试信息到宿主机上的应用程序：

第一个下拉菜单选择This end is the server或This end isthe client，在第二个下拉菜单选择The other end is an application。

输出调试信息到另一个虚拟机：

第一个下拉菜单选择This end is the server，第二个下拉菜单选择The other end is an application。

将两个虚拟机用串口连接:

在虚拟机上安装Fedora12和ubuntu10.04，为两个虚拟机添加串口，

Fedora12的串口设置为：

Ubuntu10.04的串口设置为：

这样设置后Fedora的串口为serial port 1，设备名为ttyS0，ubuntu的串口为serial port 2，设备名为ttyS1。

测试：

在Fedora下执行：

cat < /dev/ttyS0

在ubuntu下执行：

echo hello > /dev/ttyS1

在Fedora里可以看到收到的字符串hello，说明ubuntu发送和Fedora接收正常，可以互换后做同样的测试。

语 法
statserial[必要参数][设备]

功 能
statserial 命令：显示各个接脚的状态，常用来判断串口是否正常，Ctrl+C退出
类似命令: stat

相似命令: linux命令

执行权限: 超级用户 普通用户

命令属性: 网络通讯

参数

必要参数
-n 不循环显示
-d 十进制显示
-x 十六进制显示

选择参数

无

范例

范例1：显示串口状态

[root@linux ~]# statserial /dev/tty1

范例2：只显示一次串口状态

[root@linux ~]# statserial -n /dev/tty1

Ⅲ CMD怎么将带有>的命令输出到串口里

使用转义符（^），对命令行中的特殊字符进行转义。
比如
^>
^&
这样即可把>或&当成普通字符来看待，而不是特殊字符。但在命令行中%是一个特殊的存在，它要变成普通字符，不能用^进行转义，而是用%自身来转义，比如输出一个%，那么就写成%%

Ⅳ 关于串口通讯

利用串口进行数据通讯在通讯领域重占有着重要的地位。利用RS232-RS485进行数据信号的采集和传递是VC编程的又一大热点。串口通讯在通讯软件重有着十分广泛的应用。如电话、传真、视频和各种控制等。在各种开发工具中间，VC由于功能强大和灵活，同时也得到了Microsoft的最大支持，所以在一般进行涉及硬件操作的通讯编程中，大都推荐使用VC作为开发工具。然而工业控制串口通讯这个又不同于一般的串口通讯程序，因为控制外围设备传送的大都是十六进制数据（BYTE类型），所以，为了提高程序的运行稳定性，我们在编写程序进行通讯时可以不考虑传送BYTE类型数据的工作。
串口通讯目前流行的方法大概有两种：一是利用Microsoft提供的CMSCOMM控件进行通讯，不过现在很多程序员都觉应该放弃这种方式。二是利用WINAPI函数进行编程，这种编程的难度最高，要求你要掌握很多的API函数。三是利用现在网络上面提供的一些串口通讯控件进行编写，比如CSerial类等。

程序实现：
我在经过许多的项目的开发和实践中发现，采用WIN API函数进行串口的开发能够给程序员很大的控件，并且程序运也很稳定。所以我将与串口接触的函数进行封装，然后在各个工程中进行调用，效果还是比较好的，现将各个函数和调用方法列举出来，希望对各位有所帮助。
一、设置串口相关工作

#define MAXBLOCK 2048
#define XON 0x11
#define XOFF 0x13
BOOL SetCom(HANDLE &m_hCom, const char *m_sPort, int BaudRate, int Databit, CString parity, CString stopbit)
{
COMMTIMEOUTS TimeOuts; ///串口输出时间 超时设置
DCB dcb; ///与端口匹配的设备
m_hCom=CreateFile(m_sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL); // 以重叠方式打开串口
if(m_hCom==INVALID_HANDLE_VALUE)
{
AfxMessageBox("设置串口部分，串口打开失败"); /////重叠方式 异步通信（INVALID_HANDLE_VALUE）函数失败。
return FALSE;
}
SetupComm(m_hCom,MAXBLOCK,MAXBLOCK); //设置缓冲区
memset(&TimeOuts,0,sizeof(TimeOuts));
TimeOuts.ReadIntervalTimeout=MAXDWORD; // 把间隔超时设为最大，把总超时设为0将导致ReadFile立即返回并完成操作
TimeOuts.ReadTotalTimeoutMultiplier=0; //读时间系数
TimeOuts.ReadTotalTimeoutConstant=0; //读时间常量
TimeOuts.WriteTotalTimeoutMultiplier=50; //总超时=时间系数*要求读/写的字符数+时间常量
TimeOuts.WriteTotalTimeoutConstant=2000; //设置写超时以指定WriteComm成员函数中的
SetCommTimeouts(m_hCom, &TimeOuts); //GetOverlappedResult函数的等待时间*/
if(!GetCommState(m_hCom, &dcb)) ////串口打开方式、端口、波特率 与端口匹配的设备
{
AfxMessageBox("GetCommState Failed");
return FALSE;
}

dcb.fParity=TRUE; //允许奇偶校验
dcb.fBinary=TRUE;
if(parity=="NONE")
dcb.Parity=NOPARITY;
if(parity=="ODD")
dcb.Parity=ODDPARITY;
if(parity=="EVEN")
dcb.Parity=EVENPARITY;
if(stopbit=="1")//设置波特率
dcb.StopBits=ONESTOPBIT;
//if(stopbit=="0")//设置波特率
// dcb.StopBits=NONESTOPBIT;
if(stopbit=="2")//设置波特率
dcb.StopBits=TWOSTOPBITS;
BOOL m_bEcho=FALSE; ///
int m_nFlowCtrl=0;
BOOL m_bNewLine=FALSE; ///
dcb.BaudRate=BaudRate; // 波特率
dcb.ByteSize=Databit; // 每字节位数
// 硬件流控制设置
dcb.fOutxCtsFlow=m_nFlowCtrl==1;
dcb.fRtsControl=m_nFlowCtrl==1 ?RTS_CONTROL_HANDSHAKE:RTS_CONTROL_ENABLE;
// XON/XOFF流控制设置（软件流控制！）
dcb.fInX=dcb.fOutX=m_nFlowCtrl==2;
dcb.XonChar=XON;
dcb.XoffChar=XOFF;
dcb.XonLim=50;
dcb.XoffLim=50;
if(SetCommState(m_hCom, &dcb))
return TRUE; ////com的通讯口设置
else
{
AfxMessageBox("串口已打开，设置失败");
return FALSE;
}
}

二、读串口操作：
int ReadCom(HANDLE hComm, BYTE inbuff[], DWORD &nBytesRead, int ReadTime)
{
DWORD lrc; ///纵向冗余校验
DWORD endtime; /////////jiesuo
static OVERLAPPED ol;
int ReadNumber=0;
int numCount=0 ; //控制读取的数目
DWORD dwErrorMask,nToRead;
COMSTAT comstat;
ol.Offset=0; ///相对文件开始的字节偏移量
ol.OffsetHigh=0; ///开始传送数据的字节偏移量的高位字，管道和通信时调用进程可忽略。
ol.hEvent=NULL; ///标识事件，数据传送完成时设为信号状态
ol.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
endtime=GetTickCount()+ReadTime;//GetTickCount()取回系统开始至此所用的时间(毫秒)
for(int i=0;i<2000;i++)
inbuff[i]=0;
Sleep(ReadTime);
ClearCommError(hComm,&dwErrorMask,&comstat);
nToRead=min(2000,comstat.cbInQue);
if(int(nToRead)<2)
goto Loop;
if(!ReadFile(hComm,inbuff,nToRead,&nBytesRead,&ol))
{
if((lrc=GetLastError())==ERROR_IO_PENDING)
{
///////////////////
endtime=GetTickCount()+ReadTime;//GetTickCount()取回系统开始至此所用的时间(毫秒)
while(!GetOverlappedResult(hComm,&ol,&nBytesRead,FALSE))//该函数取回重叠操作的结果
{
if(GetTickCount()>endtime)
break;
}
}
}
return 1;
Loop: return 0;
}

三、写串口命令
int WriteCom(HANDLE hComm, BYTE Outbuff[], int size, int bWrite[])
{
DWORD nBytesWrite,endtime,lrc;
static OVERLAPPED ol;
DWORD dwErrorMask,dwError;
COMSTAT comstat;
ol.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
ol.Offset=0;
ol.OffsetHigh=0;
ol.hEvent=NULL; ///标识事件，数据传送完成时，将它设为信号状态
ClearCommError(hComm,&dwErrorMask,&comstat);
if(!WriteFile(hComm,Outbuff,size,&nBytesWrite,&ol))
{
if((lrc=GetLastError())==ERROR_IO_PENDING)
{
endtime=GetTickCount()+1000;
while(!GetOverlappedResult(hComm,&ol,&nBytesWrite,FALSE))
{
dwError=GetLastError();
if(GetTickCount()>endtime)
{
AfxMessageBox("写串口时间过长，目前串口发送缓冲区中的数据数目为空");
break;
}
if(dwError=ERROR_IO_INCOMPLETE)
continue; //未完全读完时的正常返回结果
else
{
// 发生错误，尝试恢复！
ClearCommError(hComm,&dwError,&comstat);
break;
}
}
}
}
FlushFileBuffers(hComm);
PurgeComm(hComm,PURGE_TXCLEAR);
bWrite=0;
return 1;
}

四、调用方法很简单，只需要将你的串口参数进行简单的设置就可以了。比如:
BOOL Main_OpenCom()//设置COM
{
int Boundrate=9600;//波特率
CString StopBits="1";//停止位
int DataBits=8;//数据位
CString Parity="ODD";//奇偶校验
CString m_Port="COM1";
return SetCom(m_hCom1,m_Port,Boundrate,DataBits,Parity,StopBits);
}

void Main()
{
int SIZE;
DWORD BytestoRead=52*Count+6;//要11个字节
int BWRITE[2];
int ReadTime=2000;
BYTE Outbuff[12]={0xff,0x00,0xea,0xff,0xea,0xff,0,0,0,0,0,0};
SIZE=sizeof(Outbuff);
WriteCom(m_hCom,Outbuff,SIZE,BWRITE);
ReadCom(m_hCom,m_Inbuff,BytestoRead,ReadTime);
//进行湘阴的解包处理
}

Ⅳ 易语言,怎样用串口命令,请说得详细点!谢谢!!

详细点也就是
串口.启动.
串口.发送数据({1,2,3})

串口收到数据并进行响应即可,,,主要是看你的串口协议是怎么样的,这里就怎么发送数据就好了...

Ⅵ 如何通过串口把一个程序发给linux

使用串口协议登录Linux终端控制台，通过Zmodem文件传输协议接收一个外部文件。
命令：rz -y会弹出文件浏览窗口，选择要上传的文件即可。
-y
表示若文件已存在，则覆盖。

Ⅶ 怎样在串口打开时自动发送几个命令

你好！
可以采用定时器，一直判断串口是不是打开！
如果串口打开，就发送数据！

Ⅷ 使用VB，串口发送大文件，串口设置怎么写

建议使用 二进制读取文件的方式发送。
Open "TESTFILE" For Binary Access Write As #1

Close #1

在二进制访问模式中，可以把文件指针移到文件的任何地方。文件刚被打开时，文件指针指向第一个字节，以后将随着文件处理命令的执行而移动。

收到 # 你就继续读取文件发送，收到!你就停止读取。如此循环，直到文件结束，
判断文件结束的命令为 eof(#1)=true

我只能告诉你这个方法，具体代码自己写吧。
照抄别人的代码不如自己写的代码学到东西的东西多。

Ⅸ 蓝牙串口助手使用方法

蓝牙串口助手是一款基于RFCOMM蓝牙串口服务的传输软件，通过该软件可以连接蓝牙串口模块进行通信，实现手机串口连接。类似计算机的串口助手，是电子工程师的开发利器

（1）实时模式：基本输入输出。发送字符串实时获取信息

（2）键盘模式：可以自定义9个按钮名称和内容，实现点击按钮即可发送相应内容

（3）命令行模式：可设定命令结束符，用于通信调试。

（1）发现和连接蓝牙串口模块

（2）接收和发送数据

（3）可选择ASCII码显示或者是HEX十六进制显示

（5）发送十六进制数据

（6）将串口接收到的数据保存成txt文件

Ⅹ 在linux系统下怎么读取串口服务器的实时数据

Linux串口读写：
#include <stdio.h> /*标准输入输出定义*/
#include <stdlib.h> /*标准函数库定义*/
#include <unistd.h> /*Unix 标准函数定义*/
#include <sys/types.h>
#include <sys/stat.h>
#include "string.h"
#include <fcntl.h> /*文件控制定义*/
#include <termios.h> /*PPSIX 终端控制定义*/
#include <errno.h> /*错误号定义*/

#define FALSE -1
#define TRUE 0

/*********************************************************************/
int OpenDev(char *Dev)
{
int fd = open( Dev, O_RDWR | O_NOCTTY ); //| O_NOCTTY | O_NDELAY
if (-1 == fd)
{
perror("Can't Open Serial Port");
return -1;
}
else
return fd;
}

/**
*@brief 设置串口通信速率
*@param fd 类型 int 打开串口的文件句柄
*@param speed 类型 int 串口速度
*@return void
*/
int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,
B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {38400, 19200, 9600, 4800, 2400, 1200, 300, 38400,
19200, 9600, 4800, 2400, 1200, 300, };
void set_speed(int fd, int speed)
{
int i;
int status;
struct termios Opt;
tcgetattr(fd, &Opt);
for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++) {
if (speed == name_arr[i]) {
tcflush(fd, TCIOFLUSH);
cfsetispeed(&Opt, speed_arr[i]);
cfsetospeed(&Opt, speed_arr[i]);
status = tcsetattr(fd, TCSANOW, &Opt);
if (status != 0) {
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
}
}

/**
*@brief 设置串口数据位，停止位和效验位
*@param fd 类型 int 打开的串口文件句柄
*@param databits 类型 int 数据位 取值 为 7 或者8
*@param stopbits 类型 int 停止位 取值为 1 或者2
*@param parity 类型 int 效验类型 取值为N,E,O,,S
*/
int set_Parity(int fd,int databits,int stopbits,int parity)
{
struct termios options;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*Input*/
options.c_oflag &= ~OPOST; /*Output*/
if ( tcgetattr( fd,&options) != 0) {
perror("SetupSerial 1");
return(FALSE);
}
options.c_cflag &= ~CSIZE;
switch (databits) /*设置数据位数*/
{
case 7:
options.c_cflag |= CS7;
break;
case 8:
options.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data size/n"); return (FALSE);
}
switch (parity)
{
case 'n':
case 'N':
options.c_cflag &= ~PARENB; /* Clear parity enable */
options.c_iflag &= ~INPCK; /* Enable parity checking */
break;
case 'o':
case 'O':
options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'e':
case 'E':
options.c_cflag |= PARENB; /* Enable parity */
options.c_cflag &= ~PARODD; /* 转换为偶效验*/
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'S':
case 's': /*as no parity*/
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;break;
default:
fprintf(stderr,"Unsupported parity/n");
return (FALSE);
}
/* 设置停止位*/
switch (stopbits)
{
case 1:
options.c_cflag &= ~CSTOPB;
break;
case 2:
options.c_cflag |= CSTOPB;
break;
default:
fprintf(stderr,"Unsupported stop bits/n");
return (FALSE);
}
/* Set input parity option */
if (parity != 'n')
options.c_iflag |= INPCK;
tcflush(fd,TCIFLUSH);
options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/
options.c_cc[VMIN] = 0; /* Update the options and do it NOW */
if (tcsetattr(fd,TCSANOW,&options) != 0)
{
perror("SetupSerial 3");
return (FALSE);
}
return (TRUE);
}

int main(int argc, char **argv)
{

int fd;
int nread;
char buff[512];
char *dev = "/dev/ttyS0"; //串口二
fd = OpenDev(dev);
set_speed(fd,4800);
if (set_Parity(fd,8,1,'N') == FALSE)
{
printf("Set Parity Error/n");
exit (0);
}
int i;
i = getchar();
if ( i == '1')
{
while (1) //循环读取数据
{
while((nread = read(fd, buff, 512))>0)
{
printf("/nLen %d/n",nread);
buff[nread+1] = '/0';
printf( "/n%s", buff);
}
}
}
if ( i == '2')
{
while (1) //循环写入数据
{

gets(buff);

printf("------buff--->%s<--------/n",buff);
int num = strlen(buff);
printf("--------num---->%d<--------------/n",num);
if ( num > 0)
{
printf("Wirte num not NULL./r/n");
nread = write(fd, buff ,num);
if(nread == -1)
{
printf("Wirte sbuf error./n");
}
printf("--nread---->%d<-----------/n",nread);
}

}
}
close(fd);
//exit (0);
}