//2006-10-05 - changed to support both SafetyPackets and regular Packets -MH void CarModel::CreateMessage(Packet * msg) { switch(msg->m_ePacketType) { default: case ptGeneric: { msg->m_ID.srcID.iSeqNumber = GetNextSequenceNumber(); msg->m_ID.srcID.ipCar = m_ipCar; msg->m_ID.iRXSeqNumber = (unsigned)-1; msg->m_ptTXPosition = m_ptPosition; msg->m_ipTX = m_ipCar; msg->m_ipRX = 0; msg->m_tTX = GetCurrentTime() + MakeTime(RandDouble(0., ToDouble(m_tDelay))); msg->m_tRX = msg->m_tTX; msg->m_iRSSI = PACKET_RSSI_UNAVAILABLE; msg->m_iSNR = PACKET_SNR_UNAVAILABLE; break; } case ptSafety: { ((SafetyPacket*)msg)->m_ID.srcID.iSeqNumber = GetNextSequenceNumber(); ((SafetyPacket*)msg)->m_ID.srcID.ipCar = m_ipCar; ((SafetyPacket*)msg)->m_ID.iRXSeqNumber = (unsigned)-1; // msg.m_eType = Message::MessageTypeNormal; ((SafetyPacket*)msg)->m_tTime = m_tTimestamp; ((SafetyPacket*)msg)->m_tLifetime = m_tDelay; ((SafetyPacket*)msg)->m_ptPosition = ((SafetyPacket*)msg)->m_ptTXPosition = m_ptPosition; ((SafetyPacket*)msg)->m_iSpeed = ((SafetyPacket*)msg)->m_iTXSpeed = m_iSpeed; ((SafetyPacket*)msg)->m_iHeading = ((SafetyPacket*)msg)->m_iTXHeading = m_iHeading; ((SafetyPacket*)msg)->m_iRecord = m_iCurrentRecord; g_pMapDB->GetRelativeRecord(((SafetyPacket*)msg)->m_iRecord, ((SafetyPacket*)msg)->m_iCountyCode); ((SafetyPacket*)msg)->m_iTXRecord = ((SafetyPacket*)msg)->m_iRecord; ((SafetyPacket*)msg)->m_iTXCountyCode = ((SafetyPacket*)msg)->m_iCountyCode; ((SafetyPacket*)msg)->m_cDirection = ((SafetyPacket*)msg)->m_cTXDirection = m_bForwards ? MESSAGE_DIRECTION_FORWARDS : MESSAGE_DIRECTION_BACKWARDS; ((SafetyPacket*)msg)->m_iShapePoint = ((SafetyPacket*)msg)->m_iTXShapePoint = m_iCRShapePoint; ((SafetyPacket*)msg)->m_fProgress = ((SafetyPacket*)msg)->m_fTXProgress = m_fCRProgress; ((SafetyPacket*)msg)->m_ipTX = m_ipCar; ((SafetyPacket*)msg)->m_ipRX = 0; ((SafetyPacket*)msg)->m_tTX = GetCurrentTime() + MakeTime(RandDouble(0., ToDouble(m_tDelay))); ((SafetyPacket*)msg)->m_tRX = ((SafetyPacket*)msg)->m_tTX; ((SafetyPacket*)msg)->m_iRSSI = PACKET_RSSI_UNAVAILABLE; ((SafetyPacket*)msg)->m_iSNR = PACKET_SNR_UNAVAILABLE; break; } } }
uint32 GetBootTime (void) { uint32 i; struct Tm tm; for (i=0; i <10000000; i++) if ((CMOS_READ (CMOS_CTRL_REG_A) & RTC_UIP) == 0) break; tm.sec = CMOS_READ (CMOS_SECONDS); tm.min = CMOS_READ (CMOS_MINUTES); tm.hour = CMOS_READ (CMOS_HOURS); tm.mday = CMOS_READ (CMOS_DATE_OF_MONTH); tm.mon = CMOS_READ (CMOS_MONTH); tm.year = CMOS_READ (CMOS_YEAR); if (!(CMOS_READ (CMOS_CTRL_REG_B) & RTC_DM_BINARY)) { BCD_TO_BIN (tm.sec); BCD_TO_BIN (tm.min); BCD_TO_BIN (tm.hour); BCD_TO_BIN (tm.mday); BCD_TO_BIN (tm.mon); BCD_TO_BIN (tm.year); } if ((tm.year += 1900) < 1970) tm.year += 100; tm.year -= 1900; tm.mon -=1; return MakeTime(&tm); }
int SimpleCommModel::ProcessEvent(SimEvent & event) { if (CarCommModel::ProcessEvent(event)) return 1; switch (event.GetEventID()) { case EVENT_CARCOMMMODEL_REBROADCAST: { RebroadcastMessage * pRBXMsg = (RebroadcastMessage *)event.GetEventData(); if (pRBXMsg != NULL) { struct timeval tNext = pRBXMsg->tIntervalHigh + (m_bJitter ? MakeTime(RandDouble(0., ToDouble(m_tRebroadcastInterval))) : m_tRebroadcastInterval); pRBXMsg->msg.m_tTX = event.GetTimestamp(); TransmitMessage(&(pRBXMsg->msg)); // only rebroadcast if there's time left pRBXMsg->tIntervalLow = pRBXMsg->tIntervalHigh; pRBXMsg->tIntervalHigh = pRBXMsg->tIntervalHigh + m_tRebroadcastInterval; if (pRBXMsg->msg.m_tTime + pRBXMsg->msg.m_tLifetime <= tNext) delete pRBXMsg; else { event.SetTimestamp(tNext); g_pSimulator->m_EventQueue.AddEvent(event); } } break; } default: break; } return 0; }
unsigned long long GetTime() { SYSTEMTIME local_system_time; unsigned long long time; GetLocalTime( &local_system_time ); if( !MakeTime( &time, local_system_time.wYear, local_system_time.wMonth, local_system_time.wDay, local_system_time.wHour, local_system_time.wMinute, local_system_time.wSecond, local_system_time.wMilliseconds ) ) return 0; return time; }
bool webvtt_scan_time( const char *psz, vlc_tick_t *p_time ) { unsigned t[4]; if( sscanf( psz, "%2u:%2u.%3u", &t[1], &t[2], &t[3] ) == 3 ) { t[0] = 0; *p_time = MakeTime( t ); return true; } else if( sscanf( psz, "%u:%2u:%2u.%3u", &t[0], &t[1], &t[2], &t[3] ) == 4 ) { *p_time = MakeTime( t ); return true; } else return false; }
void CarModel::TransmitPacket(const Packet * packet) { std::vector<CarModel *> vecCars; std::map<in_addr_t, InfrastructureNodeModel *> * pNodeRegistry; std::map<in_addr_t, InfrastructureNodeModel *>::iterator iterNode; unsigned int iBytesPerSec = GetTXRate(); struct timeval tTransmit = iBytesPerSec > 0 ? MakeTime((double)packet->GetLength() / iBytesPerSec) : timeval0; unsigned int i; Packet * pNewPacket = packet->clone(); // transmit message to all local cars, as well as to infrastructure nodes g_pCarRegistry->acquireLock(); g_pCarRegistry->GetLocalCars(vecCars); for (i = 0; i < vecCars.size(); i++) { if (vecCars[i]->GetIPAddress() == packet->m_ID.srcID.ipCar || vecCars[i]->GetIPAddress() == m_ipCar) continue; pNewPacket->m_ipRX = vecCars[i]->GetIPAddress(); pNewPacket->m_tRX = pNewPacket->m_tTX + tTransmit; pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE; pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE; vecCars[i]->ReceivePacket(pNewPacket); } g_pCarRegistry->releaseLock(); if (m_pCommModel != NULL && m_pCommModel->IsGateway()) { pNodeRegistry = g_pInfrastructureNodeRegistry->acquireLock(); for (iterNode = pNodeRegistry->begin(); iterNode != pNodeRegistry->end(); ++iterNode) { if (iterNode->second != NULL) { pNewPacket->m_ipRX = iterNode->first; pNewPacket->m_tRX = pNewPacket->m_tTX + tTransmit; pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE; pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE; iterNode->second->ReceivePacket(pNewPacket); } } g_pInfrastructureNodeRegistry->releaseLock(); } // transmit message to all remaining network cars pNewPacket->m_ipRX = 0; pNewPacket->m_tRX = timeval0; pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE; pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE; SendPacketToAll(pNewPacket); AddHybridPacket((Packet*)packet); DestroyPacket(pNewPacket); }
void SimpleCommModel::AddMessageToRebroadcastQueue(const SafetyPacket & msg) { if (!m_bRebroadcast) return; // check to see if this a message that should be rebroadcast RebroadcastMessage * pRBXMsg = new RebroadcastMessage; pRBXMsg->msg = msg; pRBXMsg->tIntervalLow = msg.m_tRX; pRBXMsg->tIntervalHigh = pRBXMsg->tIntervalLow + m_tRebroadcastInterval; g_pSimulator->m_EventQueue.AddEvent(SimEvent(pRBXMsg->tIntervalLow + (m_bJitter ? MakeTime(RandDouble(0., ToDouble(m_tRebroadcastInterval))) : m_tRebroadcastInterval), EVENT_PRIORITY_LOWEST, m_strModelName, m_strModelName, EVENT_CARCOMMMODEL_REBROADCAST, pRBXMsg, DestroyRebroadcastMessage)); }
Date::Date(double year, double month, double date, double hours, double min, double sec, double msec, bool utcFlag) { if (year < 100) { year += 1900; } m_time = MakeDate(MakeDay(year, month, date), MakeTime(hours, min, sec, msec)); if (!utcFlag) { m_time = UTC(m_time); } }
int SimpleCommModel::Init(const std::map<QString, QString> & mapParams) { QString strValue; if (CarCommModel::Init(mapParams)) return 1; strValue = GetParam(mapParams, SIMPLECOMMMODEL_REBROADCASTINTERVAL_PARAM, SIMPLECOMMMODEL_REBROADCASTINTERVAL_PARAM_DEFAULT); m_tRebroadcastInterval = MakeTime(ValidateNumber(StringToNumber(strValue), 0., HUGE_VAL)); m_bRebroadcast = StringToBoolean(GetParam(mapParams, SIMPLECOMMMODEL_DOREBROADCAST_PARAM, SIMPLECOMMMODEL_DOREBROADCAST_PARAM_DEFAULT)); m_bGateway = StringToBoolean(GetParam(mapParams, SIMPLECOMMMODEL_MOBILEGATEWAY_PARAM, SIMPLECOMMMODEL_MOBILEGATEWAY_PARAM_DEFAULT)); m_bJitter = StringToBoolean(GetParam(mapParams, SIMPLECOMMMODEL_RBXJITTER_PARAM, SIMPLECOMMMODEL_RBXJITTER_PARAM_DEFAULT)); return 0; }
bool CarModel::ReceivePacket(Packet * packet) { std::map<in_addr_t, std::vector<SafetyPacket> >::iterator iterMessage; bool bValid = false; Packet * pNewPacket; packet->m_ID.iRXSeqNumber = GetNextRXSequenceNumber(); if (m_pPhysModel != NULL && m_pPhysModel->ReceivePacket(packet)) { if (m_pLinkModel != NULL && m_pLinkModel->ReceivePacket(packet)) { unsigned int iBytesPerSec = GetTXRate(); pNewPacket = packet->clone(); struct timeval tTransmit = iBytesPerSec > 0 ? MakeTime((double)pNewPacket->GetLength() / iBytesPerSec) : timeval0; g_pSimulator->m_EventQueue.AddEvent(SimEvent(pNewPacket->m_tRX - tTransmit, EVENT_PRIORITY_HIGHEST, QString::null, m_strModelName, EVENT_CARMODEL_RXMESSAGEBEGIN, pNewPacket, DestroyPacket)); bValid = true; } } return bValid; }
EnumErrno Analyze(const BYTE *pData, INT iSize ) { INT iRet; PACKET_INFO_EX stInfo; CFrameCache *pFrame = NULL; EnumGSCodeID eCodeId = GS_CODEID_NONE; EnumGSMediaType eMediaType = GS_MEDIA_TYPE_NONE; BOOL bKey = FALSE; UINT iChn = 1; while( iSize>0 ) { iRet = HIKANA_InputData(m_hANA, (uint8 *)pData, iSize); iSize = 0; while( 0==(iRet = HIKANA_GetOnePacketEx(m_hANA, &stInfo) ) ) { eCodeId = GS_CODEID_NONE; eMediaType = GS_MEDIA_TYPE_NONE; bKey = FALSE; iChn = 1; if( stInfo.nPacketType == VIDEO_I_FRAME ) { eMediaType = GS_MEDIA_TYPE_VIDEO; eCodeId = GS_CODEID_HK_COMPLEX; bKey = TRUE; } else if( stInfo.nPacketType == AUDIO_PACKET ) { eMediaType = GS_MEDIA_TYPE_AUDIO; bKey = TRUE; eCodeId = GS_CODEID_HK_COMPLEX; iChn = 0; } else if( stInfo.nPacketType == FILE_HEAD ) { eMediaType = GS_MEDIA_TYPE_SYSHEADER; bKey = TRUE; eCodeId = GS_CODEID_HK_COMPLEX; iChn = 1; } else { eMediaType = GS_MEDIA_TYPE_VIDEO; bKey = FALSE; eCodeId = GS_CODEID_HK_COMPLEX; } StruBaseBuf stTemp; bzero(&stTemp, sizeof(stTemp)); stTemp.iSize = stInfo.dwPacketSize; stTemp.pBuffer = (BYTE*)stInfo.pPacketBuffer; pFrame = pFrame->Create(&stTemp, 1); GS_ASSERT(pFrame); if( pFrame ) { pFrame->m_stFrameInfo.iChnNo = iChn; pFrame->m_stFrameInfo.bKey = bKey; pFrame->m_stFrameInfo.bSysHeader = (eMediaType == GS_MEDIA_TYPE_SYSHEADER); pFrame->m_stFrameInfo.eMediaType = eMediaType; if ( stInfo.nYear > 0 ) { m_iLastTime = MakeTime(stInfo.nYear,stInfo.nMonth, stInfo.nDay,stInfo.nHour, stInfo.nMinute,stInfo.nSecond); } pFrame->m_stFrameInfo.iTimestamp = m_iLastTime; if( m_listFrameCache.AddTail(pFrame) ) { GS_ASSERT(0); pFrame->UnrefObject(); } } } // end while( 0==(iRet } // end while(iSize>0) return eERRNO_SUCCESS; }
EnumErrno Analyze(const BYTE *pData, INT iSize ) { INT iRet; ANA_FRAME_INFO stInfo; CFrameCache *pFrame = NULL; EnumGSCodeID eCodeId = GS_CODEID_NONE; EnumGSMediaType eMediaType = GS_MEDIA_TYPE_NONE; BOOL bKey = FALSE; while( iSize>0 ) { iRet = ANA_InputData(m_hANA, (uint8 *)pData, iSize); if( iRet>=0 ) { iSize -= iRet; pData += iRet; } else { iSize = 0; // ANA_Reset(m_hANA, 0); } while( 0==(iRet = ANA_GetMediaFrame(m_hANA, &stInfo) ) ) { eCodeId = GS_CODEID_NONE; eMediaType = GS_MEDIA_TYPE_NONE; bKey = FALSE; if( stInfo.nType == FRAME_TYPE_VIDEO ) { eMediaType = GS_MEDIA_TYPE_VIDEO; if( stInfo.nSubType == TYPE_VIDEO_I_FRAME) { bKey = TRUE; } switch( stInfo.nEncodeType ) { case ENCODE_VIDEO_MPEG4 : { eCodeId = GS_CODEID_ST_MP4; } break; case ENCODE_VIDEO_DH_H264 : case ENCODE_VIDEO_HI_H264 : { eCodeId = GS_CODEID_ST_H264; } break; case ENCODE_VIDEO_JPEG : { eCodeId = GS_CODEID_ST_MP4; } break; default : { eCodeId = GS_CODEID_NONE; } break; } // end switch } else if( stInfo.nType == FRAME_TYPE_AUDIO ) { eMediaType = GS_MEDIA_TYPE_AUDIO; bKey = TRUE; switch( stInfo.nEncodeType ) { case ENCODE_AUDIO_PCM : { eCodeId = GS_CODEID_AUDIO_ST_PCM; } break; case ENCODE_AUDIO_G729 : { eCodeId = GS_CODEID_AUDIO_ST_G729; } break; case ENCODE_AUDIO_G721 : { eCodeId = GS_CODEID_AUDIO_ST_G721; } break; case ENCODE_AUDIO_G711A : { eCodeId = GS_CODEID_AUDIO_ST_G711A; } break; case ENCODE_AUDIO_G711U : { eCodeId = GS_CODEID_AUDIO_ST_G711U; } break; case ENCODE_AUDIO_G723 : { eCodeId = GS_CODEID_AUDIO_ST_G723; } break; case ENCODE_VIDEO_H263 : { eCodeId = GS_CODEID_AUDIO_ST_H263; } break; default : { eCodeId = GS_CODEID_NONE; } break; } // end switch } else { //其他数据不需要 continue; } UINT iChn = GetMediaChannel(eMediaType); if( iChn>GSP_MAX_MEDIA_CHANNELS || eCodeId == GS_CODEID_NONE /*|| !stInfo.bValid*/ ) { /*GS_ASSERT(!stInfo.bValid);*/ continue; } if( eCodeId == m_vInfoCtx[iChn].eCodeId ) { } else if( m_vInfoCtx[iChn].eCodeId == GS_CODEID_NONE ) { if( eMediaType == GS_MEDIA_TYPE_AUDIO ) { UINT iTempCh = GetMediaChannel(GS_MEDIA_TYPE_VIDEO); if( iTempCh>=GSP_MAX_MEDIA_CHANNELS || m_vInfoCtx[iTempCh].eCodeId == GS_CODEID_NONE) { //等待视频后再设置 continue; } } m_vInfoCtx[iChn].eCodeId = eCodeId; } else { //中间改变了编码 GS_ASSERT(0); return eERRNO_SYS_ECODEID; } StruBaseBuf stTemp; bzero(&stTemp, sizeof(stTemp)); if( m_bOutFactorStream ) { //厂商流 stTemp.iSize = stInfo.nLength; stTemp.pBuffer = (BYTE*)stInfo.pHeader; } else { //裸标准流 stTemp.iSize = stInfo.nBodyLength; stTemp.pBuffer = (BYTE*)stInfo.pFrameBody; } pFrame = pFrame->Create(&stTemp, 1); GS_ASSERT(pFrame); if( pFrame ) { pFrame->m_stFrameInfo.iChnNo = iChn; pFrame->m_stFrameInfo.bKey = bKey; pFrame->m_stFrameInfo.bSysHeader = (eMediaType == GS_MEDIA_TYPE_SYSHEADER); pFrame->m_stFrameInfo.eMediaType = eMediaType; if ( stInfo.nYear > 0 ) { m_iLastTime = MakeTime(stInfo.nYear,stInfo.nMonth, stInfo.nDay,stInfo.nHour, stInfo.nMinute,stInfo.nSecond); } pFrame->m_stFrameInfo.iTimestamp = m_iLastTime; if( m_listFrameCache.AddTail(pFrame) ) { GS_ASSERT(0); pFrame->UnrefObject(); } } } // end while( 0==(iRet } // end while(iSize>0) return eERRNO_SUCCESS; }
int CarModel::ProcessEvent(SimEvent & event) { if (Model::ProcessEvent(event)) return 1; switch (event.GetEventID()) { case EVENT_CARMODEL_UPDATE: { if (m_pPhysModel != NULL) m_pPhysModel->DoUpdate(event.GetTimestamp()); if (m_pLinkModel != NULL) m_pLinkModel->DoUpdate(event.GetTimestamp()); if (m_pCommModel != NULL) m_pCommModel->DoUpdate(event.GetTimestamp()); std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage = m_mapKnownVehicles.begin(); while (iterCarMessage != m_mapKnownVehicles.end()) { if (iterCarMessage->second.m_tTime + MakeTime(NETWORK_TIMEOUT_SECS, NETWORK_TIMEOUT_USECS) < event.GetTimestamp()) { std::map<in_addr_t, SafetyPacket>::iterator iterCarMessageTemp = iterCarMessage; ++iterCarMessage; m_mapKnownVehicles.erase(iterCarMessageTemp); } else ++iterCarMessage; } if (IsActive()) { std::vector<CarModel *> vecNeighbors; g_pCarRegistry->GetCommunicatingCarsInRange(this, vecNeighbors); m_msgNeighbors.tMessage = m_tTimestamp; m_msgNeighbors.iNeighbors = vecNeighbors.size(); m_msgNeighbors.iCollisionCount = m_pPhysModel != NULL ? (m_pPhysModel->GetCollisionCount() - m_msgNeighbors.iAccumulatedCollisions) : 0; m_msgNeighbors.iAccumulatedCollisions += m_msgNeighbors.iCollisionCount; m_msgNeighbors.iMessages = m_pPhysModel != NULL ? (m_pPhysModel->GetMessageCount() - m_msgNeighbors.iAccumulatedMessages) : 0; m_msgNeighbors.iAccumulatedMessages += m_msgNeighbors.iMessages; #ifdef MULTILANETEST m_msgNeighbors.iLane = m_iLane; #endif if (m_msgNeighbors.iCollisionCount > 0 || m_msgNeighbors.iMessages > 0 || m_msgNeighbors.iNeighbors > 0) g_pLogger->WriteMessage(LOGFILE_NEIGHBORS, &m_msgNeighbors); } event.SetTimestamp(event.GetTimestamp() + m_tDelay); g_pSimulator->m_EventQueue.AddEvent(event); break; } case EVENT_CARMODEL_RXMESSAGEBEGIN: { Packet * pPacket = (Packet *)event.GetEventData(); bool bValid = (pPacket != NULL); if (bValid && m_pCommModel != NULL && pPacket->m_ePacketType == ptSafety) m_pCommModel->AddMessageToHistory(*(SafetyPacket *)pPacket); if (bValid && m_pPhysModel != NULL) bValid = m_pPhysModel->BeginProcessPacket(pPacket); if (bValid && m_pLinkModel != NULL) bValid = m_pLinkModel->BeginProcessPacket(pPacket); if (bValid) g_pSimulator->m_EventQueue.AddEvent(SimEvent(pPacket->m_tRX, EVENT_PRIORITY_HIGHEST, QString::null, m_strModelName, EVENT_CARMODEL_RXMESSAGEEND, pPacket, DestroyPacket)); else DestroyPacket(pPacket); break; } case EVENT_CARMODEL_RXMESSAGEEND: { std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage; std::map<PacketSequence, Event1Message>::iterator iterEvent1Message; Packet * pPacket = (Packet *)event.GetEventData(); // process messages in the order that they were received bool bValid = pPacket != NULL && m_pPhysModel != NULL && m_pPhysModel->EndProcessPacket(pPacket); if (bValid) bValid = m_pLinkModel != NULL && m_pLinkModel->EndProcessPacket(pPacket); if (bValid) { switch (pPacket->m_ePacketType) { case ptGeneric: { Packet * pMsg = (Packet *)pPacket; // received message successfully //g_pLogger->LogInfo(QString("%1> ***Generic Packet\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar))); g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg); g_pSimulator->m_mutexEvent1Log.lock(); if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end()) iterEvent1Message->second.iCars++; g_pSimulator->m_mutexEvent1Log.unlock(); break; } case ptSafety: { SafetyPacket * pMsg = (SafetyPacket *)pPacket; // received message successfully g_pLogger->LogInfo(QString("%1> ***Safety: %2\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg((const char *)pMsg->m_pData)); if((const char *)pMsg->m_pData != NULL) m_pMessageList->addMessage(QString("<SafetyPacket from %1 received by %2> %3").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg(IPAddressToString(pMsg->m_ipRX)).arg((const char *)pMsg->m_pData)); if (m_pCommModel) m_pCommModel->AddMessageToRebroadcastQueue(*pMsg); g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg); g_pSimulator->m_mutexEvent1Log.lock(); if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end()) iterEvent1Message->second.iCars++; g_pSimulator->m_mutexEvent1Log.unlock(); break; } default: break; } m_pLinkModel->AddReceivedPacket(pPacket); } DestroyPacket(pPacket); break; } default: break; } return 0; }
int CarModel::ProcessEvent(SimEvent & event) { if (Model::ProcessEvent(event)) return 1; switch (event.GetEventID()) { case EVENT_CARMODEL_UPDATE: { if (m_pPhysModel != NULL) m_pPhysModel->DoUpdate(event.GetTimestamp()); if (m_pLinkModel != NULL) m_pLinkModel->DoUpdate(event.GetTimestamp()); if (m_pCommModel != NULL) m_pCommModel->DoUpdate(event.GetTimestamp()); std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage = m_mapKnownVehicles.begin(); while (iterCarMessage != m_mapKnownVehicles.end()) { if (iterCarMessage->second.m_tTime + MakeTime(NETWORK_TIMEOUT_SECS, NETWORK_TIMEOUT_USECS) < event.GetTimestamp()) { std::map<in_addr_t, SafetyPacket>::iterator iterCarMessageTemp = iterCarMessage; ++iterCarMessage; m_mapKnownVehicles.erase(iterCarMessageTemp); } else ++iterCarMessage; } if (IsActive()) { std::vector<CarModel *> vecNeighbors; g_pCarRegistry->GetCommunicatingCarsInRange(this, vecNeighbors); m_msgNeighbors.tMessage = m_tTimestamp; m_msgNeighbors.iNeighbors = vecNeighbors.size(); m_msgNeighbors.iCollisionCount = m_pPhysModel != NULL ? (m_pPhysModel->GetCollisionCount() - m_msgNeighbors.iAccumulatedCollisions) : 0; m_msgNeighbors.iAccumulatedCollisions += m_msgNeighbors.iCollisionCount; m_msgNeighbors.iMessages = m_pPhysModel != NULL ? (m_pPhysModel->GetMessageCount() - m_msgNeighbors.iAccumulatedMessages) : 0; m_msgNeighbors.iAccumulatedMessages += m_msgNeighbors.iMessages; #ifdef MULTILANETEST m_msgNeighbors.iLane = m_iLane; #endif if (m_msgNeighbors.iCollisionCount > 0 || m_msgNeighbors.iMessages > 0 || m_msgNeighbors.iNeighbors > 0) g_pLogger->WriteMessage(LOGFILE_NEIGHBORS, &m_msgNeighbors); } event.SetTimestamp(event.GetTimestamp() + m_tDelay); g_pSimulator->m_EventQueue.AddEvent(event); break; } case EVENT_CARMODEL_RXMESSAGEBEGIN: { Packet * pPacket = (Packet *)event.GetEventData(); bool bValid = (pPacket != NULL); if (bValid && m_pCommModel != NULL && pPacket->m_ePacketType == ptSafety) m_pCommModel->AddMessageToHistory(*(SafetyPacket *)pPacket); if (bValid && m_pPhysModel != NULL) bValid = m_pPhysModel->BeginProcessPacket(pPacket); if (bValid && m_pLinkModel != NULL) bValid = m_pLinkModel->BeginProcessPacket(pPacket); if (bValid) g_pSimulator->m_EventQueue.AddEvent(SimEvent(pPacket->m_tRX, EVENT_PRIORITY_HIGHEST, QString::null, m_strModelName, EVENT_CARMODEL_RXMESSAGEEND, pPacket, DestroyPacket)); else DestroyPacket(pPacket); break; } case EVENT_CARMODEL_RXMESSAGEEND: { std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage; std::map<PacketSequence, Event1Message>::iterator iterEvent1Message; Packet * pPacket = (Packet *)event.GetEventData(); // process messages in the order that they were received bool bValid = pPacket != NULL && m_pPhysModel != NULL && m_pPhysModel->EndProcessPacket(pPacket); if (bValid) bValid = m_pLinkModel != NULL && m_pLinkModel->EndProcessPacket(pPacket); if (bValid) { switch (pPacket->m_ePacketType) { case ptGeneric: { Packet * pMsg = (Packet *)pPacket; // received message successfully //g_pLogger->LogInfo(QString("%1> ***Generic Packet\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar))); g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg); g_pSimulator->m_mutexEvent1Log.lock(); if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end()) iterEvent1Message->second.iCars++; g_pSimulator->m_mutexEvent1Log.unlock(); break; } case ptSafety: { SafetyPacket * pMsg = (SafetyPacket *)pPacket; //printf("m_iLane = %u m_iHeading = %d", m_iLane, m_iHeading); // received message successfully if((sin( pMsg->m_iHeading * 3.14/18000) * sin( m_iHeading * 3.14/18000) + cos( pMsg->m_iHeading *3.14/18000)* cos( m_iHeading *3.14/18000) >= 0) && (( m_ptPosition.m_iLong - pMsg->m_ptPosition.m_iLong ) * sin( pMsg->m_iHeading * 3.14/18000) + (m_ptPosition.m_iLat - pMsg->m_ptPosition.m_iLat) * cos( pMsg->m_iHeading *3.14/18000) > 0)) break; if (!QString((const char*)pMsg->m_pData).contains (QString("@%1 ").arg(IPAddressToString(pMsg->m_ipRX)))){ if((const char *)pMsg->m_pData != NULL){ time_t timer = time(NULL); printf("%s ", ctime(&timer)); g_pLogger->LogInfo(QString("[From %1 Receiv %2: %3]\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg(IPAddressToString(pMsg->m_ipRX)).arg((const char *)pMsg->m_pData).ascii()); QString temp = QString("%1@%2 ").arg((const char *)pMsg->m_pData).arg(IPAddressToString(pMsg->m_ipRX)); free(pMsg->m_pData); unsigned char * temp_c_string = (unsigned char *)calloc (temp.length()+1, sizeof(unsigned char)); const char * const_c_string = temp.ascii(); for (int i = 0 ; i < temp.length(); i++) temp_c_string[i]=const_c_string[i]; temp_c_string[temp.length()] = '\0'; pMsg->m_pData = temp_c_string; pMsg->m_iDataLength = sizeof(unsigned char)*(temp.length()+1); } if (m_pCommModel) m_pCommModel->AddMessageToRebroadcastQueue(*pMsg); g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg); g_pSimulator->m_mutexEvent1Log.lock(); if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end()) iterEvent1Message->second.iCars++; g_pSimulator->m_mutexEvent1Log.unlock(); } break; } default: break; } m_pLinkModel->AddReceivedPacket(pPacket); } DestroyPacket(pPacket); break; } default: break; } return 0; }
SimpleCommModel::SimpleCommModel(const QString & strModelName) : CarCommModel(strModelName), m_bRebroadcast(true), m_bGateway(false), m_bJitter(true), m_tRebroadcastInterval(MakeTime(1, 0)) { }
bool NetModel::IsActive() const { return m_tTimestamp + MakeTime(NETWORK_TIMEOUT_SECS, NETWORK_TIMEOUT_USECS) >= GetLastEventTime(); }
int CarModel::Init(const std::map<QString, QString> & mapParams) { QString strValue; MapCarObject * pObject; Model * pModel; if (Model::Init(mapParams)) return 1; strValue = GetParam(mapParams, CARMODEL_PARAM_DELAY, CARMODEL_PARAM_DELAY_DEFAULT); m_tDelay = MakeTime(ValidateNumber(StringToNumber(strValue), 0., HUGE_VAL)); strValue = GetParam(mapParams, CARMODEL_PARAM_CARIP, CARMODEL_PARAM_CARIP_DEFAULT); if (!StringToIPAddress(strValue, m_ipCar)) return 2; strValue = GetParam(mapParams, CARMODEL_PARAM_LOGCAR, CARMODEL_PARAM_LOGCAR_DEFAULT); m_bLogThisCar = StringToBoolean(strValue); strValue = GetParam(mapParams, CARMODEL_LINK_PARAM, CARMODEL_LINK_PARAM_DEFAULT); if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel)) return 5; m_pLinkModel = (CarLinkModel *)pModel; if (m_pLinkModel != NULL) m_pLinkModel->SetCar(m_ipCar); strValue = GetParam(mapParams, CARMODEL_PHYS_PARAM, CARMODEL_PHYS_PARAM_DEFAULT); if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel)) return 6; m_pPhysModel = (CarPhysModel *)pModel; if (m_pPhysModel != NULL) m_pPhysModel->SetCar(m_ipCar); strValue = GetParam(mapParams, CARMODEL_COMM_PARAM, CARMODEL_COMM_PARAM_DEFAULT); if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel)) return 4; m_pCommModel = (CarCommModel *)pModel; if (m_pCommModel != NULL) m_pCommModel->SetCar(m_ipCar); strValue = GetParam(mapParams, CARMODEL_TRACKSPEED_PARAM, CARMODEL_TRACKSPEED_PARAM_DEFAULT); m_bTrackSpeed = StringToBoolean(strValue); pObject = new MapCarObject(this); //HACK: set color based on ip group in_addr_t temp = pObject->m_pCar->GetIPAddress(); temp = temp>>8 & 0xFF; if(temp == 100) //red ones { QColor * redColor = new QColor(0xFF, 0x00, 0x00); pObject->SetColor(redColor->rgb()); } else if(temp == 200) //black ones { QColor * redColor = new QColor(0x00, 0x00, 0x00); pObject->SetColor(redColor->rgb()); } else //the others { pObject->SetColor(g_pMapObjects->GetColor()); } //end HACK m_iMapObjectID = g_pMapObjects->add(pObject); if (m_iMapObjectID == -1) delete pObject; g_pCarRegistry->addCar(this); m_iNextSeqNumber = 0; m_iNextRXSeqNumber = 0; return 0; }
void Server::run() { Packet * pPacket = NULL, * pNewPacket = NULL; unsigned char * pNewMessage; int iNewMessageLength = 0; in_addr_t ipTX; std::map<in_addr_t, in_addr_t> mapNewCars; struct timeval tWait = MakeTime(SERVER_WAIT_SECS, SERVER_WAIT_USECS); std::map<in_addr_t, std::vector<Packet *> >::iterator iterPackets; std::map<in_addr_t, Buffer>::iterator iterBuffer; std::map<in_addr_t, CarModel *> * pCarRegistry; std::map<in_addr_t, InfrastructureNodeModel *> * pNodeRegistry; std::map<in_addr_t, CarModel *>::iterator iterCarReceiver; std::map<in_addr_t, InfrastructureNodeModel *>::iterator iterNode; struct timeval tRX; char iRSSI, iSNR; fd_set rfds; std::list<ReadBuffer> listRead; std::list<ReadBuffer>::iterator iterRead; while (!m_bCancelled) { // get any waiting messages m_mutexConnections.lock(); if (FillFDs(&rfds) && Select(&rfds, tWait)) { Read(&rfds, listRead); for (iterRead = listRead.begin(); iterRead != listRead.end(); ++iterRead) { ipTX = ntohl(iterRead->sFrom.sin_addr.s_addr); // if new message is not null, add it to the current buffer if (iterRead->pData != NULL) m_mapBuffers[ipTX] += Buffer(iterRead->pData, iterRead->iLength); } listRead.clear(); } m_mutexConnections.unlock(); // process non-empty buffers into messages for (iterBuffer = m_mapBuffers.begin(); iterBuffer != m_mapBuffers.end(); ++iterBuffer) { if (iterBuffer->second.m_iLength > 0) { //printf("processing buffer..........\n"); //fflush(stdout); unsigned char * pNew = NULL; pCarRegistry = g_pCarRegistry->acquireLock(); pNodeRegistry = g_pInfrastructureNodeRegistry->acquireLock(); m_mutexBuffers.lock(); pNewMessage = iterBuffer->second.m_pData; iNewMessageLength = (signed)iterBuffer->second.m_iLength; tRX = GetCurrentTime(); iRSSI = rssi(); iSNR = snr(); while (iNewMessageLength >= (signed)PACKET_MINIMUM_LENGTH && (pPacket = CreatePacket(*(const PacketType *)pNewMessage)) != NULL) { //printf("got packet...\n"); if (!pPacket->FromBytes(pNewMessage, iNewMessageLength)) { //printf("failed...\n"); DestroyPacket(pPacket); iNewMessageLength = 0; break; } //if(((SafetyPacket*)pPacket)->m_ePacketType == ptSafety) // printf("data: %s\n", ((SafetyPacket*)pPacket)->m_pData); //if(((Packet*)pPacket)->m_ePacketType == ptGeneric) // printf("long: %ld\n", ((Packet*)pPacket)->m_ptTXPosition.m_iLong); // add it to the proper message buffer pPacket->m_tRX = tRX; pPacket->m_iRSSI = iRSSI; pPacket->m_iSNR = iSNR; pNewPacket = pPacket->clone(); for (iterCarReceiver = pCarRegistry->begin(); iterCarReceiver != pCarRegistry->end(); ++iterCarReceiver) { if (iterCarReceiver->second != NULL && iterCarReceiver->second->GetOwnerIPAddress() == CARMODEL_IPOWNER_LOCAL && iterCarReceiver->first != pPacket->m_ipTX) { pNewPacket->m_ipRX = iterCarReceiver->first; iterCarReceiver->second->ReceivePacket(pNewPacket); } } for (iterNode = pNodeRegistry->begin(); iterNode != pNodeRegistry->end(); ++iterNode) { if (iterNode->second != NULL && iterNode->first != pPacket->m_ipTX) { pNewPacket->m_ipRX = iterNode->first; iterNode->second->ReceivePacket(pNewPacket); } } DestroyPacket(pNewPacket); iterCarReceiver = pCarRegistry->find(pPacket->m_ID.srcID.ipCar); iterNode = pNodeRegistry->find(pPacket->m_ID.srcID.ipCar); if ((iterCarReceiver == pCarRegistry->end() || iterCarReceiver->second == NULL || iterCarReceiver->second->GetOwnerIPAddress() != CARMODEL_IPOWNER_LOCAL) && (iterNode == pNodeRegistry->end() || iterNode->second == NULL)) { //printf("processing..................................\n"); mapNewCars[pPacket->m_ID.srcID.ipCar] = iterBuffer->first; iterPackets = m_mapPackets.find(pPacket->m_ID.srcID.ipCar); if (iterPackets == m_mapPackets.end()) iterPackets = m_mapPackets.insert(std::pair<in_addr_t, std::vector<Packet *> >(pPacket->m_ID.srcID.ipCar, std::vector<Packet *>())).first; iterPackets->second.push_back(pPacket); push_heap(iterPackets->second.begin(), iterPackets->second.end(), ComparePacketPtrs); } else DestroyPacket(pPacket); } m_mutexBuffers.unlock(); g_pInfrastructureNodeRegistry->releaseLock(); g_pCarRegistry->releaseLock(); if (iNewMessageLength > 0) pNew = (unsigned char *)memcpy(malloc(iNewMessageLength), pNewMessage, iNewMessageLength); iterBuffer->second = Buffer(pNew, iNewMessageLength); } } //add new network car to list if (!mapNewCars.empty()) { g_pSimulator->m_ModelMgr.AddNetworkCars(mapNewCars); mapNewCars.clear(); } //sleep(1); } }