int psoaConnect( psoaConnector * pConnector,
const char * address,
struct qsrOutput * pAnswer,
psocErrorHandler * errorHandler )
{
int errcode = 0;
unsigned short port;
struct sockaddr_in addr;
long int dummy = 0;
#if defined (WIN32)
WORD versionRequested;
WSADATA wsaData;
#endif
struct qsrInput input;
PSO_PRE_CONDITION( pConnector != NULL );
PSO_PRE_CONDITION( address != NULL );
PSO_PRE_CONDITION( pAnswer != NULL );
PSO_PRE_CONDITION( errorHandler != NULL );
pConnector->socketFD = PSO_INVALID_SOCKET;
#if defined (WIN32)
pConnector->cleanupNeeded = false;
#endif
dummy = strtol( address, NULL, 10 );
if ( dummy <= 0 || dummy > 65535 ) return PSO_INVALID_QUASAR_ADDRESS;
port = (unsigned short) dummy;
#if defined (WIN32)
versionRequested = MAKEWORD( 2, 2 );
errcode = WSAStartup( versionRequested, &wsaData );
if ( errcode != 0 ) {
psocSetError( errorHandler, PSOC_SOCKERR_HANDLE, WSAGetLastError() );
return PSO_SOCKET_ERROR;
}
pConnector->cleanupNeeded = true;
#endif
pConnector->socketFD = socket( PF_INET, SOCK_STREAM, 0 );
if ( pConnector->socketFD == PSO_INVALID_SOCKET ) {
#if defined (WIN32)
psocSetError( errorHandler, PSOC_SOCKERR_HANDLE, WSAGetLastError() );
#else
psocSetError( errorHandler, PSOC_ERRNO_HANDLE, errno );
#endif
return PSO_SOCKET_ERROR;
}
memset( &addr, 0, sizeof(struct sockaddr_in) );
addr.sin_family = PF_INET;
addr.sin_port = htons( port );
addr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
errcode = connect( pConnector->socketFD,
(const struct sockaddr *)&addr,
sizeof addr );
if ( errcode != 0 ) {
#if defined (WIN32)
psocSetError( errorHandler, PSOC_SOCKERR_HANDLE, WSAGetLastError() );
#else
psocSetError( errorHandler, PSOC_ERRNO_HANDLE, errno );
#endif
return PSO_CONNECT_ERROR;
}
input.opcode = QSR_CONNECT;
input.processId = getpid();
errcode = Send( pConnector, &input, sizeof(struct qsrInput), errorHandler );
if ( errcode != 0 ) return PSO_SEND_ERROR;
errcode = Receive( pConnector, pAnswer, sizeof(struct qsrOutput), errorHandler );
if ( errcode != 0 ) return PSO_RECEIVE_ERROR;
return 0;
}
void handle_connection (Connection con, const char *peer, const char *now)
{
char tmps[33];
unsigned char mdc[16];
unsigned long tmp;
int genexp = 1;
longnum y;
struct message in, out;
int l;
struct timeval t;
struct tms t_times;
out.type = SC_Modulus;
memcpy (&out.body.sc_modulus.n, &n, sizeof(n));
fprintf (stderr, "-> %s: SC_Modulus\n", peer);
fflush (stderr);
Transmit (con, &out, sizeof (out));
while (1) {
if ((l=Receive (con, &in, sizeof (in))) != sizeof (in)) {
if (! l) {
fprintf (stderr, "<- %s: connection closed\n", peer);
} else {
fprintf (stderr, "<- %s: receive %d instead of %lu\n", peer, l, sizeof(in));
}
fflush (stderr);
return;
}
if (genexp) {
MD5_CTX c;
fprintf (stderr, "-- %s: Generating new exponent\n", peer);
fflush (stderr);
/* XXX Zufaelligen Exponenten erzeugen ... */
genexp = 0;
}
switch (in.type) {
case CS_Exp:
/* fprintf (stderr, "<- %s: CS_Exp\n", peer); */
out.body.sc_exp_r.timing =
LITModExp (&out.body.sc_exp_r.z, &in.body.cs_exp.x, &y, &n);
out.type = SC_ExpResp;
break;
case CS_Key:
fprintf (stderr, "<- %s: CS_Key ", peer);
memcpy (&out.body.sc_key_r.y, &y, sizeof (y));
out.type = SC_KeyResp;
out.body.sc_key_r.ok = ! LCompare (&y, &in.body.cs_key.y);
if (! out.body.sc_key_r.ok) fprintf (stderr, "not ");
fprintf (stderr, "ok\n");
fflush (stderr);
genexp = 1;
break;
default:
fprintf (stderr, "<- %s: unknown type %d\n", peer, in.type);
fflush (stderr);
return;
}
/* fprintf (stderr, "-> %s: response\n", peer); */
Transmit (con, &out, sizeof (out));
}
}
void uart1_sender_notifier() {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: enters" );
int* uart_flags = (int *)( UART1_BASE + UART_FLAG_OFFSET );
int* uart_data = (int *)( UART1_BASE + UART_DATA_OFFSET );
int* modem_ctrl = (int *)( UART1_BASE + UART_MDMCTL_OFFSET);
int* modem_status = (int *)( UART1_BASE + UART_MDMSTS_OFFSET);
int uart_flags_temp = 0;
int modem_ctrl_temp = 0;
int modem_status_temp = 0;
int sender_tid;
UART_request request;
//State machine variables
//CTS states:
// 0 - CTS is set to '1' before the character is sent
// 1 - CTS is set to '0' after the character is sent
// 2 - CTS is set to '1' after the character is sent
int cts_state = 0;
//Transmit states:
// 0 - Transmit is set to '0' right after the character is sent
// 1 - Transmit is set to '1' after the character is sent
int txfe_state = 0;
//Utility variables
int first_request = 1;
int first_iter = 1;
FOREVER {
//Get request with character from the uart1_sender_server
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for request..." );
Receive(&sender_tid, (char *) &request, sizeof(request));
//Reply, to unblock the uart1_sender_server
Reply(sender_tid, (char *) 0, 0);
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Received send request." );
//Reinitialize modem
//RTSn pin is set to low
//DTRn pin is set to low
modem_ctrl_temp = *modem_ctrl;
*modem_ctrl = modem_ctrl_temp | 3;
//Initialize the state machine
cts_state = 0;
txfe_state = 0;
first_iter = 1;
FOREVER {
//*uart_data = 'b';
//Wait until UART1 is ready to receive a character
if(txfe_state == 0 || first_iter) {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for INIT event." );
AwaitEvent(UART1_INIT_SEND, 0);
}
else {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for SEND READY event." );
AwaitEvent(UART1_SEND_READY, 0);
}
//*uart_data = 'd';
first_iter = 0;
//txfe_state = 1;
//*uart_data = 'e';
modem_status_temp = *modem_status;
uart_flags_temp = *uart_flags;
//Changing state of the state machine////////////////////
// bwprintf( COM2, "STATE00: CTS: %d TXFE: %d\n", cts_state, txfe_state );
//IF CTS value has changed
//AND CTS value is now set to '1'
//THEN CTS has been reasserted
if( ((modem_status_temp & DCTS_MASK) || first_request)
&& (uart_flags_temp & CTS_MASK)) {
cts_state = 2;
// bwprintf( COM2, "STATE03: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS value is set to '0'
//THEN CTS has been deasserted
if( cts_state == 0 && !(uart_flags_temp & CTS_MASK) ) {
cts_state = 1;
// bwprintf( COM2, "STATE02: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS has been deasserted
//AND CTS value is now set to '1'
//THEN CTS has been reasserted
if( cts_state == 1 && (uart_flags_temp & CTS_MASK) ) {
cts_state = 2;
// bwprintf( COM2, "STATE04: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF transmit is set to '1'
if( (uart_flags_temp & TXFE_MASK) ) {
txfe_state = 1;
// bwprintf( COM2, "STATE01: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS has been reasserted
//AND Transmit has been reasserted
//THEN Send the character to UART1
if( cts_state == 2 && txfe_state == 1 ) {
*uart_data = (char) request.ch;
first_request = 0;
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Sending data" );
break;
}
}
}
}
void USCI_SLAVE_SETUP(void){
P3SEL |= 0x06; // Assign I2C pins to USCI_B0
Setup_RX();
Receive();
}
bool TcpClient::ReceivePacket(NetPacket* packet)
{
//TODO: Every packet requires at least two Receive call, using an internal buffer of a fixed size would prevent this
NazaraAssert(packet, "Invalid packet");
if (!m_pendingPacket.headerReceived)
{
m_pendingPacket.data.Resize(NetPacket::HeaderSize);
std::size_t received;
if (!Receive(&m_pendingPacket.data[m_pendingPacket.received], NetPacket::HeaderSize - m_pendingPacket.received, &received))
return false;
m_pendingPacket.received += received;
//TODO: Should never happen in production !
NazaraAssert(m_pendingPacket.received <= NetPacket::HeaderSize, "Received more data than header size");
if (m_pendingPacket.received >= NetPacket::HeaderSize)
{
UInt16 size;
if (!NetPacket::DecodeHeader(m_pendingPacket.data.GetConstBuffer(), &size, &m_pendingPacket.netcode))
{
m_lastError = SocketError_Packet;
NazaraWarning("Invalid header data");
return false;
}
m_pendingPacket.data.Resize(size - NetPacket::HeaderSize);
m_pendingPacket.headerReceived = true;
m_pendingPacket.received = 0;
}
}
// We may have just received the header now
if (m_pendingPacket.headerReceived)
{
UInt16 packetSize = static_cast<UInt16>(m_pendingPacket.data.GetSize()); //< Total packet size
if (packetSize == 0)
{
// Special case: our packet carry no data
packet->Reset(m_pendingPacket.netcode);
// And reset every state
m_pendingPacket.data.Clear();
m_pendingPacket.headerReceived = false;
m_pendingPacket.received = 0;
return true;
}
std::size_t received;
if (!Receive(&m_pendingPacket.data[m_pendingPacket.received], packetSize - m_pendingPacket.received, &received))
return false;
m_pendingPacket.received += received;
//TODO: Should never happen in production !
NazaraAssert(m_pendingPacket.received <= packetSize, "Received more data than packet size");
if (m_pendingPacket.received >= packetSize)
{
// Okay we received the whole packet, copy it
packet->Reset(m_pendingPacket.netcode, m_pendingPacket.data.GetConstBuffer(), m_pendingPacket.data.GetSize());
// And reset every state
m_pendingPacket.data.Clear();
m_pendingPacket.headerReceived = false;
m_pendingPacket.received = 0;
return true;
}
}
return false;
}
void PipeReader::Pump()
{
char buf[PUMP_BUFFER_SIZE];
bool pljtmpOnce = 0;
connected = true;
while (g_shutdown == false)
{
int received = 0;
int sent = 0;
if (!wait.read)
{
//
// If there's room in the recieve buffer, attempt to receive
// some.
int receivable = receiveBuffer.QueryInsertable();
if (receivable != 0)
{
if ((received = Receive(buf, receivable)) != 0)
{
if (receiveDataSeen == false)
{
printf("pipe connected.\n");
log->Log(TAG_READ_DBG, tag, "Recieve data from debugger.\n");
receiveDataSeen = true;
}
log->Log(TAG_READ, tag, received, buf);
if (sender->Connected() == false)
{
// Ignore all incoming data until there is something
// connected to send it to.
printf("pipereader: dropping %d bytes because socket is not connected.\n",
received);
log->Log(TAG_READ_DBG, tag,
"dropping %d bytes because socket is not connected.\n",
received);
received = 0;
}
if (resetAckExpected)
{
// Ignore all incoming data until the other side tells
// us a reset ack has been seen.
log->Log(TAG_READ_DBG, tag,
"dropping %d bytes, waiting for reset ack from target.\n",
received);
received = 0;
}
int count = CheckForResetPacket(buf, received);
if (count != 0)
{
log->Log(TAG_READ_DBG, tag, "RESET packet received.\n");
if (!resetAckExpected)
{
printf("debugger sent RESET.\n");
}
// Truncate received data to end of reset packet. We
// discard all remaining data until we see a reset ack
// from the other end. Note: On send the reset packet
// is usually followed by 8 bytes of zero, the target
// seems to depend on it ... and being as we truncated
// and we don't know we got them all yet anyway and we
// will drop all further data until we see something,
// better send the zeros along.
receiveBuffer.Insert(buf, count);
int z = 0;
receiveBuffer.Insert((char *)&z, sizeof(z));
receiveBuffer.Insert((char *)&z, sizeof(z));
received = 0;
SetResetAckExpected(true);
}
receiveBuffer.Insert(buf, received);
}
}
}
if (!wait.write)
{
//
// Attempt to send.
//
// Note: The Send routine will take care of the no data case.
//
sent = sender->Send(&receiveBuffer);
}
if (!(sent | received))
{
//
// Nothing sent, nothing received, wait until something happens
// on one end or the other.
//
Wait();
}
}
connected = false;
}
void COAK10Socket::OnReceive(int nErrorCode)
{
CHiddenWnd* pWnd = (CHiddenWnd*)AfxGetApp()->m_pMainWnd;
CString s;
INT iCRAt, iReceived, iLen;
DWORD dwCurrentTicks, dwDiff;
bool bPostPacket;
iReceived = Receive(&m_cIncomingBuffer[m_iBufferLength],m_iBufferMaxLength - m_iBufferLength);
m_iBufferLength += iReceived;
s = m_cIncomingBuffer;
iCRAt = s.Find(13);
while (iCRAt != -1)
{
s = s.Left(iCRAt + 1);
iLen = s.GetLength();
m_iBufferLength -= iLen;
memcpy(&m_cIncomingBuffer[0],&m_cIncomingBuffer[iLen],m_iBufferLength);
memset(&m_cIncomingBuffer[m_iBufferLength],0,m_iBufferMaxLength - m_iBufferLength);
dwCurrentTicks = ::GetTickCount();
if (dwCurrentTicks < m_dwLastPacketReceive)
{ // ticks have turned over so reverse the math
dwDiff = m_dwLastPacketReceive - dwCurrentTicks;
}
else
{
dwDiff = dwCurrentTicks - m_dwLastPacketReceive;
}
if (dwDiff >= m_dwMinimumPacketInterval)
{
bPostPacket = true;
}
else
{
bPostPacket = false;
if (m_pOwner)
{
DebugTell("COAK10Socket::OnReceive: data skipped from %d:%s,%d at %s:%d...",
m_pOwner->m_nRoomId,m_pOwner->m_sRoomName,m_pOwner->m_nCardReaderId,
m_pOwner->m_sAddress, m_pOwner->m_usPort);
DebugTell("\tskipped data: %s",s);
}
else
{
DebugTell("COAK10Socket::OnReceive: data skipped from UNKNOWN: %s",s);
}
}
if (bPostPacket)
{
pWnd->PostMessage(UDS_MESSAGE,(WPARAM)_strdup((LPCTSTR)s),(LPARAM)m_nCardReaderId);
}
m_dwLastPacketReceive = dwCurrentTicks;
s = m_cIncomingBuffer;
iCRAt = s.Find(13);
}
/*
if (iCRAt != -1)
{
s = s.Left(iCRAt + 1);
iLen = s.GetLength();
m_iBufferLength -= iLen;
memcpy(&m_cIncomingBuffer[0],&m_cIncomingBuffer[iLen],m_iBufferLength);
memset(&m_cIncomingBuffer[m_iBufferLength],0,m_iBufferMaxLength - m_iBufferLength);
pWnd->PostMessage(UDS_MESSAGE,(WPARAM)_strdup((LPCTSTR)s),(LPARAM)m_nCardReaderId);
}
*/
//CCardReaderSocket::OnReceive(nErrorCode);
UNREFERENCED_PARAMETER(nErrorCode);
}
void genResponse(int cid) {
int power = motor[motorA];
float temp = 0.0;
string tmpString;
int index = 0;
ubyte linebuff[20];
StringFromChars(tmpString,rxbuffer);
index = StringFind(tmpString, "/");
StringDelete(tmpString, 0, index);
index = StringFind(tmpString, "HTTP");
StringDelete(tmpString, index, strlen(tmpString));
writeDebugStreamLine("Request:%s", tmpString);
nxtDisplayTextLine(2, "Request: ");
nxtDisplayTextLine(3, tmpString);
if (StringFind(tmpString, "MOTA") > 0) {
StringDelete(tmpString, 0, 6);
index = StringFind(tmpString, " ");
if (index > -1)
StringDelete(tmpString, index, strlen(tmpString));
//power = RC_atoix(tmpString);
power = clip(atoi(tmpString), -100, 100);
writeDebugStreamLine("Power:%d", power);
} else {
writeDebugStreamLine("NO POWER: %s", tmpString);
}
sendHeader(cid);
while(nxtHS_Status == HS_SENDING) wait1Msec(5);
wait1Msec(100);
index = 0;
linebuff[0] = 27; // escape;
linebuff[1] = 'S'; // the CID;
linebuff[2] = (ubyte)cid + 48; // the CID;
index = appendToBuff(buffer, index, linebuff, 3);
StringFormat(tmpString, "MotorA=%d\n", power);
memcpy(linebuff, tmpString, strlen(tmpString));
index = appendToBuff(buffer, index, linebuff, strlen(tmpString));
DTMPreadTemp(DTMP, temp);
StringFormat(tmpString, "Temp: %2.2f C", temp);
memcpy(linebuff, tmpString, strlen(tmpString));
index = appendToBuff(buffer, index, linebuff, strlen(tmpString));
linebuff[0] = 27; // escape;
linebuff[1] = 'E'; // the CID;
index = appendToBuff(buffer, index, endmarker, 2);
writeRawHS(buffer, index);
if (power != 0) nMotorEncoderTarget[motorA] = 2000;
motor[motorA] = power;
if (power > 0)
SensorType[COLOUR] = sensorCOLORGREEN;
else if (power < 0)
SensorType[COLOUR] = sensorCOLORBLUE;
else if (nMotorRunState[motorA] == runStateIdle)
SensorType[COLOUR] = sensorCOLORRED;
else
SensorType[COLOUR] = sensorCOLORRED;
wait1Msec(300);
clear_read_buffer();
closeConn(1);
memset(rxbuffer, 0, sizeof(rxbuffer));
//wait1Msec(100);
Receive();
//clear_read_buffer();
}
void SocketsToSDL::RunThread()
{
#ifdef WIN32
FD_SET fdRead;
int fd_max = -1;
#else
fd_set fdRead;
fd_set fdWrite;
int fd_max = m_Read_Sign;
#endif
while (!m_bTerminate)
{
FD_ZERO(&fdRead);
#ifndef WIN32
FD_ZERO(&fdWrite);
#endif
int iNum = m_SocketHandles.size();
for (int i = 0; i < iNum; i++)
{
SOCK_HANDLE * pHandle = m_SocketHandles[i];
int socket = pHandle->socket;
FD_SET(socket, &fdRead);
#ifndef WIN32
FD_SET(socket, &fdWrite);
#endif
fd_max = fd_max > socket? fd_max : socket;
}
FD_SET(m_Read_Sign, &fdRead);
#ifdef WIN32
if (select(0, &fdRead, NULL, NULL, NULL) == SOCKET_ERROR)
#else
if (select(fd_max+1, &fdRead, &fdWrite, NULL, NULL) == SOCKET_ERROR)
#endif
{
goto SOCKET_WRONG;
}
bool bSend = FD_ISSET(m_Read_Sign, &fdRead);
if (bSend)
{
unsigned char buffer[8];
int bytes_read = 0;
do
{
bytes_read = recv(m_Read_Sign, (char *)buffer, sizeof(buffer), 0);
} while (bytes_read > 0);
for (int i = 0; i < iNum; i++)
{
SOCK_HANDLE * pHandle = m_SocketHandles[i];
if(!Send(pHandle))
goto SOCKET_WRONG;
}
}
for (int i = 0; i < iNum; i++)
{
SOCK_HANDLE * pHandle = m_SocketHandles[i];
if (FD_ISSET(pHandle->socket, &fdRead))
{
if(!Receive(pHandle))
goto SOCKET_WRONG;
}
}
}
return;
SOCKET_WRONG:
m_bTerminate = true;
CloseSockets();
if(m_pNetwork)
m_pNetwork->onNetworkBroken();
return;
}
void Debug_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
DbgContext * const dbg = getDbgContextThreadSpecific();
glesv2debugger::Message msg, cmd;
msg.set_context_id(reinterpret_cast<int>(dbg));
msg.set_type(glesv2debugger::Message_Type_BeforeCall);
bool expectResponse = dbg->expectResponse.Bit(glesv2debugger::Message_Function_glDrawElements);
msg.set_expect_response(expectResponse);
msg.set_function(glesv2debugger::Message_Function_glDrawElements);
msg.set_arg0(mode);
msg.set_arg1(count);
msg.set_arg2(type);
msg.set_arg3(reinterpret_cast<int>(indices));
msg.set_arg7(dbg->maxAttrib); // indicate capturing vertex data
std::string * const data = msg.mutable_data();
if (GL_UNSIGNED_BYTE == type) {
if (dbg->indexBuffer) {
FetchIndexed(count, (unsigned char *)dbg->indexBuffer->data +
(unsigned long)indices, data, dbg);
} else {
FetchIndexed(count, (unsigned char *)indices, data, dbg);
}
} else if (GL_UNSIGNED_SHORT == type) {
if (dbg->indexBuffer) {
FetchIndexed(count, (unsigned short *)((char *)dbg->indexBuffer->data +
(unsigned long)indices), data, dbg);
} else {
FetchIndexed(count, (unsigned short *)indices, data, dbg);
}
} else {
assert(0);
}
void * pixels = NULL;
int viewport[4] = {};
cmd.set_function(glesv2debugger::Message_Function_CONTINUE);
cmd.set_expect_response(expectResponse);
glesv2debugger::Message_Function oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
while (true) {
msg.Clear();
nsecs_t c0 = systemTime(timeMode);
switch (cmd.function()) {
case glesv2debugger::Message_Function_CONTINUE:
dbg->hooks->gl.glDrawElements(mode, count, type, indices);
msg.set_time((systemTime(timeMode) - c0) * 1e-6f);
msg.set_context_id(reinterpret_cast<int>(dbg));
msg.set_function(glesv2debugger::Message_Function_glDrawElements);
msg.set_type(glesv2debugger::Message_Type_AfterCall);
msg.set_expect_response(expectResponse);
if (!expectResponse) {
cmd.set_function(glesv2debugger::Message_Function_SKIP);
cmd.set_expect_response(false);
}
oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
// TODO: pack glReadPixels data with vertex data instead of
// relying on separate call for transport, this would allow
// auto generated message loop using EXTEND_Debug macro
if (dbg->captureDraw > 0) {
dbg->captureDraw--;
dbg->hooks->gl.glGetIntegerv(GL_VIEWPORT, viewport);
pixels = dbg->GetReadPixelsBuffer(viewport[2] * viewport[3] *
dbg->readBytesPerPixel);
Debug_glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3],
GL_RGBA, GL_UNSIGNED_BYTE, pixels);
}
break;
case glesv2debugger::Message_Function_SKIP:
return;
case glesv2debugger::Message_Function_SETPROP:
SetProp(dbg, cmd);
expectResponse = cmd.expect_response();
if (!expectResponse) // SETPROP is "out of band"
cmd.set_function(oldCmd);
else
Receive(cmd);
break;
default:
GenerateCall(dbg, cmd, msg, NULL);
msg.set_expect_response(expectResponse);
if (!expectResponse) {
cmd.set_function(cmd.SKIP);
cmd.set_expect_response(expectResponse);
}
oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
break;
}
}
}
void Debug_glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
DbgContext * const dbg = getDbgContextThreadSpecific();
glesv2debugger::Message msg, cmd;
msg.set_context_id(reinterpret_cast<int>(dbg));
msg.set_type(glesv2debugger::Message_Type_BeforeCall);
bool expectResponse = dbg->expectResponse.Bit(glesv2debugger::Message_Function_glDrawArrays);
msg.set_expect_response(expectResponse);
msg.set_function(glesv2debugger::Message_Function_glDrawArrays);
msg.set_arg0(mode);
msg.set_arg1(first);
msg.set_arg2(count);
msg.set_arg7(dbg->maxAttrib); // indicate capturing vertex data
if (dbg->hasNonVBOAttribs) {
std::string * const data = msg.mutable_data();
for (unsigned i = 0; i < count; i++)
dbg->Fetch(i + first, data);
}
void * pixels = NULL;
int viewport[4] = {};
cmd.set_function(glesv2debugger::Message_Function_CONTINUE);
cmd.set_expect_response(expectResponse);
glesv2debugger::Message_Function oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
while (true) {
msg.Clear();
nsecs_t c0 = systemTime(timeMode);
switch (cmd.function()) {
case glesv2debugger::Message_Function_CONTINUE:
dbg->hooks->gl.glDrawArrays(mode, first, count);
msg.set_time((systemTime(timeMode) - c0) * 1e-6f);
msg.set_context_id(reinterpret_cast<int>(dbg));
msg.set_function(glesv2debugger::Message_Function_glDrawArrays);
msg.set_type(glesv2debugger::Message_Type_AfterCall);
msg.set_expect_response(expectResponse);
if (!expectResponse) {
cmd.set_function(glesv2debugger::Message_Function_SKIP);
cmd.set_expect_response(false);
}
oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
// TODO: pack glReadPixels data with vertex data instead of
// relying on sperate call for transport, this would allow
// auto generated message loop using EXTEND_Debug macro
if (dbg->captureDraw > 0) {
dbg->captureDraw--;
dbg->hooks->gl.glGetIntegerv(GL_VIEWPORT, viewport);
// ALOGD("glDrawArrays CAPTURE: x=%d y=%d width=%d height=%d format=0x%.4X type=0x%.4X",
// viewport[0], viewport[1], viewport[2], viewport[3], readFormat, readType);
pixels = dbg->GetReadPixelsBuffer(viewport[2] * viewport[3] *
dbg->readBytesPerPixel);
Debug_glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3],
GL_RGBA, GL_UNSIGNED_BYTE, pixels);
}
break;
case glesv2debugger::Message_Function_SKIP:
return;
case glesv2debugger::Message_Function_SETPROP:
SetProp(dbg, cmd);
expectResponse = cmd.expect_response();
if (!expectResponse) // SETPROP is "out of band"
cmd.set_function(oldCmd);
else
Receive(cmd);
break;
default:
GenerateCall(dbg, cmd, msg, NULL);
msg.set_expect_response(expectResponse);
if (!expectResponse) {
cmd.set_function(cmd.SKIP);
cmd.set_expect_response(expectResponse);
}
oldCmd = cmd.function();
Send(msg, cmd);
expectResponse = cmd.expect_response();
break;
}
}
}
void SocketConnection::WaitForClient() {
uint8_t junk[1];
Receive(junk, 1);
}
int main()
{
int j;
Message msg;
//Echo(strcat("b,SDRAM,",itoa(GetTick())));
for(j=0;j<128;j++) msg.msg[j]=j;
/*Comm BAB 1280*/
msg.length=128;
for(j=0;j<10;j++) Send(&msg,BAB_0);
//Echo(strcat("s,MPEG_m6(1280),",itoa(GetTick())));
/*Comm BAB 1280*/
msg.length=128;
for(j=0;j<10;j++) Receive(&msg,BAB_0);
//Echo(strcat("r,MPEG_m8(1280),",itoa(GetTick())));
/*Comm UPSAMP 15000*/
msg.length=128;
for(j=0;j<117;j++)
{
//Echo("SEND upsamp antes\n");
Send(&msg,UPSAMP_0);
//Echo("SEND upsamp depois\n");
}
msg.length=24;
Send(&msg,UPSAMP_0);
//Echo(strcat("s,MPEG_m9(15000),",itoa(GetTick())));
/*Comm UPSAMP 15000*/
msg.length=128;
for(j=0;j<117;j++)
{
//Echo("receive upsamp antes\n");
Receive(&msg,UPSAMP_0);
//Echo("receive upsamp depois\n");
}
msg.length=24;
Receive(&msg,UPSAMP_0);
//Echo(strcat("r,MPEG_m10(15000),",itoa(GetTick())));
/*Comm ADSP 1280*/
msg.length=128;
for(j=0;j<10;j++) Send(&msg,ADSP_0);
//Echo(strcat("s,MPEG_m11(1280),",itoa(GetTick())));
/*Comm MCPU 1280*/
msg.length=128;
for(j=0;j<10;j++) Send(&msg,MCPU_0);
//Echo(strcat("s,MPEG_m12(1280),",itoa(GetTick())));
/*Comm ADSP 1280*/
msg.length=128;
for(j=0;j<10;j++) Receive(&msg,ADSP_0);
//Echo(strcat("r,MPEG_m13(1280),",itoa(GetTick())));
/*Comm RAST 10130*/
msg.length=128;
for(j=0;j<79;j++) Send(&msg,RAST_0);
msg.length=18;
Send(&msg,RAST_0);
//Echo(strcat("s,MPEG_m16(10130),",itoa(GetTick())));
/*Comm RAST 10130*/
msg.length=128;
for(j=0;j<79;j++) Receive(&msg,RAST_0);
msg.length=18;
Receive(&msg,RAST_0);
//Echo(strcat("r,MPEG_m17(10130),",itoa(GetTick())));
/*Comm AU 1280*/
msg.length=128;
for(j=0;j<10;j++) Send(&msg,AU_0);
//Echo(strcat("s,MPEG_m18(1280),",itoa(GetTick())));
/*Comm VU 3210*/
msg.length=128;
for(j=0;j<25;j++) Send(&msg,VU_0);
msg.length=10;
Send(&msg,VU_0);
//Echo(strcat("s,MPEG_m19(3210),",itoa(GetTick())));
//Echo(strcat(strcat(strcat("i,",itoa(i)),","),itoa(GetTick())));
//Echo(strcat("e,SDRAM,",itoa(GetTick())));
exit();
}
void uart1_receiver_server() {
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_SERVER: enters" );
//Register the server
RegisterAs("uart1_receiver");
//Create the notifier
int notifier_tid = Create(UART1_RECEIVER_NOTIFIER_PRIORITY, &uart1_receiver_notifier);
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA,
"UART1_RECEIVER_SERVER: uart1_receiver_server_notifier created. [tid: %d priority: %d]",
notifier_tid, UART1_RECEIVER_NOTIFIER_PRIORITY );
//Request & Reply
UART_request request;
UART_reply reply;
//Buffers
Char_queue cqueue;
init_char_queue( &cqueue );
Int_queue iqueue;
init_int_queue( &iqueue );
FOREVER {
//Utility functions for communication
int sender_tid = -1;
int target_tid = -1;
//Receive request from:
// system function (Getc)
// notifier (uart1_receiver_notifier)
//bwprintf( COM2, "A\n" );
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_SERVER: Waiting for request" );
Receive(&sender_tid, (char *) &request, sizeof(request));
switch(request.type){
case UART1_RECEIVE_REQUEST:
//Enqueue the system function tid to reply later
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_SERVER: Getc request from [sender_tid: %d]",
sender_tid );
//bwprintf( COM2, "B\n" );
enqueue_int_queue( sender_tid, &iqueue );
break;
case UART1_RECEIVE_NOTIFIER_REQUEST:
//Reply to unblock the notifier
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_SERVER: message received from notifier" );
//bwprintf( COM2, "C\n" );
Reply(sender_tid, (char *) 0, 0);
//Enqueue received character
//if ( iqueue.size > 0 ){
//todo_debug( 0x7, 1 );
char_queue_push( request.ch, &cqueue );
//todo_debug( 0x8, 1 );
//}
break;
default:
// Invalid Request
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_SERVER: invalid request from [sender_tid: %d]",
sender_tid );
//bwprintf( COM2, "D\n" );
reply.type = INVALID_REQUEST;
reply.ch = 0;
Reply(sender_tid, (char *) &reply, sizeof(reply));
break;
}
//If there are system functions to receive
//and characters to be sent
while(iqueue.size > 0 && cqueue.size > 0) {
//Prepare the reply to the system function
target_tid = dequeue_int_queue( &iqueue );
reply.type = UART1_RECEIVE_REPLY;
reply.ch = char_queue_pop( &cqueue );
//Perform the reply
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECIEVER_SERVER: replying [to: %d with: %d]",
target_tid, reply.ch );
//bwprintf( COM2, "E\n" );
Reply(target_tid, (char *) &reply, sizeof(reply));
}
}
}
virtual void OnRead()
{
TRACE("OnRead\n");
char buf[512];
int nRead = Receive(buf, 1);
m_data += buf;
// ::MessageBox(NULL, buf, NULL, MB_OK);
for (int i = 0; i < nRead; i++)
{
TRACE("%c", buf[i]);
}
const char* end = strstr(m_data.c_str(), "\r\n");
if (end)
{
//std::string response = std::string(m_data, end - m_data.c_str());
//m_response = end + 2;
}
#if 0
if (m_state == STATE_CONNECT)
{
if (!strncmp(m_response.c_str(), "+OK", 3))
{
// The server has greeted us
// Let's identify ourselves
m_state = STATE_USER;
m_response = "";
}
}
else if (m_state == STATE_USER)
{
if (!strncmp(m_response.c_str(), "+OK", 3))
{
// Username has been accepted
// Send the password
m_state = STATE_PASS;
m_response = "";
// char* msg = "PASS 04bi1u6\r\n";
// send(m_socket, msg, strlen(msg), 0);
}
/*
else
{
char* msg = "QUIT\r\n";
send(m_socket, msg, strlen(msg), 0);
}
*/
}
else if (m_state == STATE_PASS)
{
if (!strncmp(m_response.c_str(), "+OK", 3))
{
// Password has been accepted
m_state = STATE_LIST;
m_response = "";
#if 0
char* msg = "LIST\r\n";
send(m_socket, msg, strlen(msg), 0);
#endif
}
/*
else
{
char* msg = "QUIT\r\n";
send(m_socket, msg, strlen(msg), 0);
}
*/
}
/*
else if (m_state == STATE_LIST)
{
if (!strncmp(m_response.c_str(), "+OK", 3))
{
if (strstr(m_response.c_str(), "\r\n."))
{
char* msg = "QUIT\r\n";
send(m_socket, msg, strlen(msg), 0);
}
}
}
else
{
char* msg = "QUIT\r\n";
send(m_socket, msg, strlen(msg), 0);
}
*/
#endif
}
static int HandleReply(zloop_t *wloop, zmq_pollitem_t *item, void *arg) {
proto::Reply rep;
Receive(rep, item->socket);
//rep.PrintDebugString();
if(rep.has_errstr())
printf("Message from server: %s\n", rep.errstr().c_str());
if(rep.has_block()){
HandleNewBlock(rep.block());
}
if(rep.type() == proto::Request::GETWORK){
if(rep.has_work()){
HandleNewWork(rep.work());
}
}else if(rep.type() == proto::Request::SHARE){
unsigned length = gSharesSent[rep.reqid()];
gSharesSent.erase(rep.reqid());
switch(rep.error()){
case proto::Reply::NONE:
printf("Share accepted.\n");
gShares[length].accepted++;
break;
case proto::Reply::INVALID:
printf("Invalid share.\n");
gShares[length].invalid++;
break;
case proto::Reply::STALE:
printf("Stale share.\n");
gShares[length].stale++;
ReConnectSignals();
break;
case proto::Reply_ErrType_DUPLICATE:
printf("Duplicate share.\n");
gShares[length].duplicate++;
break;
default: break;
}
}else if(rep.type() == proto::Request::STATS){
if(rep.error() == proto::Reply::NONE)
{}//printf("Statistics accepted.\n");
else
printf("Statistics rejected.\n");
}else if(rep.type() == proto::Request::PING){
//printf("Received heartbeat.\n");
}
gHeartBeat = true;
return 0;
}
void
qsrWaitForConnections( qsrAcceptor * pAcceptor )
{
int errcode = 0;
fd_set readSet, writeSet;
int maxFD, fired;
struct timeval timeout;
unsigned int i;
bool rc;
PSO_PRE_CONDITION( pAcceptor != NULL );
/*
* NOTE: since socket handles, on Windows, are not integers, we will
* not used the handles as indices to the pAcceptor->dispatch array
*/
pAcceptor->dispatch[0].socketId = pAcceptor->socketFD;
pAcceptor->dispatch[0].pid = 0;
pAcceptor->dispatch[0].dataToBeWritten = false;
for ( i = 1; i < FD_SETSIZE; ++i ) {
pAcceptor->dispatch[i].socketId = PSO_INVALID_SOCKET;
pAcceptor->dispatch[i].pid = -1;
pAcceptor->dispatch[i].dataToBeWritten = false;
}
while ( true ) {
int zzz = 0;
if ( g_pQSR->controlWord & QSR_SHUTDOWN_REQUEST ) {
break;
}
timeout.tv_sec = 1;
timeout.tv_usec = 0;
FD_ZERO( &readSet );
FD_ZERO( &writeSet );
maxFD = 0;
for ( i = 0; i < FD_SETSIZE; ++i ) {
if ( pAcceptor->dispatch[i].socketId != PSO_INVALID_SOCKET) {
if ( pAcceptor->dispatch[i].dataToBeWritten == 0 ) {
FD_SET( pAcceptor->dispatch[i].socketId, &readSet);
zzz++;
}
else {
FD_SET( pAcceptor->dispatch[i].socketId, &writeSet);
zzz++;
}
#if ! defined (WIN32)
if ( pAcceptor->dispatch[i].socketId+1 > maxFD ) {
maxFD = pAcceptor->dispatch[i].socketId+1;
}
#endif
}
}
do {
fired = select( maxFD, &readSet, &writeSet, NULL, &timeout );
} while ( fired == -1 && errno == EINTR );
if ( fired == -1 ) {
qsrSendMessage( &pAcceptor->pQuasar->log,
QSR_ERROR,
"In function select(), error = %d",
GetSockError() );
errcode = -1;
break;
}
if ( fired == 0 ) continue;
/*
* Start with the socket listening for new connection requests
*/
if ( FD_ISSET( pAcceptor->socketFD, &readSet ) ) {
rc = Accept( pAcceptor );
PSO_POST_CONDITION( rc == true || rc == false );
if ( ! rc ) break;
fired--;
}
if ( fired == 0 ) continue;
/*
* Process all open sockets
*/
for ( i = 1; i < FD_SETSIZE; ++i ) {
if ( pAcceptor->dispatch[i].socketId != PSO_INVALID_SOCKET ) {
if ( FD_ISSET( pAcceptor->dispatch[i].socketId, &writeSet ) ) {
Send( pAcceptor, i );
fired--;
}
else if ( FD_ISSET( pAcceptor->dispatch[i].socketId, &readSet ) ) {
Receive( pAcceptor, i );
fired--;
}
}
if ( fired == 0 ) break;
}
}
// Cleanup (close all sockets)
for ( i = 0; i < FD_SETSIZE; ++i ) {
if ( pAcceptor->dispatch[i].socketId != PSO_INVALID_SOCKET ) {
#if defined (WIN32)
shutdown( pAcceptor->dispatch[i].socketId, SD_BOTH );
closesocket( pAcceptor->dispatch[i].socketId );
#else
shutdown( pAcceptor->dispatch[i].socketId, 2 );
close( pAcceptor->dispatch[i].socketId );
#endif
}
}
pAcceptor->socketFD = PSO_INVALID_SOCKET;
}
int main(void) {
gBlock.set_height(0);
gClientName = sysinfo::GetClientName();
gClientID = sysinfo::GetClientID();
gInstanceID = gClientID * (unsigned)time(0);
srand(gInstanceID);
std::string frontHost;
unsigned frontPort;
Configuration* cfg = Configuration::create();
try{
cfg->parse("config.txt");
frontHost = cfg->lookupString("", "server", "localhost");
frontPort = cfg->lookupInt("", "port", 6666);
gAddr = cfg->lookupString("", "address", "");
gClientName = cfg->lookupString("", "name", gClientName.c_str());
}catch(const ConfigurationException& ex){
printf("ERROR: %s\n", ex.c_str());
printf("hit return to exit...\n");
std::string line;
std::getline(std::cin, line);
exit(EXIT_FAILURE);
}
if(!gClientName.size())
gClientName = sysinfo::GetClientName();
printf("madPrimeMiner-v%d.%d\n", gClientVersion/10, gClientVersion%10);
printf("ClientName = '%s' ClientID = %u InstanceID = %u\n", gClientName.c_str(), gClientID, gInstanceID);
printf("Address = '%s'\n", gAddr.c_str());
if(!gAddr.size()){
printf("ERROR: address not specified in config.txt\n");
printf("hit return to exit...\n");
std::string line;
std::getline(std::cin, line);
exit(EXIT_FAILURE);
}
gCtx = zctx_new();
gWorkers = zsocket_new(gCtx, ZMQ_PULL);
zsocket_bind(gWorkers, "inproc://shares");
gClient = new XPMClient(gCtx);
gExit = !gClient->Initialize(cfg);
while(!gExit){
printf("Connecting to frontend: %s:%d ...\n", frontHost.c_str(), frontPort);
gBlock.Clear();
proto::Reply rep;
gExit = true;
while(gExit){
zsocket_destroy(gCtx, gFrontend);
gFrontend = zsocket_new(gCtx, ZMQ_DEALER);
int err = zsocket_connect(gFrontend, "tcp://%s:%d", frontHost.c_str(), frontPort);
if(err){
printf("ERROR: invalid hostname and/or port.\n");
exit(EXIT_FAILURE);
}
proto::Request req;
req.set_type(proto::Request::CONNECT);
req.set_reqid(++gNextReqID);
req.set_version(gClientVersion);
req.set_height(0);
GetNewReqNonce(req);
Send(req, gFrontend);
bool ready = zsocket_poll(gFrontend, 3*1000);
if(zctx_interrupted)
break;
if(!ready)
continue;
Receive(rep, gFrontend);
if(rep.error() != proto::Reply::NONE){
printf("ERROR: %s\n", proto::Reply::ErrType_Name(rep.error()).c_str());
if(rep.has_errstr())
printf("Message from server: %s\n", rep.errstr().c_str());
}
if(!rep.has_sinfo())
break;
gServerInfo = rep.sinfo();
bool ret = false;
ret |= !ConnectBitcoin();
ret |= !ConnectSignals();
if(ret)
break;
gExit = false;
}
zsocket_disconnect(gFrontend, "tcp://%s:%d", frontHost.c_str(), frontPort);
if(gExit)
break;
zloop_t* wloop = zloop_new();
zmq_pollitem_t item_server = {gServer, 0, ZMQ_POLLIN, 0};
int err = zloop_poller(wloop, &item_server, &HandleReply, 0);
assert(!err);
zmq_pollitem_t item_signals = {gSignals, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_signals, &HandleSignal, 0);
assert(!err);
zmq_pollitem_t item_workers = {gWorkers, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_workers, &HandleWorkers, 0);
assert(!err);
err = zloop_timer(wloop, 60*1000, 0, &HandleTimer, 0);
assert(err >= 0);
gHeartBeat = true;
gExit = true;
if(rep.has_block())
HandleNewBlock(rep.block());
else
RequestWork();
gClient->Toggle();
zloop_start(wloop);
gClient->Toggle();
zloop_destroy(&wloop);
zsocket_destroy(gCtx, gServer);
zsocket_destroy(gCtx, gSignals);
gServer = 0;
gSignals = 0;
}
delete gClient;
zsocket_destroy(gCtx, gWorkers);
zsocket_destroy(gCtx, gFrontend);
zctx_destroy(&gCtx);
return EXIT_SUCCESS;
}
void train_command_entry() {
RegisterAs(TRAIN_COMMAND);
int clock_tid = WhoIs(CLOCK_SERVER);
int uart_tid = WhoIs(UART_SERVER);
int sender_tid;
struct train_command_message msg;
while (1) {
int reply = 0;
Receive(&sender_tid, (char*)&msg, sizeof(msg));
switch (msg.command) {
case TRAIN_GO:
Putc(COM1, 0x60, uart_tid);
break;
case TRAIN_STOP:
Putc(COM1, 0x61, uart_tid);
break;
case TRAIN_SPEED:
if (msg.data1 <= 14) {
if (msg.data2 > 0 && msg.data2 <= 80) {
Putc(COM1, msg.data1 | 16, uart_tid);
Putc(COM1, msg.data2, uart_tid);
break;
}
}
// Error case
reply = -1;
break;
case TRAIN_REVERSE:
if (msg.data1 > 0 && msg.data1 <= 80) {
Putc(COM1, 0x0F, uart_tid);
Putc(COM1, msg.data1, uart_tid);
break;
}
// Error case
reply = -1;
break;
case TRAIN_READ_SENSORS:
if (msg.data1 > 0 && msg.data1 <= 31) {
Putc(COM1, 0x80 + msg.data1, uart_tid);
break;
}
// Error case
reply = -1;
break;
case TRAIN_RESET_SENSORS:
if (msg.data1 > 0 && msg.data1 <= 31) {
Putc(COM1, 192, uart_tid);
break;
}
// Error case
reply = -1;
break;
case TRAIN_SWITCH_CURVED:
Putc(COM1, 0x22, uart_tid);
Putc(COM1, msg.data1, uart_tid);
break;
case TRAIN_SWITCH_STRAIGHT:
Putc(COM1, 0x21, uart_tid);
Putc(COM1, msg.data1, uart_tid);
break;
case TRAIN_SOLENOID_OFF:
Putc(COM1, 0x20, uart_tid);
break;
default:
reply = -1;
break;
}
// delay between train commands
Delay(1, clock_tid); // 1 tick = 10ms
Reply(sender_tid, (char*)&reply, sizeof(reply));
}
Exit();
}
void sensors_server() {
bwdebug( DBG_SYS, SENSORS_SERVER_DEBUG_AREA, "SENSORS_SERVER: enters" );
RegisterAs( SENSORS_SERVER_NAME );
// Data structures
int notifier_tid, sender_tid;
char s88s[10], s88s_prev[10];
Sensor_history sensor_history;
Sensor_waiting_list sensors_waiting_list[ NUM_SENSORS ];
All_sensors_waiting_queue all_sensors_waiting_queue;
Sensor_server_data server_data;
server_data.sensor_history = &sensor_history;
server_data.sensor_waiting_list = sensors_waiting_list;
server_data.all_sensors_wait_queue = &all_sensors_waiting_queue;
// Messages
Sensor_msg sensor_msg;
Init_sensor_msg init_msg;
Sensor_id_list_reply sensor_id_list_reply;
// Initialization
init_sensor_data( s88s );
init_sensor_data( s88s_prev );
init_sensor_history( &sensor_history );
init_sensor_waiting_lists( sensors_waiting_list );
init_all_sensors_waiting_queue( &all_sensors_waiting_queue );
init_id_list_reply( &sensor_id_list_reply );
init_msg.sensor_data_buff = s88s;
init_msg.prev_sensor_data_buff = s88s_prev;
notifier_tid = Create( SENSOR_NOTIFIER_PRIORITY, sensors_server_notifier );
bwdebug( DBG_SYS, SENSORS_SERVER_DEBUG_AREA, "SENSORS_SERVER: sensors_server_notifier created [tid: %d priority: %d]",
notifier_tid, SENSOR_NOTIFIER_PRIORITY );
Send( notifier_tid, ( char * ) &init_msg, sizeof( init_msg ), 0, 0 );
FOREVER {
bwdebug( DBG_SYS, SENSORS_SERVER_DEBUG_AREA, "SENSORS_SERVER: listening for a request" );
Receive( &sender_tid, ( char * ) &sensor_msg, sizeof( sensor_msg ) );
switch( sensor_msg.type ){
case SENSOR_DATA_RECEIVED_MSG:
Reply( sender_tid, 0, 0 );
parse_sensors( s88s, s88s_prev, &server_data ); // If this slows down the server put it in a different task.
draw_sensor_history( &sensor_history );
store_previous_sensors( s88s, s88s_prev );
break;
case WAIT_SENSOR_CHANGE_MSG:
// Wait for a particular sensor to be triggered
wait_for_sensor( sensors_waiting_list, sender_tid, sensor_msg.sensor_group, sensor_msg.pin_id );
break;
case WAIT_ALL_SENSORS_CHANGE_MSG:
// Wait for any sensor to be triggered
wait_for_all_sensors( &all_sensors_waiting_queue, sender_tid );
break;
case GET_SENSOR_LIST_MSG:
// Get the list of sensors
bwdebug( DBG_USR, TEMP_DEBUG_AREA, "Received msg" );
Reply( sender_tid, ( char * ) &sensor_id_list_reply, sizeof( sensor_id_list_reply ) );
bwdebug( DBG_USR, TEMP_DEBUG_AREA, "Replying msg" );
default:
bwdebug( DBG_SYS, SENSORS_SERVER_DEBUG_AREA, "SENSORS_SERVER: Invalid request. [type: %d]", sensor_msg.type );
break;
}
}
}
void driver() {
Driver me;
initDriver(&me, 1);
unsigned int naggCount = 0;
unsigned int updateStoppingDistanceCount = 0;
for (;;) {
int tid = -1;
DriverMsg msg;
msg.data2 = -1;
msg.data3 = -1;
msg.replyTid = -1;
Receive(&tid, (char*)&msg, sizeof(DriverMsg));
if (tid != me.delayer && tid != me.stopDelayer) {
Reply(tid, (char*)1, 0);
}
const int replyTid = msg.replyTid;
switch (msg.type) {
case SET_SPEED: {
//TrainDebug(&me, "Set speed from msg");
trainSetSpeed(msg.data2,
getStoppingTime(&me),
(msg.data3 == DELAYER),
&me);
if (msg.data3 != DELAYER) {
//TrainDebug(&me, "Replied to %d", replyTid);
Reply(replyTid, (char*)1, 0);
sendUiReport(&me);
break;
} else if (me.route.length != 0) {
// Delayer came back. Reverse command completed
me.stopCommited = 0; // We're moving again.
// We've completed everything up to the reverse node.
me.routeRemaining = me.stopNode+1;
me.previousStopNode = me.routeRemaining;
me.distanceFromLastSensorAtPreviousStopNode = me.distanceFromLastSensor;
// Calculate the next stop node.
updateStopNode(&me);
me.nextSetSwitchNode = -1;
updateSetSwitch(&me);
// if the reverse is last node, nothing to do
// if it isn't.. it should speed up again.
}
}
case DELAYER: {
//TrainDebug(&me, "delayer come back.");
break;
}
case STOP_DELAYER: {
// To prevent the first receive from this delayer
if (me.lastSensorActualTime > 0 && me.speed == 0 && !me.isAding) {
TrainDebug(&me, "releasing reserveration");
int reserveStatus = reserveMoreTrack(&me, 1, 0);
if (reserveStatus == RESERVE_FAIL) {
TrainDebug(&me, "WARNING: unable to reserve during init");
}
}
break;
}
case SENSOR_TRIGGER: {
// only handle sensor reports in primary + secondary prediction if not position finding
int sensorReportValid = 0;
TrackLandmark conditionLandmark;
int condition;
int isSensorReserved = QueryIsSensorReserved(&me, msg.data2, msg.data3);
if (me.positionFinding) {
sensorReportValid = 1;
me.lastSensorUnexpected = 1;
//FinishPositionFinding(me.trainNum, me.trainController);
} else if (isSensorReserved) {
//TrainDebug(&me, "Predictions.");
for (int i = 0; i < me.numPredictions; i ++) {
TrackLandmark predictedSensor = me.predictions[i].sensor;
//printLandmark(&me, &predictedSensor);
if (predictedSensor.type == LANDMARK_SENSOR && predictedSensor.num1 == msg.data2 && predictedSensor.num2 == msg.data3) {
sensorReportValid = 1;
if (i != 0) {
TrainDebug(&me, "Trigger Secondary");
// secondary prediction, need to do something about them
conditionLandmark = me.predictions[i].conditionLandmark;
condition = me.predictions[i].condition;
me.lastSensorUnexpected = 1;
if (conditionLandmark.type == LANDMARK_SWITCH) {
TrackMsg setSwitch;
setSwitch.type = UPDATE_SWITCH_STATE;
TrainDebug(&me, "UPDATE SWITCH STATE");
setSwitch.landmark1 = conditionLandmark;
setSwitch.data = condition;
Send(me.trackManager, (char*)&setSwitch, sizeof(TrackMsg), (char *)1, 0);
}
// Stop and then try to reroute.
reroute(&me);
} else {
me.lastSensorUnexpected = 0;
}
}
}
}
if (sensorReportValid) {
updateRoute(&me, msg.data2, msg.data3);
me.lastSensorBox = msg.data2; // Box
me.lastSensorVal = msg.data3; // Val
me.lastSensorIsTerminal = 0;
me.lastSensorActualTime = msg.timestamp;
dynamicCalibration(&me);
me.lastSensorPredictedTime = me.nextSensorPredictedTime;
TrackNextSensorMsg trackMsg;
QueryNextSensor(&me, &trackMsg);
// Reserve the track above train and future (covers case of init)
for (int i = 0; i < trackMsg.numPred; i++) {
me.predictions[i] = trackMsg.predictions[i];
}
me.numPredictions = trackMsg.numPred;
int reserveStatus = reserveMoreTrack(&me, me.positionFinding, getStoppingDistance(&me));
if (reserveStatus == RESERVE_FAIL) {
if (!me.positionFinding) {
reroute(&me);
} else {
TrainDebug(&me, "WARNING: unable to reserve during init");
}
}
TrackSensorPrediction primaryPrediction = me.predictions[0];
me.calibrationStart = msg.timestamp;
me.calibrationDistance = primaryPrediction.dist;
int dPos = 50 * getVelocity(&me) / 100000.0;
me.lastSensorDistanceError = -(int)me.distanceToNextSensor - dPos;
me.distanceFromLastSensor = dPos;
me.distanceToNextSensor = primaryPrediction.dist - dPos;
me.lastPosUpdateTime = msg.timestamp;
if (primaryPrediction.sensor.type != LANDMARK_SENSOR &&
primaryPrediction.sensor.type != LANDMARK_END) {
TrainDebug(&me, "QUERY_NEXT_SENSOR_FROM_SENSOR ..bad");
}
me.nextSensorIsTerminal = (primaryPrediction.sensor.type == LANDMARK_END);
me.nextSensorBox = primaryPrediction.sensor.num1;
me.nextSensorVal = primaryPrediction.sensor.num2;
me.nextSensorPredictedTime =
msg.timestamp + me.distanceToNextSensor*100000 /
getVelocity(&me);
updatePosition(&me, msg.timestamp);
sendUiReport(&me);
if (me.positionFinding) {
trainSetSpeed(0, getStoppingTime(&me), 0, &me); // Found position, stop.
me.positionFinding = 0;
me.currentlyLost = 0;
}
}
break;
}
case NAVIGATE_NAGGER: {
updatePosition(&me, msg.timestamp);
if (me.routeRemaining != -1) {
if (!me.stopCommited) {
if (shouldStopNow(&me)) {
if (me.route.nodes[me.stopNode].num == REVERSE) {
//TrainDebug(&me, "Navi reversing.");
const int speed = -1;
trainSetSpeed(speed, getStoppingTime(&me), 0, &me);
}
else {
//TrainDebug(&me, "Navi Nagger stopping.");
const int speed = 0; // Set speed zero.
trainSetSpeed(speed, getStoppingTime(&me), 0, &me);
me.route.length = 0; // Finished the route.
me.testMode = 0;
}
me.stopCommited = 1;
me.useLastSensorNow = 0;
me.stopNow = 0;
me.stopSensorHit = 0;
} else {
if ((++updateStoppingDistanceCount & 15) == 0) updateStopNode(&me);
}
}
}
if (me.nextSetSwitchNode != -1 && (++me.setSwitchNaggerCount & 3) == 0) {
trySetSwitch_and_getNextSwitch(&me);
}
if (me.rerouteCountdown-- == 0) {
if (me.testMode) {
int reserveStatus = reserveMoreTrack(&me, 0, me.d[8][ACCELERATE][MAX_VAL]); // moving
if (reserveStatus == RESERVE_FAIL) {
reroute(&me);
} else {
me.nextSetSwitchNode = -1;
updateSetSwitch(&me);
trainSetSpeed(8, 0, 0, &me);
}
} else {
// reroute
if (me.route.length != 0) {
setRoute(&me, &(me.routeMsg));
}
}
}
if ((++naggCount & 15) == 0) sendUiReport(&me);
break;
}
case SET_ROUTE: {
Reply(replyTid, (char*)1, 0);
me.routeMsg = msg;
setRoute(&me, &msg);
break;
}
case BROADCAST_UPDATE_PREDICTION: {
updatePrediction(&me);
int reserveStatus = reserveMoreTrack(&me, 0, getStoppingDistance(&me)); // moving
if (reserveStatus == RESERVE_FAIL) {
reroute(&me);
}
break;
}
case BROADCAST_TEST_MODE: {
me.testMode = 1;
setRoute(&me, &msg);
break;
}
case FIND_POSITION: {
me.positionFinding = 1;
trainSetSpeed(5, 0, 0, &me);
break;
}
default: {
TrainDebug(&me, "Not suppported train message type.");
}
}
}
}
// CSysTimeSocket 成员函数
// CMySocket2 成员函数
void CSysTimeSocket::OnReceive(int nErrorCode)
{
// TODO: Add your specialized code here and/or call the base class
int ret=0;
ret = Receive(udp_buf,RcvFrameSize);
if(ret == RcvFrameSize)
{
unsigned short usCommand = 0;
byte ucCommand = 0;
int iPos = 26;
unsigned short usCRC16 = 0;
unsigned int uiSysTime = 0;
memcpy(&usCRC16, &udp_buf[RcvFrameSize - CRCSize], 2);
if (usCRC16 != get_crc_16(&udp_buf[FrameHeadSize], RcvFrameSize - FrameHeadSize - CRCCheckSize))
{
// return FALSE;
}
memcpy(&usCommand, &udp_buf[iPos], 2);
iPos += 2;
if (usCommand == SendQueryCmd)
{
// 查询本地时间，0x04命令
memcpy(&ucCommand, &udp_buf[iPos], 1);
iPos++;
if (ucCommand == 0x04)
{
memcpy(&uiSysTime, &udp_buf[iPos], 4);
m_uiSysTimeCount++;
if (m_uiSysTimeCount == 1)
{
m_uiSysTime = uiSysTime;
// 广播命令开始采样
m_uiIPAim = 0xffffffff;
TRACE(_T("查询到的本地时间%d"), m_uiSysTime);
OnADCStartSample(m_uiIPAim, m_uiSysTime);
}
}
else if (ucCommand == 0x17)
{
memcpy(&m_uiIPAim, &udp_buf[16], 4);
TRACE1("接收零漂矫正查询-仪器IP地址：%d\r\n", m_uiIPAim);
for (int i=0; i<GraphViewNum; i++)
{
ProcessMessages();
if (m_uiIPAim == 81 + i*10)
{
memcpy(&m_ucZeroDrift[i][0], &udp_buf[0x29], 2);
memcpy(&m_ucZeroDrift[i][2], &udp_buf[0x2c], 2);
memcpy(&m_ucZeroDrift[i][4], &udp_buf[0x2e], 2);
break;
}
}
}
}
}
CAsyncSocket::OnReceive(nErrorCode);
}
main(int argc, char *argv[]) {
unsigned short cr_com=0;
unsigned int Tpr=0;
unsigned int Tpr1=0;
unsigned int Tstart=0;
short OC4=0;
pid_t proxy;
FILE *out_fp = NULL;
timer_t id;
unsigned char chkSUM=0,N=0;
struct itimerspec timer;
struct sigevent event;
int K2count=0;//счетчик бафтов в буфере К2
while( (i=getopt(argc, argv, "t:s:") )!=-1) {
switch(i){
case 't' : TM=1; break;
case 's' : TS=1; break;
//case 'c' : sscanf(optarg,"%d",COR_T); break;
}//switch
}//while
delay(500);
open_shmem();
p->to41.PrM_K2=0;
if (TS) printf(" УСТАНОВЛЕН РЕЖИМ РАБОТЫ ПО СИГНАЛУ ТВК\n");
if (TM) printf(" УСТАНОВЛЕН РЕЖИМ РАБОТЫ БЕЗ ОЖИДАНИЯ КОМАНДЫ НАЧАЛА СС\n");
if (COR_T!=0) printf(" УСТАНОВЛЕНА КОРРЕКЦИЯ ПО ВРЕМЕНИ %d МИНУТ\n",COR_T);
// printf("TM=%d TS=%d COR_T=%d\n\n",TM,TS,COR_T);
COR_T=COR_T*60;
if (!TM)
{
//if ( ( out_fp = fopen( "//1/home/seversk/new31/k2_log", "w" ) ) == NULL )
// fprintf( stderr, "Couldn't create/open file. %s\n", strerror( errno ) );
printf("ОЖИДАНИЕ КОМАНДЫ НАЧАЛА СС \n");
while((p->from41.num_com!=1)&&(p->from41.num_com!=2)) delay(500);
}
proxy = qnx_proxy_attach( 0, 0, 0, -1 );
if( proxy == -1 ) {
printf( "Unable to attach proxy." );
return;
}
/* Attach to the timer */
event.sigev_signo = -proxy;
id = timer_create( CLOCK_REALTIME, &event );
if( id == -1 ) {
printf( "Unable to attach timer." );
return;
}
timer.it_value.tv_sec = 3L; //start after X sec
timer.it_value.tv_nsec = 0L;
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_nsec = 100*m_sec;
timer_settime( id, 0, &timer, NULL );
delay(1000);
Init_K2();
delay(500);
printf(" НАСТРОЙКА К2 команда %d\n",p->from41.num_com);
while(1)
{
pid=Receive(0,0,0); //получение всех системных сообщений
if (pid==proxy_DRV2)
{ //получили сообщение чтения данных из ПОСТ-3Ц
rd_cpcs_s.type=4;
rd_cpcs_s.cnl=chan2;
// выдача команды и прием данных
i=Send(pid_drv,&rd_cpcs_s,&rd_cpcs_r,sizeof(rd_cpcs_s),sizeof(rd_cpcs_r));
//printf("Ответ =");
//for(i=0;i<rd_cpcs_r.cnt;i++) printf(" %02x",rd_cpcs_r.uim.dt[i]);printf("\n");
// переформатирование
for (i=0;i<rd_cpcs_r.cnt;i++) buffer[i+K2count]=rd_cpcs_r.uim.dt[i];//дополним массив
//if ( out_fp != NULL )
// if ( fwrite( buffer+K2count, rd_cpcs_r.cnt, 1, out_fp ) != 1 )
// fprintf( stderr, "Failed to write to file. %s\n", strerror( errno ) );
K2count=K2count+rd_cpcs_r.cnt;//увеличим кол-во байт в буфере
}
if (pid==proxy)
{ //срабатывание таймера
Tcount++;
//for(i1=0;i1<K2count;i1++) printf("%x ",buffer[i1]);printf("\n");
//printf("com1=%2x ", c); //печать байта
//printf("count=%d\n",K2count);
if (K2count>4)
for(i=0;i<K2count;i++)
if (buffer[i]==0x55) //найден заголовок
{
N=buffer[i+1]; //кол-во байт в пакете без КС
if (K2count>N+i) //достаточное кол-во байт в буфере
{
//printf("N=%d \n",N);
//1_of_day=time(NULL);
//1strftime(b, 40 , "%T", localtime(&time_of_day));//D T
//1msec=div(Tcount,10);
//1printf("%s:%03d -->",b,msec.rem*100);
printf("%02x:%02x:%02x ", p->CEB[2]>>8,p->CEB[3]>>8,p->CEB[3]&0x00ff);
for(i1=0;i1<N;i1++) chkSUM+=buffer[i+i1]; //подсчет контр суммы
//printf("i=%d chkSUM=%x\n",i,chkSUM);
if (chkSUM!=buffer[N+i]) //если не совпадает контр сумма
{
printf(" error CHKSUM\n");//проверка контрольной суммы
K2count=chkSUM=0; //очистка буфера
break; //выходим и ждем дальше
}
//пришел правильный пакет
printf(" (");
for(i1=0;i1<N+1;i1++) printf("%x.",buffer[i1+i]);printf(")");
//анализ полученного пакета
switch(buffer[i+1])
{
case 4: if(buffer[i+2]==3)
{
//printf(" Получена квитанция - команда принята ");
//if(buffer[i+3]==0) {comOK[1]++;printf("ПРАВИЛЬНО");break;}
//else printf("неправильно");
if(buffer[i+3]==0) {comOK[1]++;printf("");break;}
else printf("");
}
else printf(" Получен неизвестный пакет");
break;
case 5: if(buffer[i+2]==2)
{
switch(buffer[i+3])
{
case 0x03 : printf(" ИЛС Сообщение принято - ");
if (buffer[i+4]==0) {printf("норма");comOK[0]=1;}
else printf("ненорма");
break;
case 0x06 : printf(" ЛК1 Сообщение принято - ");
if (buffer[i+4]==0) {printf("норма");comOK[17]=1;}
else printf("ненорма");
break;
case 0x18 : printf(" ЛК2 Сообщение принято - ");
if (buffer[i+4]==0) {printf("норма");comOK[5]=1;}
else printf("ненорма");
break;
case 0x01 : printf(" АвтК Сообщение принято - ");
if (buffer[i+4]==0) {printf("норма");comOK[7]=1;}
else printf("ненорма");
break;
case 0x02 : printf(" Дан.Н.НН - ");
if (buffer[i+4]&1) printf(" нет-ДанИ");
if (buffer[i+4]&2) printf(" нет-ДанП");
//printf("\n");
break;
case 0x010: printf(" ПРМ - ");
if (buffer[i+4]&0x01) {printf(" ПРС");p->to41.PrM_K2=1;}else p->to41.PrM_K2=0;
if (buffer[i+4]&0x02) printf(" СС");
if (buffer[i+4]&0x04) printf(" ЗС");
if (buffer[i+4]&0x08) printf(" СБ");
if (buffer[i+4]&0x10) {printf(" ИДК");p->to41.Pr_ZI_K2=1;}else p->to41.Pr_ZI_K2=0;
if (buffer[i+4]&0x20) printf(" ИДД");
if (buffer[i+4]&0x40) printf(" ВИ");
if (buffer[i+4]&0x80) printf(" ПС");
//printf("\n");
break;
}
}
else printf(" Получен неизвестный пакет");
break;
case 6: if(buffer[i+2]==2)
{
switch(buffer[i+3])
{
case 0x07 : OC4=buffer[i+5];OC4=(OC4<<8)|buffer[i+4];
printf(" ОСЧ - %6.3f м/с ",OC4*0.582);break;
//printf(" ОСЧ - %d м/с ",OC4);break;
case 0x11 : printf(" Pтек - %d ",buffer[i+4]);
if (buffer[i+4]>0) p->to41.UR_sign_K2=buffer[i+4]*3;
else p->to41.UR_sign_K2=0;
break;
case 0x73 : printf(" ПРМ1 - ");
if (buffer[i+4]&0x01) {printf(" ПРС");p->to41.PrM_K2=1;}else p->to41.PrM_K2=0;
if (buffer[i+4]&0x02) printf(" СС");
if (buffer[i+4]&0x04) printf(" ЗС");
if (buffer[i+4]&0x08) printf(" СБ");
if (buffer[i+4]&0x10) {printf(" ИДК");p->to41.Pr_ZI_K2=1;}else p->to41.Pr_ZI_K2=0;
if (buffer[i+4]&0x20) printf(" ИДД");
if (buffer[i+4]&0x40) printf(" ВИ");
if (buffer[i+4]&0x80) printf(" ПС");
if (buffer[i+5]&0x01) printf(" 27М1н");
if (buffer[i+5]&0x02) printf(" ПФ");
if (buffer[i+5]&0x04) printf(" РНС");
if (buffer[i+5]&0x08) printf(" РПС");
if (buffer[i+5]&0x10) printf(" РСС");
if (buffer[i+5]&0x20) printf(" ЗКС");
if (buffer[i+5]&0x40) printf(" ОСС");
if (buffer[i+5]&0x80) printf(" НС");
//printf("\n");
break;
}
}
else printf(" Получен неизвестный пакет");
break;
case 7: if(buffer[i+2]==2)
{
switch(buffer[i+3])
{
case 0x014: printf(" НУС Сообщение принято - ");
if (buffer[i+4]==0) {printf("норма");comOK[10]=1;}
else printf("ненорма");
comOK[10]=1;//!!!
break;
}
}
else printf(" Получен неизвестный пакет");
break;
case 0x1b:
if(buffer[i+2]==2)
{
printf("\n ");
if (buffer[i+5]||buffer[i+6]) printf("ГР=%02x%02x ",buffer[i+6],buffer[i+5]);
if (buffer[i+7]||buffer[i+8]) printf("НДИ=%02x%02x ",buffer[i+8],buffer[i+7]);
if (buffer[i+9]||buffer[i+10])printf("МН=%02x%02x ",buffer[i+10],buffer[i+9]);
if (buffer[i+19]||buffer[i+20]||buffer[i+21]) printf("ИИ=%02x%02x%02x ",buffer[i+21],buffer[i+20],buffer[i+19]);
if (buffer[i+24]) {printf("СИГ=%x ",buffer[i+24]);p->to41.GL_priem=1;} else p->to41.GL_priem=0;
if (buffer[i+25]) {printf("СРГ=%x ",buffer[i+25]);p->to41.GL_CP=1;} else p->to41.GL_CP=0;
if (buffer[i+26]) printf("СбСИГ=%x ",buffer[i+26]);
}
else printf(" Получен неизвестный пакет");
break;
}
printf("\n");
chkSUM=0;
K2count-=N+i+1; // сдвигаем данные в буфере
for(i1=0;i1<K2count;i1++) buffer[i1]=buffer[i+N+i1+1];
}
}
void Connection::Run()
{
Receive();
io_service.run();
}
void CSocketSend::OnReceive(int nErrorCode)
{
// TODO: ÔÚ´ËÌí¼ÓרÓôúÂëºÍ/»òµ÷ÓûùÀà
int ret=0;
unsigned short uiPort = 0;
unsigned short usADCDataPoint = 0;
unsigned short usADCDataPointMove = 0;
unsigned int uiIP = 0;
ret = Receive(m_ucudp_buf[m_usudp_count],256);
if(ret == 256)
{
CString strTemp = _T("");
unsigned int uiCommand = 0;
// 加入端口分发功能
memcpy(&uiPort, &m_ucudp_buf[m_usudp_count][24], 2);
if (uiPort == HeadFramePort)
{
memcpy(&uiCommand, &m_ucudp_buf[m_usudp_count][28], 1);
if (uiCommand == 0x01)
{
// 显示SN
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][29]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][30]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][31]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][32]);
m_csHeadFrameShow += strTemp;
m_csHeadFrameShow += _T("\t");
// 显示首包时刻
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][34]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][35]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][36]);
m_csHeadFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][37]);
m_csHeadFrameShow += strTemp;
m_csHeadFrameShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_HEADFRAMESHOW)->SetWindowText(m_csHeadFrameShow);
m_uiHeadFrameNum++;
strTemp.Format(_T("%d"),m_uiHeadFrameNum);
m_pwnd->GetDlgItem(IDC_STATIC_HEADFRAMENUM)->SetWindowText(strTemp);
}
}
else if (uiPort == IPSetPort)
{
memcpy(&uiCommand, &m_ucudp_buf[m_usudp_count][28], 1);
if (uiCommand == 0x01)
{
// 显示SN
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][29]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][30]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][31]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][32]);
m_csIPSetReturnShow += strTemp;
m_csIPSetReturnShow += _T("\t");
// 显示IP
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][34]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][35]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][36]);
m_csIPSetReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][37]);
m_csIPSetReturnShow += strTemp;
m_csIPSetReturnShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_IPSETRETURNSHOW)->SetWindowText(m_csIPSetReturnShow);
m_uiIPSetReturnNum++;
strTemp.Format(_T("%d"),m_uiIPSetReturnNum);
m_pwnd->GetDlgItem(IDC_STATIC_IPSETRETURNNUM)->SetWindowText(strTemp);
}
}
else if (uiPort == TailFramePort)
{
memcpy(&uiCommand, &m_ucudp_buf[m_usudp_count][33], 1);
if (uiCommand == 0x01)
{
// 显示SN
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][34]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][35]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][36]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][37]);
m_csTailFrameShow += strTemp;
m_csTailFrameShow += _T("\t");
// 显示IP
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][29]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][30]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][31]);
m_csTailFrameShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][32]);
m_csTailFrameShow += strTemp;
m_csTailFrameShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_TAILFRAMESHOW)->SetWindowText(m_csTailFrameShow);
m_uiTailFrameNum++;
strTemp.Format(_T("%d"),m_uiTailFrameNum);
m_pwnd->GetDlgItem(IDC_STATIC_TAILFRAMENUM)->SetWindowText(strTemp);
}
}
else if (uiPort == TailTimeFramePort)
{
memcpy(&uiCommand, &m_ucudp_buf[m_usudp_count][28], 1);
if (uiCommand == 0x01)
{ // 显示SN
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][29]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][30]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][31]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][32]);
m_csTailTimeReturnShow += strTemp;
m_csTailTimeReturnShow += _T(" ");
// 显示网络时间
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][34]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][35]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][36]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][37]);
m_csTailTimeReturnShow += strTemp;
m_csTailTimeReturnShow += _T(" ");
// 显示本地时间
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][39]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][40]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][41]);
m_csTailTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][42]);
m_csTailTimeReturnShow += strTemp;
// m_csTailTimeReturnShow += _T(" ");
// // 显示尾包接收发送时刻（前14位有效）
// strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][44]);
// m_csTailTimeReturnShow += strTemp;
// strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][45]);
// m_csTailTimeReturnShow += strTemp;
// strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][46]);
// m_csTailTimeReturnShow += strTemp;
// strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][47]);
// m_csTailTimeReturnShow += strTemp;
m_csTailTimeReturnShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_TAILTIMERETURNSHOW)->SetWindowText(m_csTailTimeReturnShow);
m_uiTailTimeReturnNum++;
strTemp.Format(_T("%d"),m_uiTailTimeReturnNum);
m_pwnd->GetDlgItem(IDC_STATIC_TAILTIMERETURNNUM)->SetWindowText(strTemp);
}
}
else if (uiPort == TimeSetPort)
{
memcpy(&uiCommand, &m_ucudp_buf[m_usudp_count][28], 1);
if (uiCommand == 0x05)
{
// 显示IP
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][16]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][17]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][18]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][19]);
m_csDelayTimeReturnShow += strTemp;
m_csDelayTimeReturnShow += _T(" ");
// 显示延时修正高位
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][29]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][30]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][31]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][32]);
m_csDelayTimeReturnShow += strTemp;
m_csDelayTimeReturnShow += _T(" ");
// 显示延时修正低位
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][34]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][35]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][36]);
m_csDelayTimeReturnShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][37]);
m_csDelayTimeReturnShow += strTemp;
m_csDelayTimeReturnShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_DELAYTIMERETURNSHOW)->SetWindowText(m_csDelayTimeReturnShow);
m_uiDelayTimeReturnNum++;
strTemp.Format(_T("%d"),m_uiDelayTimeReturnNum);
m_pwnd->GetDlgItem(IDC_STATIC_DELAYTIMERETURNNUM)->SetWindowText(strTemp);
}
}
else if (uiPort == ADSetReturnPort)
{
// 每次采集只有一个ADC设置应答帧
m_uiADCSetReturnNum++;
strTemp.Format(_T("%d"),m_uiADCSetReturnNum);
m_pwnd->GetDlgItem(IDC_STATIC_ADCSETRETURNNUM)->SetWindowText(strTemp);
}
else if (uiPort == ADRecPort)
{
// 显示IP
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][16]);
m_csADCDataRecShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][17]);
m_csADCDataRecShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][18]);
m_csADCDataRecShow += strTemp;
strTemp.Format(_T("%02x "),m_ucudp_buf[m_usudp_count][19]);
m_csADCDataRecShow += strTemp;
m_csADCDataRecShow += _T(" ");
// 显示ADC数据采样帧个数
m_uiADCDataRecNum++;
strTemp.Format(_T("%d"),m_uiADCDataRecNum);
m_pwnd->GetDlgItem(IDC_STATIC_ADCDATARECNUM)->SetWindowText(strTemp);
m_csADCDataRecShow += strTemp;
m_csADCDataRecShow += _T("\t");
memcpy(&usADCDataPoint, &m_ucudp_buf[m_usudp_count][28], 2);
strTemp.Format(_T("%d"),usADCDataPoint);
m_csADCDataRecShow += strTemp;
m_csADCDataRecShow += _T("\t");
memcpy(&uiIP, &m_ucudp_buf[m_usudp_count][16], 4);
if (uiIP == 81)
{
usADCDataPointMove = usADCDataPoint - m_usADCLastDataPoint[0];
m_usADCLastDataPoint[0] = usADCDataPoint;
}
else if (uiIP == 91)
{
usADCDataPointMove = usADCDataPoint - m_usADCLastDataPoint[1];
m_usADCLastDataPoint[1] = usADCDataPoint;
}
else if (uiIP == 101)
{
usADCDataPointMove = usADCDataPoint - m_usADCLastDataPoint[2];
m_usADCLastDataPoint[2] = usADCDataPoint;
}
else if (uiIP == 111)
{
usADCDataPointMove = usADCDataPoint - m_usADCLastDataPoint[3];
m_usADCLastDataPoint[3] = usADCDataPoint;
}
else
{
usADCDataPointMove = 0;
}
strTemp.Format(_T("%d"),usADCDataPointMove);
m_csADCDataRecShow += strTemp;
m_csADCDataRecShow += _T("\r\n");
m_pwnd->GetDlgItem(IDC_EDIT_ADCDATARECSHOW)->SetWindowText(m_csADCDataRecShow);
}
else
{
}
m_uiRecFrameNum++;
strTemp.Format(_T("%d"),m_uiRecFrameNum);
m_pWndTab->GetDlgItem(IDC_STATIC_RECFRAMENUM)->SetWindowText(strTemp);
if (m_bPortDistribution == TRUE)
{
// 开启端口分发功能
SendTo(m_ucudp_buf[m_usudp_count],256,uiPort,m_csIP);
}
else
{
SendTo(m_ucudp_buf[m_usudp_count],256,m_iSendPort,m_csIP);
}
m_pSaveFile->OnSaveSendData(m_ucudp_buf[m_usudp_count],256);
m_usudp_count +=1;
m_usudp_count = m_usudp_count%8;
}
// AsyncSelect(FD_READ); //提请一个“读”的网络事件
CSocket::OnReceive(nErrorCode);
}
main() {
int i, j;
int tid, tid1;
int send=13;
int reply=0;
int *pSend = &send;
int *pReply = &reply;
printf("delaying 20\n");
Delay(5);
printf("delay 20 finished >>\n");
printf("test tid %d pri %d parent tid %d\n", \
MyTid(), MyPriority(), MyParentTid());
tid = Receive(&i, sizeof(int));
printf("test received << %d \n", i);
if(i >1) {
tid1 = Create("Test", 10);
printf("Test %d created %d\n", MyTid(), tid1);
j = i - 1;
Send(tid1, &j, sizeof(int), &j, sizeof(int));
printf("Test %d gotBack %d\n", MyTid(),j);
i = i*j;
Reply(tid, &i, sizeof(int));
} else
Reply(tid, &i, sizeof(int));
while(1) {
Delay(40);
printf("test\n");
}
Exit();
*pSend = 6;
Send(tid, pSend, sizeof(int), pReply, sizeof(int));
printf("init replyied << %d \n", *pReply);
Exit();
for(i=0;i <10;i++) {
printf("init\n");
}
getchar();
Pass();
for(i=0;i <10;i++) {
printf("init\n");
}
getchar();
tid = Create("Init", 63);
printf("init is exiting new tid %d\n", tid);
printf("before send , send %d, reply %d\n", *pSend, *pReply);
Send(2, pSend, sizeof(int), pReply, sizeof(int));
printf("got replied , send %d, reply %d\n", *pSend, *pReply);
tid = Receive( pSend, 9);
printf("init received from tid %d\n", tid);
printf("init exitting...\n");
Exit();
}
int cgWinSocket::ReceiveData( void * pBuff, int nBuffLen )
{
return Receive(pBuff, nBuffLen);
}
void uart1_sender_server() {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_SERVER: enters" );
//Register the server
RegisterAs("uart1_sender");
//Create the notifier
int notifier_tid = Create(UART1_SENDER_NOTIFIER_PRIORITY, &uart1_sender_notifier);
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA,
"UART1_SENDER_SERVER: uart1 sender server notifier created. [tid: %d priority: %d]",
notifier_tid, UART1_SENDER_NOTIFIER_PRIORITY );
//Request & Reply
UART_request request;
UART_reply reply;
//Buffer queues
Char_queue cqueue;
init_char_queue( &cqueue );
FOREVER{
//Receive request from the system function (Putc)
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_SERVER: listening for a request" );
int sender_tid = -1;
Receive(&sender_tid, (char *) &request, sizeof(request));
switch(request.type){
case UART_SEND_REQUEST_PUTC:
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_SERVER: Putc request from [sender_tid: %d]",
sender_tid );
//Reply to unblock the system function (Putc)
//reply.type = UART1_SEND_REPLY;
//reply.ch = 0;
//Reply(sender_tid, (char *) &reply, sizeof(reply));
//bwprintf( COM2, "Before reply Sender: %d\n", sender_tid );
char_queue_push( request.ch, &cqueue );
Reply(sender_tid, 0, 0);
break;
default:
//Invalid request
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_SERVER: Invalid request from [sender_tid: %d]",
sender_tid );
reply.type = INVALID_REQUEST;
reply.ch = 0;
Reply(sender_tid, (char *) &reply, sizeof(reply));
break;
}
while( cqueue.size > 0){
request.type = UART1_SEND_NOTIFIER_REQUEST;
request.ch = char_queue_pop( &cqueue );
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_SERVER: Waking up notifier." );
Send( notifier_tid, (char *) &request, sizeof(request), 0, 0);
}
}
}
