//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);
}
}
