MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
SerialWindow = new ConnexionSerie(this);
ProtocoleBeagleBone = new Protocole;
QObject::connect(SerialWindow, SIGNAL(InitSerialConnection(QString)), this, SLOT(SerialConnect(QString)));
//connect(serial,SIGNAL(readyRead()),this,SLOT(donnee_recue()));
}
void android_main(struct android_app *state)
{
system("su -c \"chmod 0777 /dev/ttyUSB0\"");
app_dummy();
state->userData=NULL;
state->onAppCmd=engine_handle_cmd;
state->onInputEvent=engine_handle_input;
app=state;
assetManager=state->activity->assetManager;
SerialConnect("/dev/ttyUSB0");
while(1)
{
int ident, events;
struct android_poll_source *source;
while((ident=ALooper_pollAll(0, NULL, &events, (void**)&source))>=0)
{
if(source!=NULL)
source->process(state, source);
if(state->destroyRequested!=0)
{
engine_term_display();
return;
}
}
memcpy(&StartTime, &EndTime, sizeof(struct timespec));
clock_gettime(CLOCK_MONOTONIC, &EndTime);
engine_draw_frame();
fTimeStep=(float)timespecDiff(&EndTime, &StartTime)/1000000000.0f;
fTime+=fTimeStep;
FPSTemp+=1.0f/fTimeStep;
if(Frames++>15)
{
FPS=FPSTemp/Frames;
FPSTemp=0.0f;
Frames=0;
}
}
close(tty_fd);
}
void Xbox360Peripheral::ChatPadTimerAction(IOTimerEventSource *sender)
{
int nextTime, serialGot;
serialGot = 0;
nextTime = 1000;
switch (serialTimerState)
{
case tsToggle:
SendToggle();
if (serialActive)
{
if (!serialHeard)
{
serialActive = false;
serialGot = 2;
}
}
else
{
if (serialHeard)
{
serialTimerState = tsReset1;
serialResetCount = 0;
nextTime = 40;
}
}
break;
case tsMiniToggle:
SendToggle();
if (serialHeard)
{
serialTimerState = tsSet1;
nextTime = 40;
}
else
{
serialResetCount++;
if (serialResetCount > 3)
{
serialTimerState = tsToggle;
}
else
{
serialTimerState = tsReset1;
nextTime = 40;
}
}
break;
case tsReset1:
SendSpecial(0x1B);
serialTimerState = tsReset2;
nextTime = 35;
break;
case tsReset2:
SendSpecial(0x1B);
serialTimerState = tsMiniToggle;
nextTime = 150;
break;
case tsSet1:
SendSpecial(0x18);
serialTimerState = tsSet2;
nextTime = 10;
break;
case tsSet2:
SendSpecial(0x10);
serialTimerState = tsSet3;
nextTime = 10;
break;
case tsSet3:
SendSpecial(0x03);
serialTimerState = tsToggle;
nextTime = 940;
serialActive = true;
serialGot = 1;
break;
}
sender->setTimeoutMS(nextTime); // Todo: Make it take into account function execution time?
serialHeard = false;
// Make it happen after the timer's set, for minimum impact
switch (serialGot)
{
case 1:
SerialConnect();
break;
case 2:
SerialDisconnect();
break;
default:
break;
}
}
int main( int argc, char **argv )
{
APIRET rc;
COMMAND cmd = {0,0};
int n;
char *cp;
char rc_string[12];
CONNECTION Connection;
EXCEPTIONREGISTRATIONRECORD reg_rec;
ESP_QUE_ELEMENT Qelement;
if( argc == 1 )
SayMsg(HELP_INVOCATION_ESP);
/****************************************************************************/
/* */
/* Parse the invocation options. */
/* */
/* - If this is a child debugger, then these additional parameters will */
/* precede the invocation parameters inherited from the parent. */
/* */
/* - /child=xxxxx where child = child debugger and */
/* xxxxx = child pid (for serial connections only.)*/
/* */
/* - /handle=xxxxx where handle = switch for com handle( serial only ) */
/* xxxxx = parent's com handle - inherited by */
/* the child. */
/* */
/****************************************************************************/
memset( &EspParms, 0, sizeof( ESP_PARMS ) );
memset( &Connection, 0, sizeof(Connection) );
if( strstr( argv[1], "/child" ) )
{
ParseEspChildOptions( argc, argv, &EspParms, &Connection );
}
else
{
ParseOptions( argc, argv, &EspParms, &Connection );
}
printf("\nESP Version 5.00 \n");fflush(0);
/****************************************************************************/
/* - Send connection info to the router. */
/****************************************************************************/
SendConnectionToRouter( &Connection );
/****************************************************************************/
/* - Make the connection. */
/****************************************************************************/
{
int RcMoreInfo = 0;
rc = ConnectInit( &RcMoreInfo );
if( rc != 0 )
{
char BadConnectMsg[32] = "";
int MsgId;
if( (Connection.ConnectType == _NETBIOS) && (RcMoreInfo != 0) )
{
/*************************************************************************/
/* - handle netbios specific connect errors. */
/*************************************************************************/
n = 1;
MsgId = ERR_NB_INADEQUATE_RESOURCES;
switch( RcMoreInfo )
{
case CANT_LOAD_NETB_DLL:
n = 0;
MsgId = ERR_NB_CANT_LOAD_DLL;
break;
case INADEQUATE_SESSIONS:
strcpy( BadConnectMsg,"sessions");
break;
case INADEQUATE_COMMANDS:
strcpy( BadConnectMsg,"commands");
break;
case INADEQUATE_NAMES:
strcpy( BadConnectMsg,"names");
break;
default:
n = 1;
MsgId = ERR_BAD_CONNECT;
sprintf( BadConnectMsg, "NetBios error rc=%d", rc );
break;
}
}
else if( (Connection.ConnectType == SOCKET) && (RcMoreInfo != 0) )
{
/*************************************************************************/
/* - handle tcpip specific connect errors. */
/*************************************************************************/
switch( RcMoreInfo )
{
case CANT_LOAD_TCPIP_DLL:
n = 1;
MsgId = ERR_TCPIP_CANT_LOAD_DLL;
sprintf( BadConnectMsg, "%d", rc );
break;
case TCPIP_NOT_RUNNING:
n = 0;
MsgId = ERR_TCPIP_NOT_RUNNING;
break;
case TCPIP_ERROR:
n = 0;
MsgId = ERR_TCPIP_ERROR;
break;
case TCPIP_NO_SERVICES_PORT:
n = 0;
MsgId = ERR_TCPIP_NO_SERVICES_PORT;
break;
default:
n = 1;
MsgId = ERR_BAD_CONNECT;
sprintf( BadConnectMsg, "tcpip error rc=%d", rc );
break;
}
}
else
{
/*************************************************************************/
/* - handle generic connect errors. */
/*************************************************************************/
n = 1;
MsgId = ERR_BAD_CONNECT;
sprintf( BadConnectMsg, "rc=%d", rc );
}
ErrorPrintf( MsgId, n, BadConnectMsg );
}
}
/****************************************************************************/
/* - register an exception handler for the probe. */
/****************************************************************************/
reg_rec.ExceptionHandler = Handler;
DosSetExceptionHandler(®_rec);
/****************************************************************************/
/* - Add a connect sema4 for serial connections and wait to be posted. */
/****************************************************************************/
if( (SerialParallel() == SERIAL) && ( IsParent() == FALSE ) )
{
USHORT EspPid;
TIB *pTib;
PIB *pPib;
ALLPIDS *p;
SetComHandle( EspParms.handle );
DosGetInfoBlocks(&pTib,&pPib);
EspPid = (USHORT)pPib->pib_ulpid;
CreateConnectSema4( EspPid, _ESP );
SerialConnect( JUST_WAIT, 0, _ESP, SendMsgToEspQue );
p = GetEspPid( EspPid );
p->Connect = CONNECTED;
}
/****************************************************************************/
/* - Each child debugger will have a termination que so we can kill the */
/* child debuggers on quit/restart. */
/****************************************************************************/
if( IsParent() == FALSE )
{
rc = StartEspTermQue( );
if( rc != 0 )
{
sprintf(rc_string, "%d",rc);
ErrorPrintf( ERR_CANT_START_QUE, TRUE, 1, rc_string );
}
}
/****************************************************************************/
/* - Now, start the command processing loop. */
/****************************************************************************/
for(;;)
{
memset(&cmd,0,sizeof(cmd) );
RmtRecv(DEFAULT_HANDLE, (char*)&cmd, sizeof(cmd));
if( IsVerbose() ) PrintCmdMessage( cmd.api ) ;
switch( cmd.api )
{
case FINDEXE:
RxFindExe(cmd);
break;
case STARTUSER:
RxStartUser( cmd );
break;
case GOINIT:
RxGoInit(cmd);
break;
case GOENTRY:
RxGoEntry(cmd);
break;
case DEFBRK:
RxDefBrk(cmd);
break;
case UNDBRK:
RxUndBrk(cmd);
break;
case PUTINBRK:
RxPutInBrk(cmd);
break;
case PULLOUTBRK:
RxPullOutBrk(cmd);
break;
case INSERTALLBRK:
RxInsertAllBrk();
break;
case REMOVEALLBRK:
RxRemoveAllBrk();
break;
case SELECT_SESSION:
/*************************************************************************/
/* - Only the parent probe can select one of the debuggee sessions, so */
/* we send a message and tell him to do it. */
/*************************************************************************/
Qelement.ChildPid = GetEspProcessID();
SendMsgToEspQue( ESP_QMSG_SELECT_SESSION, &Qelement, sizeof(Qelement) );
memset(&cmd,0,sizeof(cmd) );
cmd.api = SELECT_SESSION;
RmtSend( DEFAULT_HANDLE, &cmd, sizeof(cmd) );
break;
case GOSTEP:
RxGoStep(cmd);
break;
case GOFAST:
RxGoFast(cmd);
break;
case DOSDEBUG:
RxDosDebug( cmd );
break;
case GETTHREADINFO:
RxGetThreadInfo( cmd );
break;
case FREEZETHREAD:
RxFreezeThread( cmd );
break;
case THAWTHREAD:
RxThawThread( cmd );
break;
case GETCALLSTACK:
RxGetCallStack(cmd);
break;
case GETEXEORDLLENTRY:
RxGetExeOrDllEntryOrExitPt(cmd);
break;
case NORMALQUIT:
RxNormalQuit(cmd);
/*************************************************************************/
/* - The que has to be up until after the normal quit because the */
/* system will need to post an end session message to the queue. */
/*************************************************************************/
if( IsParent() )
{
if( SingleMultiple() == MULTIPLE )
{
ALLPIDS *p;
/***********************************************************************/
/* - Send a message to all of the child probes telling them that */
/* they are going to be killed. */
/***********************************************************************/
for( p = GetAllpids(); p ; p = p->next )
{
if( (p->PidFlags.IsDebug) == TRUE && (p->pid != GetEspProcessID()) )
{
ESP_QUE_ELEMENT Qelement;
Qelement.ChildPid = p->EspPid;
SendMsgToEspTermQue(ESP_PROBE_TERM, &Qelement, sizeof(Qelement) );
}
}
/***********************************************************************/
/* - send a message to the que to kill all the child probes and */
/* then wait until they are all dead. */
/***********************************************************************/
ResetAllProbesAreDeadFlag( );
SendMsgToEspQue(ESP_QMSG_PARENT_TERM,NULL,0);
while( AllProbesAreDead() == FALSE ){ DosSleep(100) ;}
}
SendMsgToEspQue(ESP_QMSG_QUE_TERM,NULL,0);
}
CloseConnectSema4();
cmd.api = NORMALQUIT;
cmd.len = sizeof(rc);
/*************************************************************************/
/* - Now, tell dbg that we're finished normal quitting. */
/*************************************************************************/
RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
RmtSend(DEFAULT_HANDLE, &rc, cmd.len );
break;
case SETEXECADDR:
RxSetExecAddr(cmd);
break;
case DEFWPS:
RxDefWps(cmd);
break;
case PUTINWPS:
RxPutInWps(cmd);
break;
case PULLOUTWPS:
RxPullOutWps(cmd);
break;
case GETDATABYTES:
RxGetDataBytes(cmd);
break;
case GETMEMBLKS:
RxGetMemBlocks(cmd);
break;
case SETXCPTNOTIFY:
RxSetExceptions(cmd);
break;
case SETEXECTHREAD:
RxSetExecThread(cmd);
break;
case WRITEREGS:
RxWriteRegs(cmd);
break;
case GETCOREGS:
RxGetCoRegs(cmd);
break;
case SETESPRUNOPTS:
RxSetEspRunOpts(cmd);
break;
case TERMINATEESP:
if( IsParent() == FALSE )
{
memset( &Qelement, 0, sizeof(Qelement) );
Qelement.ChildPid = GetEspProcessID();
SendMsgToEspQue( ESP_QMSG_CHILD_TERM, &Qelement, sizeof(Qelement) );
}
DosUnsetExceptionHandler(®_rec);
RmtSend(DEFAULT_HANDLE, &cmd , sizeof(cmd) );
ConnectClose( DEFAULT_HANDLE );
exit(0);
break;
case START_QUE_LISTEN:
SendMsgToEspQue(ESP_QMSG_OPEN_CONNECT,NULL,0);
break;
case START_ESP_QUE:
RxStartEspQue(cmd);
break;
case CONNECT_ESP:
/*************************************************************************/
/* - Serial connection only. */
/*************************************************************************/
{
USHORT GoToPid;
USHORT YieldPid;
ALLPIDS *pYield;
ALLPIDS *pGoTo;
BOOL TorF;
/************************************************************************/
/* - Receive the pid to be connected and mark it connected. */
/* - If this pid has not yet been assigned to a probe, then pGoTo */
/* will be NULL. */
/* - There MUST be a probe with a pid==0, so we release that probe. */
/* ( The pid will be stuffed into the structure at goinit() time.) */
/* - Post the connect sema4 for the goto pid. */
/************************************************************************/
RmtRecv( DEFAULT_HANDLE, &GoToPid, cmd.len );
pGoTo = GetPid( GoToPid );
if( pGoTo == NULL )
pGoTo = GetPid(0);
pGoTo->Connect = CONNECTED;
TorF = TRUE;
if( GoToPid == GetEspProcessID() )
TorF = FALSE;
/************************************************************************/
/* - Send back verification that the connection has been made. */
/************************************************************************/
memset(&cmd,0,sizeof(cmd) );
cmd.api = SERIAL_POLL;
RmtSend( DEFAULT_HANDLE, &cmd, sizeof(cmd) );
PostConnectSema4( &pGoTo->ConnectSema4, TorF );
/************************************************************************/
/* - Disconnect/block this probe. */
/************************************************************************/
YieldPid = (USHORT)GetEspProcessID();
pYield = GetPid( YieldPid );
pYield->Connect = DISCONNECTED;
SerialConnect( SET_WAIT, YieldPid, _ESP, SendMsgToEspQue );
}
break;
case CTRL_BREAK:
{
USHORT ThisPid;
USHORT CtrlBreakPid;
RmtRecv( DEFAULT_HANDLE, &CtrlBreakPid, cmd.len );
ThisPid = (USHORT)GetEspProcessID();
Qelement.ChildPid = CtrlBreakPid;
Qelement.ChildSid = ThisPid;
SendMsgToEspQue(ESP_QMSG_CTRL_BREAK, &Qelement, sizeof(Qelement));
SerialConnect( SET_WAIT, ThisPid, _ESP, SendMsgToEspQue );
}
break;
case SERIAL_POLL:
ReportMessage();
break;
default:
cp = (char*)&cmd;
for( n=1; n<=sizeof(cmd); n++,cp++)
printf("%c",*cp);
AsyncFlushModem();
break;
}
}
}
