上位机软件流程图 写上位机程序要学习哪些编程软件

上位机程序要学习哪些编程软件

既然是上位机编程，当然应该是与控制有关，还有下位机，所以这个编程用到的软件主要应该有：

1、C语言，这是基本的上位机语言，特别在以前的DOS时代，用的十分普遍

2、C++，这是目前用的很多的编程语言，VC，MFC等都属于这个范畴

3、VB，这个语言现在应用也很广泛，由于可视化编程，入门较容易，很多人在使用

上位机应用程序，原理图和PCB的设计。

/*测试的时候是在idleapp.c中测试的，在函数IdleSetLRKey中通过SetKeyHandler(start_uart_echo, KEY_LEFT_ARROW,KEY_EVENT_UP);来启动串口，然后就可以在上位机中通过串口调试助手发送指令操作MTK手机了*/

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "stdC.h"

#include "MMI_Features.h" /* 编译开关会出现在这个由make update生成的文件里面 */

#include "L4Dr.h"

#include "L4Dr1.h"

#include "AllAppGprot.h"

#include "FrameworkStruct.h"

#include "GlobalConstants.h"

#include "EventsGprot.h"

#include "mmiappfnptrs.h"

#include "HistoryGprot.h"

#include "MainMenuDef.h"

#include "wgui_categories.h"

#include "Unicodexdcl.h"

#include "gui_data_types.h"

#include "Uart_sw.h"

#include "SettingProfile.h"

// 我们要用到的串口, uart_port1是枚举型数值，usb串口的编号

#define HELLO_WORLD_UART_PORT uart_port1 // 手机接USB下载线的地方

// 定义我们的应用所属系统的哪一个模块

// 这里是MMI模块，实际上我更愿意称MMI为一个子系统，将我们的应用称为模块

#define MOD_HELLO_WORLD MOD_MMI

// 数据接收Buffer大小

#define MAX_ECHO_PACKET_LEN 128

// 外部函数申明，没有对应头文件，手动加吧

extern module_type UART_GetOwnerID(UART_PORT port);

extern void UART_ClrTxBuffer(UART_PORT port, module_type ownerid);

extern void UART_ClrRxBuffer(UART_PORT port, module_type ownerid);

extern void playRequestedTone(ALL_TONE_ENUM playtone);

// 本程序内部使用的函数申明

static void init_uart(void);

static void mmi_HelloWorld_uart_readyToRead_ind_handler(void *msg);

static U16 read_from_uart(U8 *pbyBuf, U16 wLenMax, UART_PORT hPort, module_type hOwner);

static U8 write_to_uart(U8 *pbyBuf, U16 wLenBuf, UART_PORT hPort, module_type hOwner);

static void exit_uart();

static void start_uart_echo(void);

static void uart_echo_process(void);

static void stop_uart_echo(void);

// 睡眠模式句柄

static kal_uint8 ghSleepMode;

// 我们要用到的串口之前的占用者

static module_type gnOrigUartOwner;

static kal_bool gbUartInitialized = KAL_FALSE;

static kal_bool gbUartEchoStarted = KAL_FALSE;

static U16 gwLenUartBuffer = 0;

static U8 gabyUartBuffer[MAX_ECHO_PACKET_LEN];

static void init_uart(void)

