bool CPacketActiveFilter::WaitInputBuffer(CPacketQueueInputPin*& pPin, CPacket*& pBuffer) { CQueue::WaitResult result; CMD cmd; while (true) { CQueue::QType type = mpWorkQ->WaitDataMsg(&cmd, sizeof(cmd), &result); if (type == CQueue::Q_MSG) { if (!ProcessCmd(cmd)) { if (cmd.code == AO::CMD_STOP) { OnStop(); CmdAck(ME_OK); return false; } } } else { pPin = (CPacketQueueInputPin*) result.pOwner; if (pPin->PeekBuffer(pBuffer)) { return true; } INFO("No buffer?\n"); } } return false; }
void ProcessIO(void) { if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return; /*if(USBGetDeviceState() == DETACHED_STATE) { if(I2CCount > 0) { ProcessCmd(OUTPacket); I2CCount = 0; } } else*/ if(!USBHandleBusy(USBGenericOutHandle)) { //if( OUTPacket[1] != MASTER_ADDRESS ) // I2CRelay(OUTPacket, USBGEN_EP_SIZE); //else ProcessCmd(OUTPacket); USBGenericOutHandle = USBGenRead(USBGEN_EP_NUM, (BYTE*)&OUTPacket, USBGEN_EP_SIZE); } if(WQI != WQX && !USBHandleBusy(USBGenericInHandle)) { USBGenericInHandle = USBGenWrite(USBGEN_EP_NUM, (BYTE*)&INPacket[WQX*USB_RECORD_SIZE], USB_RECORD_SIZE); WQX = (WQX+1) & 3; } } //end ProcessIO
int TapeDrive::command(short mt_op, daddr_t mt_count) { waitForChildProcess(); DOASSERT(_child <= 0, "Invalid child process ID"); #ifdef TAPE_THREAD _proc_mt_op = mt_op; _proc_mt_count = mt_count; if (pthread_create(&_child, 0, ProcessCmd, this)) { reportErrSys("pthread_create"); return -1; } #else // There seems to be a problem forking the tape command. Do it // in same process for now. _child = fork(); if (!_child) { (void)ProcessCmd(mt_op, mt_count); exit(1); } if (_child < 0) { reportErrSys("fork"); return -1; } #endif return 0; }
void NetClient::OnReceiveCmd(const NetMessage& msg, const NetCmdHeader& header, const streambuf::const_buffers_type& bufs) { LSL_TRACE(lsl::StrFmt("NetClient OnReceiveCmd sender=%d id=%d rpc=%d size=%d", msg.sender, header.id, header.rpc, header.size)); ProcessCmd(msg, header, bufs); _net->OnReceiveCmd(msg, header, buffer_cast<const void*>(bufs), buffer_size(bufs)); }
void SPUThread::ListCmd(u32 lsa, u64 ea, u16 tag, u16 size, u32 cmd, MFCReg& MFCArgs) { u32 list_addr = ea & 0x3ffff; u32 list_size = size / 8; lsa &= 0x3fff0; struct list_element { be_t<u16> s; // Stall-and-Notify bit (0x8000) be_t<u16> ts; // List Transfer Size be_t<u32> ea; // External Address Low }; u32 result = MFC_PPU_DMA_CMD_ENQUEUE_SUCCESSFUL; for (u32 i = 0; i < list_size; i++) { auto rec = vm::ptr<list_element>::make(dmac.ls_offset + list_addr + i * 8); u32 size = rec->ts; if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8) { LOG_ERROR(Log::SPU, "DMA List: invalid transfer size(%d)", size); result = MFC_PPU_DMA_CMD_SEQUENCE_ERROR; break; } u32 addr = rec->ea; ProcessCmd(cmd, tag, lsa | (addr & 0xf), addr, size); if (Ini.HLELogging.GetValue() || rec->s) LOG_NOTICE(Log::SPU, "*** list element(%d/%d): s = 0x%x, ts = 0x%x, low ea = 0x%x (lsa = 0x%x)", i, list_size, (u16)rec->s, (u16)rec->ts, (u32)rec->ea, lsa | (addr & 0xf)); lsa += std::max(size, (u32)16); if (rec->s.ToBE() & se16(0x8000)) { StallStat.PushUncond_OR(1 << tag); if (StallList[tag].MFCArgs) { LOG_ERROR(Log::SPU, "DMA List: existing stalled list found (tag=%d)", tag); result = MFC_PPU_DMA_CMD_SEQUENCE_ERROR; break; } StallList[tag].MFCArgs = &MFCArgs; StallList[tag].cmd = cmd; StallList[tag].ea = (ea & ~0xffffffff) | (list_addr + (i + 1) * 8); StallList[tag].lsa = lsa; StallList[tag].size = (list_size - i - 1) * 8; break; } } MFCArgs.CMDStatus.SetValue(result); }
bool Mgr::start(){ while(true){ if(!ProcessCmd()) break; obj->update(); _sleep(10); } return true; }
void CMainFrame::OnClientPcShutdown() { LPCLIENTITEM pItem = pClientListView->GetCurSel(); if(pItem != NULL) { ProcessCmd(pItem->m_WorkSocket, CLIENT_SYSTEM_SHUTDOWN,NULL,0); DeleteCurItem(); } }
void CMainFrame::OnClientProUninstall() { LPCLIENTITEM pItem = pClientListView->GetCurSel(); if(pItem != NULL) { ProcessCmd(pItem->m_WorkSocket, CLIENT_PRO_UNINSTALL,NULL,0); DeleteCurItem(); } }
void CMainFrame::OnClientPcRestart() { LPCLIENTITEM pItem = pClientListView->GetCurSel(); if(pItem != NULL) { ProcessCmd(pItem->m_WorkSocket, CLIENT_SYSTEM_RESTART,NULL,0); DeleteCurItem(); } }
void CCmdProcess::OnCmdCome(unsigned int flow, char *pData, int nLen) { Commpack * pPack = new Commpack(nLen + 512); if (!pPack->Input((void *) pData, nLen)) { delete pPack; return; } ProcessCmd(flow, pPack); delete pPack; }
int ServerProcess(int new_fd, char * recvbuf) { char * result = NULL; //strcpy( sendbuf, "welcome !"); //sendlen = strlen(sendbuf); //send(new_fd, sendbuf, sendlen,0); result = ProcessCmd(recvbuf); debug_print(("result is %s\n",result)); SendData(new_fd,result); return 0; }
void CReadThread::ParseData( QByteArray& byData ) { int nRet = 0; QByteArray vData; quint16 nDataLen = 0; quint8 nCanAddr = 0; quint8 nCheckSum = 0; CPortCmd::PortUpCmd cmdType = portCmd.ParseUpCmd( byData, nDataLen, nCanAddr, nCheckSum, vData ); ProcessCmd( byData, cmdType ); emit SerialData( byData ); }
void TelnetDataCollector::ProcessIac(byte val) { if (val == CMD_SB) { m_currentState = InsideSb; ProcessSb(val); } else { m_currentState = InsideCmd; ProcessCmd(val); } }
void CThread::RealRun() { while (!m_bStop) { uint32_t iRet = ProcessCmd(); if (iRet ==0 && !m_bStop) { pthread_cond_wait(&m_cond, &m_mutex); } } pthread_signal(&m_condWait); }
void TelnetDataCollector::ProcessChar(byte val) { switch (m_currentState) { case (InsideText): ProcessPair(val); break; case (InsideCmd): ProcessCmd(val); break; case (InsideSb): ProcessSb(val); break; default: ESS_ASSERT(0 && "Unknown state"); } }
int main(void) { setup(); while(1) { // use LED to show if I2C has a bus manager blink(); // check if character is available to assemble a command, e.g. non-blocking if ( (!command_done) && uart0_available() ) // command_done is an extern from parse.h { // get a character from stdin and use it to assemble a command AssembleCommand(getchar()); // address is an ascii value, warning: a null address would terminate the command string. StartEchoWhenAddressed(rpu_addr); } // check if a character is available, and if so flush transmit buffer and nuke the command in process. // A multi-drop bus can have another device start transmitting after getting an address byte so // the first byte is used as a warning, it is the onlly chance to detect a possible collision. if ( command_done && uart0_available() ) { // dump the transmit buffer to limit a collision uart0_flush(); initCommandBuffer(); } // delay between ADC burst adc_burst(); // finish echo of the command line befor starting a reply (or the next part of a reply) if ( command_done && (uart0_availableForWrite() == UART_TX0_BUFFER_SIZE) ) { if ( !echo_on ) { // this happons when the address did not match initCommandBuffer(); } else { if (command_done == 1) { findCommand(); command_done = 10; } // do not overfill the serial buffer since that blocks looping, e.g. process a command in 32 byte chunks if ( (command_done >= 10) && (command_done < 250) ) { ProcessCmd(); } else { initCommandBuffer(); } } } } return 0; }
int Mouse::Loop() { fd_set readfds; struct timeval timeout = {0, 10000}; bool isDeviceAdd = false; if (access(DEVICE_PATH, 0) != 0) { printf("device do not exist\n"); return -1; } /* open /dev/mouse */ OpenDev(); CursorBounds desireBounds; desireBounds.width = mWidth; desireBounds.height = mHeight; desireBounds.spotX = mSpotX; desireBounds.spotY = mSpotY; mDrawBitmaps = (char *)mDefaultBitmap->getPixels(); printf("now draw default cursor bitmap\n"); DrawCursor(desireBounds); printf("finish draw default cursor bitmap\n"); while(mIsRunning) { readfds = mSelectFds; int retval; retval = select(mMaxFd + 1, &readfds, NULL, NULL, NULL); if (retval == 0) { printf("select time out\n"); continue; } if (FD_ISSET(mUnixFd, &readfds)) { struct sockaddr_in address; int addrLength; int acceptFd = accept(mUnixFd, (struct sockaddr *)&address, &addrLength); if (acceptFd > mMaxFd) { mMaxFd = acceptFd; } mAcceptFds.add(String8("cursor"), acceptFd); FD_SET(acceptFd, &mSelectFds); printf("new connect accept\n"); } if (FD_ISSET(mDeviceFd, &readfds)) { InputPosition tmpPos; bool isOK = true; int read_size = read(mDeviceFd, &tmpPos, sizeof(tmpPos));; if (read_size <= 0 && errno == ENODEV) { printf("device is closed\n"); isOK = false; } else if(read_size > 0 && read_size % sizeof(tmpPos) != 0) { printf("read fd %d error\n", mDeviceFd); isOK = false; } if (isOK) { memcpy(&mPos, &tmpPos, sizeof(mPos)); mMove = true; } DrawCursor(desireBounds); //printf("mouse move\n"); } for (int i = 0;i < mAcceptFds.size();i++) { int acceptFd = mAcceptFds.valueAt(i); if (FD_ISSET(acceptFd, &readfds)) { CmdHeader header; int read_size; read_size = read(acceptFd, &header, sizeof(CmdHeader)); if (read_size == 0) { printf("remote close unix socket\n"); FD_CLR(acceptFd, &mSelectFds); mAcceptFds.removeItemsAt(i); close(acceptFd); mWantChange = true; mUpdateCursor = true; if (mDrawBitmaps != NULL && !mUseDefaultBitmap) { char *freeHeader = mDrawBitmaps - sizeof(CmdHeader) + sizeof(CursorBounds); free(freeHeader); } desireBounds.width = mDefaultBitmap->width(); desireBounds.height = mDefaultBitmap->height(); desireBounds.spotX = IMAGE_HOT_X; desireBounds.spotY = IMAGE_HOT_Y; mUseDefaultBitmap = true; mDrawBitmaps = mDefaultBitmap->getPixels(); DrawCursor(desireBounds); continue; } char *data = (char *)malloc(sizeof(CmdHeader) + header.length); memcpy(data, &header, sizeof(CmdHeader)); read_size = read(acceptFd, data + sizeof(CmdHeader), header.length); ProcessCmd(data, sizeof(CmdHeader) + header.length, desireBounds); DrawCursor(desireBounds); mUseDefaultBitmap = false; } } } return 0; }
void CListener::ProcessRead(SOCKET sock) { MSG_HEADER hdr; int iError = 0; if (!RecvHeader(sock, (char*)&hdr, sizeof (MSG_HEADER), 0, &iError)) { if (iError) { // check existence of the connection and close CloseConnection(sock); } else // nonfatal error -> don't close connection { } return; } else { hdr.ConvertNTOH(); } if (hdr.Command < VCM_MIN || hdr.Command > VCM_MAX) { // invalid command // check existence of the connection and close CloseConnection(sock); return; } if (hdr.DataLen < 0) { // check existence of the connection and close CloseConnection(sock); return; } #ifdef UNICODE if (hdr.DataLen % 2 != 0) { // invalid data (because data is a widechar string, number of bytes must be even) // check existence of the connection and close CloseConnection(sock); } #endif if (hdr.DataLen > 0) { int iNumTChar = hdr.DataLen/sizeof(TCHAR); TCHAR *pData; pData = new TCHAR[iNumTChar + 1]; if (!pData) { CloseConnection(sock); return; } if (!RecvData(sock, (char*)pData, hdr.DataLen, 0, &iError)) { delete []pData; if (iError) { // check existence of the connection and close CloseConnection(sock); } return; } pData[iNumTChar] = 0; ProcessCmd(hdr, pData, sock); delete []pData; } else { ProcessCmd(hdr, _T(""), sock); } }
BOOL CFileManagerApp::InitInstance() { // InitCommonControls() is required on Windows XP if an application // manifest specifies use of ComCtl32.dll version 6 or later to enable // visual styles. Otherwise, any window creation will fail. InitCommonControls(); CWinApp::InitInstance(); #if CONSOLE_WND InitConsoleWindow(); #endif AfxEnableControlContainer(); LogTools::InitZToolsLog(); CCrashHandler ch; ch.SetProcessExceptionHandlers(); ch.SetThreadExceptionHandlers(); globalData.SetDPIAware (); ProcessCmd(); HANDLE hMetux = CreateMutex(NULL,TRUE,"FileManager_Sqlite3"); if (hMetux) { if(ERROR_ALREADY_EXISTS==GetLastError()) { CloseHandle(hMetux); CWnd * pDeskTopWnd = CWnd::GetDesktopWindow(); CWnd *pFind = pDeskTopWnd->GetWindow(GW_CHILD); while(pFind) { if (::GetProp(pFind->m_hWnd,m_pszExeName)) { if (::IsIconic(pFind->m_hWnd)) pFind->ShowWindow(SW_RESTORE); // 如果主窗口已经最小话,则恢复其大小 pFind->ShowWindow(SW_SHOW); pFind->SetForegroundWindow(); ::SetForegroundWindow(::GetLastActivePopup(pFind->m_hWnd)); return FALSE; // 前一个运行实例已经存在,退出本实例 } pFind = pFind->GetWindow(GW_HWNDNEXT); } } } CFileManagerDlg dlg; dlg.m_bRunAtBack = m_bRunAtBack; m_pMainWnd = &dlg; INT_PTR nResponse = dlg.DoModal(); if (nResponse == IDOK) { // TODO: Place code here to handle when the dialog is // dismissed with OK } else if (nResponse == IDCANCEL) { // TODO: Place code here to handle when the dialog is // dismissed with Cancel } BCGCBProCleanUp (); CloseHandle(hMetux); // Since the dialog has been closed, return FALSE so that we exit the // application, rather than start the application's message pump. return FALSE; }
void SPUThread::EnqMfcCmd(MFCReg& MFCArgs) { u32 cmd = MFCArgs.CMDStatus.GetValue(); u16 op = cmd & MFC_MASK_CMD; u32 lsa = MFCArgs.LSA.GetValue(); u64 ea = (u64)MFCArgs.EAL.GetValue() | ((u64)MFCArgs.EAH.GetValue() << 32); u32 size_tag = MFCArgs.Size_Tag.GetValue(); u16 tag = (u16)size_tag; u16 size = size_tag >> 16; switch (op & ~(MFC_BARRIER_MASK | MFC_FENCE_MASK)) { case MFC_PUT_CMD: case MFC_PUTR_CMD: // ??? case MFC_GET_CMD: { if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", (op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_RESULT_MASK ? "R" : ""), (op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_FENCE_MASK ? "F" : ""), lsa, ea, tag, size, cmd); ProcessCmd(cmd, tag, lsa, ea, size); MFCArgs.CMDStatus.SetValue(MFC_PPU_DMA_CMD_ENQUEUE_SUCCESSFUL); break; } case MFC_PUTL_CMD: case MFC_PUTRL_CMD: // ??? case MFC_GETL_CMD: { if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, list = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", (op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_RESULT_MASK ? "RL" : "L"), (op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_FENCE_MASK ? "F" : ""), lsa, ea, tag, size, cmd); ListCmd(lsa, ea, tag, size, cmd, MFCArgs); break; } case MFC_GETLLAR_CMD: case MFC_PUTLLC_CMD: case MFC_PUTLLUC_CMD: case MFC_PUTQLLUC_CMD: { if (Ini.HLELogging.GetValue() || size != 128) LOG_NOTICE(Log::SPU, "DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x", (op == MFC_GETLLAR_CMD ? "GETLLAR" : op == MFC_PUTLLC_CMD ? "PUTLLC" : op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"), lsa, ea, tag, size, cmd); if (op == MFC_GETLLAR_CMD) // get reservation { if (R_ADDR) { m_events |= SPU_EVENT_LR; } R_ADDR = ea; for (u32 i = 0; i < 16; i++) { R_DATA[i] = vm::get_ptr<u64>(R_ADDR)[i]; vm::get_ptr<u64>(dmac.ls_offset + lsa)[i] = R_DATA[i]; } MFCArgs.AtomicStat.PushUncond(MFC_GETLLAR_SUCCESS); } else if (op == MFC_PUTLLC_CMD) // store conditional { MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); if (R_ADDR == ea) { u32 changed = 0, mask = 0; u64 buf[16]; for (u32 i = 0; i < 16; i++) { buf[i] = vm::get_ptr<u64>(dmac.ls_offset + lsa)[i]; if (buf[i] != R_DATA[i]) { changed++; mask |= (0x3 << (i * 2)); if (vm::get_ptr<u64>(R_ADDR)[i] != R_DATA[i]) { m_events |= SPU_EVENT_LR; MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE); R_ADDR = 0; return; } } } for (u32 i = 0; i < 16; i++) { if (buf[i] != R_DATA[i]) { if (InterlockedCompareExchange(&vm::get_ptr<volatile u64>(ea)[i], buf[i], R_DATA[i]) != R_DATA[i]) { m_events |= SPU_EVENT_LR; MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE); if (changed > 1) { LOG_ERROR(Log::SPU, "MFC_PUTLLC_CMD: Memory corrupted (~x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", changed, mask, op, cmd, lsa, ea, tag, size); Emu.Pause(); } break; } } } if (changed > 1) { LOG_WARNING(Log::SPU, "MFC_PUTLLC_CMD: Reservation impossibru (~x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", changed, mask, op, cmd, lsa, ea, tag, size); SPUDisAsm dis_asm(CPUDisAsm_InterpreterMode); for (s32 i = (s32)PC; i < (s32)PC + 4 * 7; i += 4) { dis_asm.dump_pc = i; dis_asm.offset = vm::get_ptr<u8>(dmac.ls_offset); const u32 opcode = vm::read32(i + dmac.ls_offset); (*SPU_instr::rrr_list)(&dis_asm, opcode); if (i >= 0 && i < 0x40000) { LOG_NOTICE(Log::SPU, "*** %s", dis_asm.last_opcode.c_str()); } } } } else { MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE); } R_ADDR = 0; } else // store unconditional { if (R_ADDR) { m_events |= SPU_EVENT_LR; } ProcessCmd(MFC_PUT_CMD, tag, lsa, ea, 128); if (op == MFC_PUTLLUC_CMD) { MFCArgs.AtomicStat.PushUncond(MFC_PUTLLUC_SUCCESS); } R_ADDR = 0; } break; } default: LOG_ERROR(Log::SPU, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", op, cmd, lsa, ea, tag, size); break; } }
//***************************************************************************** // // This is the main loop for the application. // //***************************************************************************** int main(void) { // // If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is // a workaround to allow the PLL to operate reliably. // if(REVISION_IS_A2) { SysCtlLDOSet(SYSCTL_LDO_2_75V); } // // Set the clocking to run directly from the PLL at 25MHz. // SysCtlClockSet(SYSCTL_SYSDIV_8 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable the pull-ups on the JTAG signals. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Configure CAN 0 Pins. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeCAN(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure GPIO Pins used for the Buttons. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Configure GPIO Pin used for the LED. // GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // // Turn off the LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); // // Enable the CAN controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); // // Reset the state of all the message object and the state of the CAN // module to a known state. // CANInit(CAN0_BASE); // // Configure the bit rate for the CAN device, the clock rate to the CAN // controller is fixed at 8MHz for this class of device and the bit rate is // set to 250000. // CANBitRateSet(CAN0_BASE, 8000000, 250000); // // Take the CAN0 device out of INIT state. // CANEnable(CAN0_BASE); // // Enable interrups from CAN controller. // CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR); // // Set up the message object that will receive all messages on the CAN // bus. // CANConfigureNetwork(); // // Enable interrupts for the CAN in the NVIC. // IntEnable(INT_CAN0); // // Enable processor interrupts. // IntMasterEnable(); // // Configure SysTick for a 10ms interrupt. // SysTickPeriodSet(SysCtlClockGet() / 100); SysTickEnable(); SysTickIntEnable(); // // Initialize the button status. // g_ucButtonStatus = GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Loop forever. // while(1) { // // Forground handling of interrupts. // ProcessInterrupts(); // // Handle any incoming commands. // ProcessCmd(); } }
void CAM_Input(uint8_t c) { static uint16_t CamCrc = 0; if(camStopFlag == 0) // cam is running { switch(camState) { case WAIT_HEADER: { if(c == 'U') { CamCrc = c; camState = GET_CMD; } } break; case GET_CMD: { CamCrc += c; camRespondedCmd = c; camRespondedDataLen = 0; camState = GET_CAM_ID; } break; case GET_CAM_ID: { CamCrc += c; camRespondedId = c; // image data if(camRespondedCmd == 'F') { camState = GET_IMG_PKG_ID0; } else { camRespondedDataLen = 0; camState = GET_CMD_DATA; } } break; case GET_CMD_DATA: { if(c == '#') { ProcessCmd(); camState = WAIT_HEADER; } else { packetWriteJpegFile.data[camRespondedDataLen++] = c; } } break; case GET_IMG_PKG_ID0: { CamCrc += c; camRespondedPacketId = c; camState = GET_IMG_PKG_ID1; } break; case GET_IMG_PKG_ID1: { CamCrc += c; camRespondedPacketId |= ((uint16_t)c)<<8; camState = GET_IMG_DATA_LEN0; } break; case GET_IMG_DATA_LEN0: { CamCrc += c; camRespondedPacketLen = c; camState = GET_IMG_DATA_LEN1; } break; case GET_IMG_DATA_LEN1: { CamCrc += c; camRespondedPacketLen |= ((uint16_t)c)<<8; camRespondedPacketLen += 2; camRespondedDataLen = 0; camState = GET_IMG_DATA; } break; case GET_IMG_DATA: { if((camRespondedDataLen < CAMERA_DATA_SIZE)) { packetWriteJpegFile.data[camRespondedDataLen] = c; CamCrc += c; } camRespondedDataLen++; if(camRespondedDataLen >= camRespondedPacketLen - 2) { camState = GET_IMG_CRC0; } } break; case GET_IMG_CRC0: { camRespondedCrc = c; camState = GET_IMG_CRC1; } break; case GET_IMG_CRC1: { camRespondedCrc |= ((uint16_t)c)<<8; //if(CamCrc == camRespondedCrc) { // prepair the packet CamCrc = 0; packetWriteJpegFile.cameraNumber = camRespondedId; packetWriteJpegFile.len = camRespondedDataLen; packetWriteJpegFile.offset = (uint32_t)(camRespondedPacketId - 1)*CAMERA_DATA_SIZE; packetWriteJpegFile.fileSize = ssInfo[camRespondedId].size; packetWriteJpegFile.year = ssInfo[camRespondedId].time.year - 2000; packetWriteJpegFile.month = ssInfo[camRespondedId].time.month; packetWriteJpegFile.mday = ssInfo[camRespondedId].time.mday; packetWriteJpegFile.hour = ssInfo[camRespondedId].time.hour; packetWriteJpegFile.min = ssInfo[camRespondedId].time.min; packetWriteJpegFile.sec = ssInfo[camRespondedId].time.sec; //memcpy(packetWriteJpegFile.data, camData, camRespondedDataLen); INFO("CAM: Got packet from CAM %d, ID: %d / %d, len:%d\n", camRespondedId, camRespondedPacketId, ssInfo[camCurrentId].packetCount, camRespondedDataLen); } // else // camManState = GOT_PACKET; camManState = GOT_PACKET; camState = WAIT_HEADER; } break; default: { camManState = GOT_PACKET; camState = WAIT_HEADER; } break; } } }
int main(int argc, char **argv) { int c; int args; int ip=0; int verbose=0; int node=0; int tty=0; char lbuf[SZ_LINE]; char tbuf[SZ_LINE]; char *p; char *image=NULL; Finfo cur, tcur; /* we want the args in the same order in which they arrived, and gnu getopt sometimes changes things without this */ putenv("POSIXLY_CORRECT=true"); /* process switch arguments */ while ((c = getopt(argc, argv, "i:v")) != -1){ switch(c){ case 'i': image = optarg; break; case 'v': verbose++; break; } } /* process remaining args */ args = argc - optind; /* if image was specified, this is a batch job */ if( image ){ switch(args){ case 0: /* get image info and exit */ if( ProcessCmd("image", &image, 1, 0, 0) == 0 ){ FinfoFree(image); return 0; } else { return 1; } break; case 1: /* set image (no info returned) */ if( ProcessCmd("image_", &image, 1, 0, 0) != 0 ){ return 1; } /* process command without args */ if( ProcessCmd(argv[optind+0], NULL, 0, 0, 0) == 0 ){ FinfoFree(image); return 0; } else { return 1; } break; default: /* set image (no info returned) */ if( ProcessCmd("image_", &image, 1, 0, 0) != 0 ){ return 1; } /* process command with args */ if( ProcessCmd(argv[optind+0], &(argv[optind+1]), args-1, 0, 0) == 0 ){ FinfoFree(image); return 0; } else { return 1; } break; } } /* stdout is connected to terminal => not connected to the node helper */ if( isatty(1) ){ node = 0; tty = 1; } else { node = 1; tty = 0; } /* initial prompt */ if( !node ){ fprintf(stdout, "js9helper> "); fflush(stdout); } /* command loop */ while( fgets(lbuf, SZ_LINE-1, stdin) ){ /* first arg: command */ ip = 0; if( !word(lbuf, tbuf, &ip) ) continue; /* look for quit */ if( !node ){ if( !strcasecmp(tbuf, "quit") ){ break; } } /* process this command */ p = &lbuf[ip]; ProcessCmd(tbuf, &p, 1, node, tty); /* re-prompt, if necessary */ if( !node ){ fprintf(stdout, "js9helper> "); fflush(stdout); } } /* clean up */ for(cur=finfohead; cur!=NULL; ){ tcur = cur->next; _FinfoFree(cur); cur = tcur; } /* all done */ return 0; }
int main(void) { // Initialize Timers, ADC, and clear bootloader, Arduino does these with init() in wiring.c initTimers(); //Timer0 Fast PWM mode, Timer1 & Timer2 Phase Correct PWM mode. init_ADC_single_conversion(EXTERNAL_AVCC); // warning AREF should only have a bypass cap init_uart0_after_bootloader(); // bootloader may have the UART setup // setup() // Set digital pins to control load init_load(); // Set digital pins to control solar init_pv(); // put ADC in free running Auto Trigger mode enable_ADC_auto_conversion(FREE_RUNNING); /* Initialize UART, it returns a pointer to FILE so redirect of stdin and stdout works*/ stdout = stdin = uartstream0_init(BAUD); /* Clear and setup the command buffer, (probably not needed at this point) */ initCommandBuffer(); sei(); // Enable global interrupts starts TIMER0, UART0, ADC and any other ISR's // this start up command should run cctest, e.g. after a reset. if (uart0_available() == 0) { strcpy_P(command_buf, PSTR("/0/cctest?")); command_done = 1; echo_on = 1; printf_P(PSTR("%s\r\n"), command_buf); } // loop() while(1) /* I am tyring to use non-blocking code */ { // check if character is available to assemble a command, e.g. non-blocking if ( (!command_done) && uart0_available() ) // command_done is an extern from parse.h { // get a character from stdin and use it to assemble a command AssembleCommand(getchar()); // address is the ascii value for '0' note: a null address will terminate the command string. StartEchoWhenAddressed('0'); } // check if a character is available, and if so flush transmit buffer and nuke the command in process. // A multi-drop bus can have another device start transmitting after getting an address byte so // the first byte is used as a warning, it is the onlly chance to detect a possible collision. if ( command_done && uart0_available() ) { // dump the transmit buffer to limit a collision uart0_flush(); initCommandBuffer(); //Enable the LT3652, which may have been turned off digitalWrite(SHUTDOWN, LOW); // trun off the load load_step(0); } // finish echo of the command line befor starting a reply (or the next part of a reply) if ( command_done && (uart0_availableForWrite() == UART_TX0_BUFFER_SIZE) ) { if ( !echo_on ) { // this happons when the address did not match initCommandBuffer(); } else { if (command_done == 1) { findCommand(); command_done = 10; } // do not overfill the serial buffer since that blocks looping, e.g. process a command in 32 byte chunks if ( (command_done >= 10) && (command_done < 250) ) { ProcessCmd(); } else { initCommandBuffer(); } } } } return 0; }
int main(void) { /* Initialize UART, it returns a pointer to FILE so redirect of stdin and stdout works*/ stdout = stdin = uartstream0_init(BAUD); /* Initialize I2C, with the internal pull-up*/ twi_init(1); /* Clear and setup the command buffer, (probably not needed at this point) */ initCommandBuffer(); sei(); // Enable global interrupts char rpu_addr = get_Rpu_address(); // set a default address if RPU manager not found if (rpu_addr == 0) { rpu_addr = '0'; } while(1) { // check if character is available to assemble a command, e.g. non-blocking if ( (!command_done) && uart0_available() ) // command_done is an extern from parse.h { // get a character from stdin and use it to assemble a command AssembleCommand(getchar()); // address is a char e.g. the ascii value for '0' warning: a null will terminate the command string. StartEchoWhenAddressed(rpu_addr); } // check if the character is available, and if so stop transmit and the command in process. // a multi-drop bus can have another device start transmitting after the second received byte so // there is little time to detect a possible collision if ( command_done && uart0_available() ) { // dump the transmit buffer to limit a collision uart0_flush(); initCommandBuffer(); } // finish echo of the command line befor starting a reply (or the next part of reply) if ( command_done && (uart0_availableForWrite() == UART_TX0_BUFFER_SIZE) ) { if ( !echo_on ) { // this happons when the address did not match initCommandBuffer(); } else { // command is a pointer to string and arg[] is an array of pointers to strings // use findCommand to make them point to the correct places in the command line // this can only be done once, since spaces and delimeters are replaced with null termination if (command_done == 1) { findCommand(); command_done = 10; } if ( (command_done >= 10) && (command_done < 250) ) { ProcessCmd(); } else { initCommandBuffer(); } } } } return 0; }