private void OnDriverIdEventHandler(object sender, BlockStatusEventArgs stateEvent)
{
try
{
CNXLog.InfoFormat("DriverId {0}", stateEvent.State);
if (stateEvent.State == BlockState.COMPLETE || stateEvent.State == BlockState.COMPLETE_REPEAT)
{
TransientBlockReciever reciever = (TransientBlockReciever)sender;
if (reciever.BlockData.Length == 0)
{
mCommsServer.Send(RTTMesg.CreateDriverStatus(RTTMesg.RTTOutMsgIds.DriverLogoff));
}
else if (reciever.BlockData[0] == 0)
{
mCommsServer.Send(RTTMesg.CreateDriverStatus(RTTMesg.RTTOutMsgIds.DriverLogoff));
}
else
{
string driverId = Encoding.ASCII.GetString(reciever.BlockData);
CNXLog.WarnFormat("DriverId {0}", driverId);
mCommsServer.Send(RTTMesg.CreateDriverLogonMessage(driverId));
}
}
}
catch (Exception e)
{
CNXLog.Error("OnDriverIdEventHandler", e);
}
}
/// <summary>
/// Create a Driver message
/// </summary>
/// <param name="driverStatus">The status</param>
/// <returns>Driver message</returns>
public static RTTMesg CreateDriverStatus(RTTOutMsgIds driverStatus)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = driverStatus
};
return(mesg);
}
/// <summary>
/// Create a GPS message
/// </summary>
/// <param name="error">Error estimation</param>
/// <param name="alarmActive">Alarm state</param>
/// <param name="latitude">Current latitude in WGS84 decimal degrees.</param>
/// <param name="longitude">Current longitude in WGS84 decimal degrees.</param>
/// <param name="velocity">Current horizontal velocity in meters/second.</param>
/// <returns>GPS message</returns>
/// <remarks>
/// When the TrackingState is packed into a byte array to be used as an RTT message values may be truncated as follows: -
/// Latitude/Longitude will be truncated to single presision floating point numbers.
/// The error values is packed into 6 bits in 3 meter increments giving a maximum value of 208 meters.
/// </remarks>
public static RTTMesg CreateGPSFix(uint error, bool alarmActive, double latitude, double longitude, double velocity)
{
RTTMesg mesg = new RTTMesg();
mesg.SetLocation(error, latitude, longitude, velocity);
mesg.mAlarm = alarmActive;
return(mesg);
}
/// <summary>
/// Sends an un-acknowledged message to the RTT Server
/// </summary>
/// <param name="msg"></param>
public void Send(RTTMesg msg)
{
if (msg == null)
{
CNXLog.ErrorFormat("{0} Could not send null message.", DateTime.Now.TimeOfDay.ToString());
return;
}
TimeSpan span = DateTime.Now.Subtract(mLastMsg);
msg.CommsAddress = mCommsAddress;
if (msg.RequiresMesgNo)
{
msg.MessageNumber = mShortMsgNumber++;
}
byte[] message = msg.GetBytes(true);
try
{
CNXLog.DebugFormat("Sending {0}\n\r{1}", msg.MessageId, HexDump(message));
int count = mUDPTxClient.Send(message, message.Length, mRTTServer, mRTTTxPort);
if (count != message.Length)
{
CNXLog.ErrorFormat("Could not send UDP message to server {0}:{1}.", mRTTServer, mRTTTxPort);
}
else
{
mLastMsg = DateTime.Now;
}
}
catch (Exception e)
{
CNXLog.WarnFormat("{0} Can't connect to server {1}:{2}.", mLastMsg, mRTTServer, mRTTTxPort);
CNXLog.Warn(e.ToString());
// may get here if the client cant connect
if (!e.GetType().Equals(typeof(SocketException)))
{
CNXLog.Error(e.ToString());
}
// consider taking action
//if (TimeSpan.Compare(span, MaxCommsOutage) > 0)
//{
// reset last message to stop any thrashing
mLastMsg = DateTime.Now;
CNXLog.WarnFormat("{0} : Restarting UDPClient to {1}:{2}.", mLastMsg, mRTTServer, mRTTTxPort);
// replace UDP client
mUDPTxClient.Close();
mUDPTxClient = new UdpClient();
//}
}
if (mShortMsgNumber == 0)
{
OnMessageCountRolloverEvent(new EventArgs());
}
}
/// <summary>
/// Create a Loading message.
/// </summary>
/// <param name="loading">The loading of the vehicle</param>
/// <returns>APCLoading message</returns>
public static RTTMesg CreateAPCLoading(byte loading)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.APCLoading,
APCLoading = loading
};
return(mesg);
}
/// <summary>
/// Create a Resource message.
/// </summary>
/// <param name="catalogue">Device catalogue.</param>
/// <returns>Resource message</returns>
public static RTTMesg CreateFirmwareMessage(ReadOnlyCollection <DeviceCatalogueInfo> catalogue)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.FirmwareBuildNo,
mCatalogue = catalogue
};
return(mesg);
}
/// <summary>
/// Create a Driver message
/// </summary>
/// <param name="id">Driver Id.</param>
/// <returns>Driver message</returns>
public static RTTMesg CreateDriverLogonMessage(string id)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.DriverLogon,
mDriverId = id
};
return(mesg);
}
/// <summary>
/// Create a Driver message
/// </summary>
/// <param name="message">Text message for the server.</param>
/// <returns>Driver message</returns>
public static RTTMesg CreateDriverTxTMessage(string message)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.DriverMesg,
mTxTMessage = message
};
return(mesg);
}
/// <summary>
/// Create a Driver message
/// </summary>
/// <param name="messageTag">The message tag (cookie) supplied with the thessage that is being acknowledged</param>
/// <returns>Driver message</returns>
public static RTTMesg CreateDriverMessageAck(ushort messageTag)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.DriverMesgAck,
MessageTag = messageTag
};
return(mesg);
}
/// <summary>
/// Create a GPS message
/// </summary>
/// <param name="alarmActive">Alarm state</param>
/// <returns>GPS message</returns>
public static RTTMesg CreateGPSNoFix(bool alarmActive)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.GPSNoFix,
mAlarm = alarmActive
};
return(mesg);
}
/// <summary>
/// Create a Resource message
/// </summary>
/// <param name="catalogue">Device catalogue.</param>
/// <returns>Resource message</returns>
public static RTTMesg CreateEquipmentMessage(DeviceCatalogueInfo.EquipmentFlages mask, DeviceCatalogueInfo.EquipmentFlages state)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.EquipmentStatus,
mEquipmentMask = mask,
mEquipmentState = state
};
return(mesg);
}
/// <summary>
/// Create a Resource message.
/// </summary>
/// <param name="routePatternVer">Route pattern resource version.</param>
/// <param name="vehicleConfigVer">Vehicle config resource version.</param>
/// <param name="ServiceAlertVer">Service alert resource version.</param>
/// <param name="driverConfigVer">Driver config resource version.</param>
/// <returns>Resource message.</returns>
public static RTTMesg CreateResourceBuildMessage(byte routePatternVer, byte vehicleConfigVer, byte serviceAlertVer, byte driverConfigVer)
{
RTTMesg mesg = new RTTMesg()
{
mMesgId = RTTOutMsgIds.ResourceBuildNo,
mRoutePatternVersion = routePatternVer,
mVehicleConfigVersion = vehicleConfigVer,
mServiceAlertVersion = serviceAlertVer,
mDriverConfigVersion = driverConfigVer
};
return(mesg);
}
private void OnTxTMessageEventHandler(object sender, BlockStatusEventArgs stateEvent)
{
try
{
if (stateEvent.State == BlockState.COMPLETE || stateEvent.State == BlockState.COMPLETE_REPEAT)
{
TransientBlockReciever reciever = (TransientBlockReciever)sender;
string txtMesg = Encoding.ASCII.GetString(reciever.BlockData);
CNXLog.InfoFormat("TxT Message {0}", txtMesg);
mCommsServer.Send(RTTMesg.CreateDriverTxTMessage(txtMesg));
}
}
catch (Exception e)
{
CNXLog.Error("OnTxTMessageEventHandler", e);
}
}
private void MakeFullReport()
{
MakeMinimalReport();
if (mFullReportRequired)
{
RTTMesg message;
// set versioning and catalogue data
if (mDeviceMask != DeviceCatalogueInfo.EquipmentFlages.None)
{
message = RTTMesg.CreateEquipmentMessage(mDeviceMask, mDeviceStatus);
CNXLog.WarnFormat("Sending {0}", message);
mCommsServer.Send(message);
}
if (mCatalogue != null)
{
message = RTTMesg.CreateFirmwareMessage(mCatalogue);
CNXLog.WarnFormat("Sending {0}", message);
mCommsServer.Send(message);
}
if (mResourceMessage != null)
{
if (mResourceMessage.IsResourceBuildPopulated)
{
CNXLog.WarnFormat("Sending {0}", mResourceMessage);
mCommsServer.Send(mResourceMessage);
}
else
{
CNXLog.WarnFormat("ResourceMessage not populated {0}", mResourceMessage);
}
}
else
{
CNXLog.WarnFormat("No ResourceMessage to send");
}
mFullReportRequired = (mDeviceMask == DeviceCatalogueInfo.EquipmentFlages.None) || (mCatalogue == null) || (!mResourceMessage.IsResourceBuildPopulated);
}
}
private void FrameReceivedEventHandler(object o, FrameReceivedEventArgs a)
{
switch ((CNXMsgIds)a.Frame.MailboxId)
{
case CNXMsgIds.DriverMessageAck:
mCommsServer.Send(RTTMesg.CreateDriverMessageAck(BitConverter.ToUInt16(a.Frame.Data, 0)));
break;
case CNXMsgIds.DriverStatus:
CNXLog.WarnFormat("Driver status recieved {0}.", (CANLib.DriverStatus)a.Frame.Data[0]);
RTTMesg.RTTOutMsgIds state = RTTMesg.RTTOutMsgIds.UNKNOWN;
switch ((CANLib.DriverStatus)a.Frame.Data[0])
{
case DriverStatus.Break:
state = RTTMesg.RTTOutMsgIds.DriverStatusOnBreak;
break;
case DriverStatus.Normal:
state = RTTMesg.RTTOutMsgIds.DriverStatusNormal;
break;
case DriverStatus.OutOfVehicle:
state = RTTMesg.RTTOutMsgIds.DriverStatusOutOfVehicle;
break;
default:
CNXLog.WarnFormat("CNXMsgIds.DriverStatus {0} out of range.", a.Frame.Data[0]);
break;
}
if (state != RTTMesg.RTTOutMsgIds.UNKNOWN)
{
mCommsServer.Send(RTTMesg.CreateDriverStatus(state));
}
break;
default:
break;
}
}