{

if(gbUartInitialized)

{

return;

}

ghSleepMode = L1SM_GetHandle();

// 禁止休眠，休眠后串口收发会有问题

// 问题：如何做到串口唤醒？ FIXME

L1SM_SleepDisable(ghSleepMode);

// 记录我们要用的串口的当前占有者

gnOrigUartOwner = UART_GetOwnerID(HELLO_WORLD_UART_PORT);

// 下面我们申明要占用这个串口了

UART_SetOwner(HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

// 以上对串口占用的申明，我理解更多是一种编程者之间的约定

// 当发现串口的占用者不是本程序所属模块时，说明我们申明占用之后

// 又有其他模块申明占用同一个串口，此时如果收到数据应不予处理

// 当然，也有可能同一模块的其他程序申明占用同一串口

// 这需要在设计应用时统一协调，避免数据发生混乱

// 设置波特率，缺省的起停位和校验为:8,n,1，即8个数据位，1个停止位，无校验

UART_SetBaudRate(HELLO_WORLD_UART_PORT, UART_BAUD_115200, MOD_HELLO_WORLD);

// 其他串口设定(如起停位、校验等)使用函数 UART_ReadDCBConfig 和 UART_SetDCBConfig

// 详细参数见结构体 UARTDCBStruct

// 注册一个事件钩子函数，当串口(任何)有数据到达时，我们的钩子函数将被调用

// 注意，同一种事件同时只能注册一个钩子函数，因此：

// 如果在我们的程序处理串口的同时还有其他程序要读取和处理(任何)串口数据，

// 就必须由当前的钩子函数代为处理

// 实际上我觉得系统底层可以改一下，改成Windows钩子的方式，可以挂多个，能够依次调用或跳过

SetProtocolEventHandler(mmi_HelloWorld_uart_readyToRead_ind_handler, MSG_ID_UART_READY_TO_READ_IND);

gbUartInitialized = KAL_TRUE;

}

static U16 read_from_uart(U8 *pbyBuf, U16 wLenMax, UART_PORT hPort, module_type hOwner)

{

U16 wLenAvail;

U16 wLenRead;

U16 wLenRet = 0;

U8 byStatus = 0;

// 收取数据，超出最大包长的数据将简单丢弃，这一层需要具体的应用协议做相应处理

while( (wLenAvail = UART_GetBytesAvail(hPort) > 0 && wLenRet < wLenMax) )

{

if (wLenAvail + wLenRet > wLenMax)

{

wLenAvail = wLenMax - wLenRet;

}

wLenRead = UART_GetBytes(hPort, (kal_uint8 *)(pbyBuf + wLenRet), (kal_uint16)wLenAvail, &byStatus, hOwner);

wLenRet += wLenRead;

}

// 读完之后，清除接收Buffer

UART_ClrRxBuffer(hPort, hOwner);

return wLenRet;

}

static U8 write_to_uart(U8 *pbyBuf, U16 wLenBuf, UART_PORT hPort, module_type hOwner)

{

U16 wSent= 0;

U8 bRet = FALSE;

// 发送前清FIFO和Buffer，注意：这一步必须做，否则收发会有问题

UART_Purge(hPort, RX_BUF, hOwner); // 清除设备输入FIFO

UART_Purge(hPort, TX_BUF, hOwner); // 清除设备输出FIFO

UART_ClrTxBuffer(hPort, hOwner); // 清除发送Buffer

UART_ClrRxBuffer(hPort, hOwner); // 清除接收Buffer

wSent = UART_PutBytes(hPort, (kal_uint8 *)pbyBuf, (kal_uint16)wLenBuf, hOwner);

if (wSent == wLenBuf)

{

bRet = TRUE;

}

return bRet ;

}

static void exit_uart()

{

if(gbUartInitialized)

{

// 恢复成原有的端口占用者

UART_SetOwner(HELLO_WORLD_UART_PORT, (kal_uint8) gnOrigUartOwner);

// 允许休眠

L1SM_SleepEnable(ghSleepMode);

gbUartInitialized = KAL_FALSE;

}

}

static void mmi_HelloWorld_uart_readyToRead_ind_handler(void *msg)

{

uart_ready_to_read_ind_struct* uart_rtr_ind = (uart_ready_to_read_ind_struct*)msg;

// 检查一下端口以及所有者信息，不匹配的数据略过

// 注意，作为例子程序，我们只是查看和处理我们关心的数据

// 其他与此同时需要监听和处理串口数据的程序，须由相关的代码完成代理的工作

if( KAL_FALSE == gbUartEchoStarted ||

HELLO_WORLD_UART_PORT != uart_rtr_ind->port ||

MOD_HELLO_WORLD != UART_GetOwnerID(uart_rtr_ind->port) )

{

// 如果底层能做成钩子链，这里就可以调用钩子链的下一个钩子了

return;

}

gwLenUartBuffer = read_from_uart(gabyUartBuffer, sizeof(gabyUartBuffer), HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

// 呼叫数据处理部分

uart_echo_process();

}

static void start_uart_echo(void)

{

S8 strHello[] = "Hello World Uart Echo Example Started!\r\n";

if(gbUartEchoStarted)

{

return;

}

init_uart();

write_to_uart((kal_uint8*)strHello, (kal_uint16)strlen(strHello), HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

gbUartEchoStarted = KAL_TRUE;

SetKeyHandler(stop_uart_echo, KEY_LSK, KEY_EVENT_UP);

}

void mmi_sndrec_send_record_req(void);

void mmi_sndrec_stop_record(void);

void mmi_sndrec_entry_edit_name(void);

void mmi_sndrec_entry_rename_option(void);

void mmi_sndrec_entry_save(void);

extern void MakeCall(PS8 strNumber);

extern void EntryScrNotifyCallAborted(void);

void make_call_test(void)

{

S8 numb[6]="10086";

U16 newnumb[6];

memset(newnumb,0,sizeof(newnumb));

AnsiiToUnicodeString((S8*)newnumb,(S8*)numb);

MakeCall((char *)newnumb);

}

#include "F:\HUAYU\P1300\New\P1300_V1.7_Release\custom\drv\misc_drv\NEOTEL25_06B_BB\codegen\Gpio_drv.h"

#include "Gpio_sw.h"

extern void HangupAllCalls(void);

extern void ChargingPwnOnThanPwnOn();

extern void ShutdownSystemOperation(void);

static void uart_echo_process(void)

{

U8 i;

char my_data_buffer[256];

// 稍稍处理一下，这样就能看出是否确实是我们的程序在处理数据

for(i = 0; i < gwLenUartBuffer; i++)

{

AnsiiToUnicodeString((S8 *)my_data_buffer, (S8 *)gabyUartBuffer);

GPIO_ModeSetup((kal_uint16)GPIO_PORT_43, (kal_uint16)0);

GPIO_InitIO((char)1, (char)GPIO_PORT_43);

if(my_data_buffer[0]=='p'&&my_data_buffer[2]=='t')

{

S8 strByte[] = "Play tone successfully\r\n";

playRequestedTone(ALARM_TONE);

write_to_uart((kal_uint8*)strByte, (kal_uint16)strlen(strByte), HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

}

else if(my_data_buffer[0]=='s'&&my_data_buffer[2]=='t')

{

stopRequestedTone(ALARM_TONE);

}

else if(my_data_buffer[0]=='d'&&my_data_buffer[2]=='h')

{

S8 numb[30];

memset(numb,0,sizeof(numb));

numb[0]=my_data_buffer[4];

numb[2]=my_data_buffer[6];

numb[4]=my_data_buffer[8];

numb[6]=my_data_buffer[10];

numb[8]=my_data_buffer[12];

numb[10]=my_data_buffer[14];

numb[12]=my_data_buffer[16];

numb[14]=my_data_buffer[18];

numb[16]=my_data_buffer[20];

numb[18]=my_data_buffer[22];

numb[20]=my_data_buffer[24];

MakeCall((char *)numb);

}

else if(my_data_buffer[0]=='h'&&my_data_buffer[2]=='a'&&my_data_buffer[4]=='n'&&my_data_buffer[6]=='g')

{

EntryScrNotifyCallAborted();

}

else if(my_data_buffer[0]=='y'&&my_data_buffer[2]=='d'&&gwLenUartBuffer==2)

{

make_call_test();

}

else if(my_data_buffer[0]=='i'&&my_data_buffer[2]=='o')

{

GPIO_WriteIO((char)1, (char)GPIO_PORT_43);

}

else if(my_data_buffer[0]=='o'&&my_data_buffer[2]=='d')

{

GPIO_WriteIO((char)0, (char)GPIO_PORT_43);

}

else if(my_data_buffer[0]=='x'&&my_data_buffer[2]=='f')

{

ChargingPwnOnThanPwnOn();

}

else if(my_data_buffer[0]=='c'&&my_data_buffer[2]=='d')

{

HangupAllCalls();

}

else

{

//if(gabyUartBuffer[i] >= 'a' && gabyUartBuffer[i] <= 'z')

gabyUartBuffer[i] -= 0x20;

}

}

// 回显

write_to_uart(gabyUartBuffer, gwLenUartBuffer, HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

}

static void stop_uart_echo(void)

{

S8 strBye[] = "Hello World Uart Echo Example Stop!\r\n";

if(gbUartEchoStarted)

{

write_to_uart((kal_uint8*)strBye, (kal_uint16)strlen(strBye), HELLO_WORLD_UART_PORT, MOD_HELLO_WORLD);

gbUartEchoStarted = KAL_FALSE;

SetKeyHandler(start_uart_echo, KEY_LSK, KEY_EVENT_UP);

}

exit_uart();

}

#include "OrganizerDef.h"

extern void mmi_HelloWorld_exit(void);

/* 模块入口 */

void mmi_HelloWorld_entry(void)

{

S32 x,y;

x=30;y=0;

/* 强制退出当前屏幕，之后进入到我们的模块了 */

/* 上电缺省是idle屏幕，现进入MAIN_MENU_SCREENID屏 */

/* 注意看第二个参数，这个是当我们模块被强制退出时执行的一些操作 */

EntryNewScreen(ORGANIZER_SCREENID, mmi_HelloWorld_exit, NULL, NULL);

gui_lock_double_buffer();

/* 关掉屏幕顶部的状态条，我们要用整个屏幕 */

entry_full_screen();

/* 擦除当前背景 */

clear_screen();

y+=50;

gui_set_text_color(UI_COLOR_RED);

gui_move_text_cursor(x,y);

gui_print_text(L"Uart Test");

gui_unlock_double_buffer();

/* 刷新屏幕显示，MMI用的是双缓冲绘图方式，而且需要显式刷新 */

gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);

/* 注册一个按键处理，右软键弹起时返回到之前被我们强制退出的模块 */

SetKeyHandler(GoBackHistory, KEY_RSK, KEY_EVENT_UP);

// SetKeyHandler(stop_play_anim, KEY_LSK, KEY_EVENT_UP);

SetKeyHandler(start_uart_echo, KEY_LSK, KEY_EVENT_UP);

}

/* 模块出口

* 当我们的模块被其他模块强制退出时会执行这个函数，

* 这个函数的常见写法，包括：

* 1、模块已申请资源的释放(如果需要的话)，这一步可选

* 2、手动把自己压栈到窗口(实际是整个屏)堆栈里面，

* 便于强制我们退出的模块执行完后重新把我们叫出来

* 不像Window的窗口管理是自动压栈的，Pluto MMI需要手动压栈

* 3、其他一些清理动作

*/

void mmi_HelloWorld_exit(void)

{

history currHistory;

S16 nHistory = 0;

currHistory.scrnID = MAIN_MENU_SCREENID;

currHistory.entryFuncPtr = mmi_HelloWorld_entry;

pfnUnicodeStrcpy( (S8*)currHistory.inputBuffer, (S8*)&nHistory);

AddHistory(currHistory);

stop_uart_echo();

}

//////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////

上位机程序怎么搞？？

delphi c++ vb c# java PB，这些都可以搞啊

你既然问上位机，肯定有下位机，是不是做串口通讯啊，像VB/VC/MFC中可以用一个控件MSComm，很方便的

是的，在做串口通信

麻烦提供一些详细参考思路

先下载个电脑串口调试工具，比较常用像sscom32.exe，然后制定通讯协议，简单点就如：头+长度+命令字+数据内容+异或校验+尾。

如果下位机已经有固定协议，那先用串口调试工具把各种命令执行一遍。心里有数了，就可以写上位机软件了，如果不太懂先下个串口收发的源码。网上各种语言版本的都有。然后照着改就行了。

VC6通过MSComm读写串口如下：

m_MSComm.SetCommPort(1); //选择COM1

m_MSComm.SetPortOpen(TRUE);//打开串口

m_MSComm.SetSettings("9600,n,8,1"); //波特率9600，无校验位，8个数据位，1个停止位

VARIANT variant_inp=m_MSComm.GetInput(); //读缓冲区

m_MSComm.SetOutput(COleVariant("test")); //给下位机发送“test”

上位机程序 什么软件开发好

这个吗，，

微软公司一般做的比较好！

visual studio 2008就比较好！随便 拖几个控件 即可！

我就是学嵌入式的，，现在做.net开发，，感觉挺容易上手的！

而且，微软公司把什么都做好了，，就等你去 调用，，

网上资料也比较多！！！

你可以看看！！

希望对你有帮助！！！

编写单片机上位机程序一般都是用什么软件

上位机软件可以VB，VC，当然C也可以,人个认为最简单当属VB了，上手容易。

你可以找一些关于串口通信的书箱和资料先看看，www.pudn.com上有很多源码及资料。

学上位机编程用什么软件

根据你的意思，既然是上位机编程，当然应该是与控制有关，还有下位机，所以这个编程用到的软件主要应该有：

1、C语言，这是基本的上位机语言，特别在以前的DOS时代，用的十分普遍

2、C++，这是目前用的很多的编程语言，VC，MFC等都属于这个范畴

3、VB，这个语言现在应用也很广泛，由于可视化编程，入门较容易，很多人在使用

怎么从上位机导出其中的PLC程序？

编程软年中有相应功能，如从PLC上载等，触摸屏的话，上载后一般要经过反编译，如威纶的屏就有此功能。但如果加密的话就没办法了，除非解密

转载请注明出处51数据库 » 上位机软件流程图 写上位机程序要学习哪些编程软件