/// <summary>
/// Throws a socket exception only on initialization. Once everything is up and running exceptions are handled internally.
/// </summary>
/// <param name="endpoint"></param>
/// <param name="new_frame_callback"></param>
/// <param name="should_cancel_callback">Called at 1 Hz</param>
public static void Listen(
IPEndPoint endpoint,
FrameRecieved new_frame_callback = null,
ShouldCancel should_cancel_callback = null)
{
var framer = new VLP_16_Framer(new_frame_callback);
VLP_16.Listen(
endpoint,
framer.RecievePacket,
should_cancel_callback);
}
/// <summary>
/// This method won't return untill listener is done (canceled manually, or error).
/// It returns the raw data packets sent by the VLP-16
/// Throws a socket exception only on initialization. Once everything is up and running exceptions are handled internally.
/// </summary>
/// <param name="endpoint">Where to listen for data</param>
/// <param name="packet_recieved_callback">New data gets parsed, sent to this method.</param>
/// <param name="should_cancel_callback">Hearbeat function, called at 1 Hz, can stop the velodyne listener</param>
public static void Listen(
IPEndPoint endpoint,
PacketRecieved packet_recieved_callback = null,
ShouldCancel should_cancel_callback = null)
{
UdpClient cl = null;
try
{
cl = new UdpClient(new IPEndPoint(IPAddress.Any, endpoint.Port));
cl.Client.ReceiveTimeout = 250; // .25 Seconds
cl.Client.ReceiveBufferSize = 4096;
Listen_(cl, packet_recieved_callback, should_cancel_callback); // This will only end when canceled
}
finally
{
if (cl != null)
{
cl.Dispose();
}
}
}
/// <summary>
/// This constructor won't return untill listener is done (or error).
/// It returns the raw data packets sent by the VLP-16
/// Throws a socket exception only on initialization. Once everything is up and running exceptions are handled internally.
/// </summary>
/// <param name="d"></param>
/// <param name="packet_recieved_sync"></param>
/// <param name="should_cancel_async">Called at 1 Hz</param>
public VLP_16(
IPEndPoint d,
PacketRecieved packet_recieved_sync = null,
ShouldCancel should_cancel_async = null)
{
UdpClient cl = null;
try
{
cl = new UdpClient(new IPEndPoint(d.Address, d.Port));
cl.Client.ReceiveTimeout = 250; // .25 Seconds
cl.Client.ReceiveBufferSize = 4096;
this.Listen(cl, packet_recieved_sync, should_cancel_async); // This will only end when canceled
}
finally
{
if (cl != null)
{
cl.Dispose();
}
}
}
private void button1_Click(object sender, EventArgs e)
{
ShouldCancel Cancel = PersistUnsavedChanges(true);
if (Cancel == ShouldCancel.Yes)
{
return;
}
using (OpenFileDialog D = new OpenFileDialog())
{
D.Filter = "Clang Tidy files|.clang-tidy";
D.CheckPathExists = true;
D.CheckFileExists = true;
if (D.ShowDialog() == DialogResult.OK)
{
PropertyChain_.Clear();
PropertyChain_ = ClangTidyConfigParser.ParseConfigurationChain(D.FileName);
textBox1.Text = D.FileName;
reloadPropertyChain();
}
}
}
private static unsafe void Listen_(
UdpClient cl,
PacketRecieved packet_recieved_callback,
ShouldCancel should_cancel_callback)
{
DateTime start = DateTime.Now;
int elapsed_seconds = 0;
int corrects = 0;
int incorrects = 0;
int timeouts = 0;
int socketerrors = 0;
while (true)
{
try
{
IPEndPoint iep = null;
var data = cl.Receive(ref iep);
if (data.Length == Packet.Raw._Size)
{
Packet p;
bool valid;
fixed(byte *b = data)
p = new Packet(b, out valid);
if (valid)
{
corrects++;
packet_recieved_callback?.Invoke(p, iep);
}
else
{
incorrects--;
}
}
else
{
incorrects++;
}
}
catch (TimeoutException)
{
timeouts++;
}
catch (SocketException)
{
socketerrors++;
}
catch (Exception e)
{
Logger.WriteException(typeof(VLP_16), "Listen", e);
incorrects++;
}
var now = DateTime.Now;
if ((now - start).TotalSeconds > elapsed_seconds)
{
elapsed_seconds++;
var st = new UpdateArgs();
st.Timeouts = timeouts;
st.PacketsReceivedCorrectly = corrects;
st.PacketsReceivedIncorrectly = incorrects;
st.SocketErrors = socketerrors;
timeouts = 0;
corrects = 0;
incorrects = 0;
socketerrors = 0;
if (should_cancel_callback != null)
{
if (should_cancel_callback(st))
{
return;
}
}
}
}
}
private unsafe void Listen(
UdpClient cl,
PacketRecieved packet_recieved_sync,
ShouldCancel should_cancel_async)
{
DateTime start = DateTime.Now;
int elapsed_seconds = 0;
int corrects = 0;
int incorrects = 0;
int timeouts = 0;
int socketerrors = 0;
while (true)
{
try
{
IPEndPoint iep = null;
var data = cl.Receive(ref iep);
if (data.Length == Packet.Raw._Size)
{
Packet p;
bool valid;
fixed(byte *b = data)
p = new Packet(b, out valid);
if (valid)
{
corrects++;
if (packet_recieved_sync != null)
{
packet_recieved_sync(p, iep);
}
}
else
{
incorrects--;
}
}
else
{
incorrects++;
}
}
catch (TimeoutException)
{
timeouts++;
}
catch (SocketException)
{
socketerrors++;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(this.GetType().FullName + ": " + e.ToString());
incorrects++;
}
var now = DateTime.Now;
if ((now - start).TotalSeconds > elapsed_seconds)
{
elapsed_seconds++;
var st = new UpdateArgs();
st.SocketErrors = timeouts;
st.PacketsReceivedCorrectly = corrects;
st.PacketsReceivedIncorrectly = incorrects;
st.SocketErrors = socketerrors;
timeouts = 0;
corrects = 0;
incorrects = 0;
socketerrors = 0;
if (should_cancel_async != null)
{
if (should_cancel_async(st))
{
return;
}
}
}
}
}
