private void Init()
{
try
{
_serialPort = new SerialPort(this.myPort, this.myBaudRate, this.myParity, this.myDataBits, this.myStopBits);
_serialPort.DataReceived += new SerialDataReceivedEventHandler(this.port_DataReceived);
_serialPort.Open();
}
catch (Exception exception)
{
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText("Fehler: " + exception.Message);
MainWindow.main.Background = Brushes.LightPink;
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("RS232 - Fehler: " + exception.Message);
WriteLogger.WriteLog("-------------------------------");
}));
//Console.WriteLine("Exception: " + exception);
}
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("RS232 - Config:");
WriteLogger.WriteLog("Port: " + myPort);
WriteLogger.WriteLog("BaudRate: " + this.myBaudRate);
WriteLogger.WriteLog("Parity: " + myParity);
WriteLogger.WriteLog("StopBits: " + myStopBits);
WriteLogger.WriteLog("DataBits: " + myDataBits);
WriteLogger.WriteLog("-------------------------------");
#endif
//parser.receiveState = (int)Parser.ReceiveState.Receiving;
}
//private void Parse(List<byte> receivedData)
//{
// if (this.receiveState == (int)ReceiveState.ReadyToParse)
// {
// List<byte> Messurement = new List<byte>();
// Messurement = receivedData.GetRange((int)this.recievedDataIndexStart, ((this.recievedDataIndexEnd + 1) - (int)this.recievedDataIndexStart));
// byte[] tohexstring = new byte[Messurement.Count()];
// tohexstring = Messurement.ToArray<byte>();
// string hexstring = BitConverter.ToString(tohexstring);
// hexstring = hexstring.Replace("-", "");
// string ergstring = Converter.Hex2String(hexstring);
// List<Laborergebnisse> laborergebnisse = parse(ergstring);
// if (!ExceptionOccuredParser && !saved)
// {
// saveLaborergebnisse(laborergebnisse);
// }
// }
//}
//private void OnTimedEvent(object sender, ElapsedEventArgs e)
//{
// aTimer.Stop();
// this.recievedDataIndexStart = 0;
// this.recievedDataIndexEnd = myMessurement.Count-1;
// this.receiveState = (int)ReceiveState.ReadyToParse;
// Parse(myMessurement);
//}
#endregion
#region Saver
public void saveLaborergebnisse(List <Laborergebnisse> value)
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Start Saving!");
WriteLogger.WriteLog("-------------------------------");
#endif
saved = true;
bool ExceptionOccured = false;
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText(DataOk);
}));
System.Threading.Thread.Sleep(Latenz);
try
{
foreach (Laborergebnisse l in value)
{
new LaborergebnisseDS().insert(l);
}
}
catch (Exception exception)
{
ExceptionOccured = true;
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText("Fehler: " + exception.Message);
MainWindow.main.Background = Brushes.LightPink;
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Fehler Saving: " + exception.Message);
WriteLogger.WriteLog("-------------------------------");
}));
}
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Stop Saving!");
WriteLogger.WriteLog("-------------------------------");
#endif
if (!ExceptionOccured)
{
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText(DBSave);
}));
System.Threading.Thread.Sleep(Latenz);
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.Close();
}));
}
}
public void dataParser(string data)
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Finding Start and End of Transmission.....");
WriteLogger.WriteLog("-------------------------------");
#endif
List <Laborergebnisse> laborergebnisse = parse(data);
if (!ExceptionOccuredParser && !saved)
{
saveLaborergebnisse(laborergebnisse);
}
}
public RS232()
{
ParserThread = new Thread(DoWork);
ParserThread.Start();
//Thread.Sleep(7000);
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("| CTOR RS232 |");
WriteLogger.WriteLog("-------------------------------");
#endif
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.Background = Brushes.Beige;
}));
this.ReadConfigFromConfFile();
this.Init();
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
aTimer.Interval = 10000;
aTimer.Enabled = true;
}
private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("startReceiving.....");
WriteLogger.WriteLog("-------------------------------");
#endif
receivingStart = true;
aTimer.Start();
parser.receiveState = (int)Parser.ReceiveState.Start;
for (int i = 0; i < _serialPort.BytesToRead; i++)
{
this.receivedData.Add((byte)_serialPort.ReadByte());
}
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("myData:");
string temp = "";
foreach (Byte b in receivedData)
{
temp = temp + " " + b.ToString("X2");
}
WriteLogger.WriteLog(temp);
WriteLogger.WriteLog("-------------------------------");
#endif
try
{
parser.dataParser(receivedData);
}catch (Exception ex)
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Exeption beim Aufruf dataParser: " + ex.Message);
WriteLogger.WriteLog("-------------------------------");
#endif
}
}
public TCP()
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("| CTOR TCP |");
WriteLogger.WriteLog("-------------------------------");
#endif
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.Background = Brushes.LightGray;
}));
ReadConfigFromConfFile();
TcpListener server = null;
try
{
// Set the TcpListener on port 13000.
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[256];
String data = null;
bool work = true;
// Enter the listening loop.
while (work)
{
#if DEBUG
Console.Write("Waiting for a connection... ");
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Waiting for a connection... ");
WriteLogger.WriteLog("-------------------------------");
#endif
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
#if DEBUG
Console.WriteLine("Connected!");
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Connected!");
WriteLogger.WriteLog("-------------------------------");
#endif
data = "";
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
//while (stream.DataAvailable)
//while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
while (GetData)
{
// Read Data from Stream
i = stream.Read(bytes, 0, bytes.Length);
//Encoding einstallbar
if (Encoding.Equals("ASCII"))
{
data = data + System.Text.Encoding.ASCII.GetString(bytes, 0, i);
}
else if (Encoding.Equals("BigEndianUnicode"))
{
data = System.Text.Encoding.BigEndianUnicode.GetString(bytes, 0, i);
}
else if (Encoding.Equals("Default"))
{
data = System.Text.Encoding.Default.GetString(bytes, 0, i);
}
else if (Encoding.Equals("Unicode"))
{
data = System.Text.Encoding.Unicode.GetString(bytes, 0, i);
}
else if (Encoding.Equals("UTF32"))
{
data = System.Text.Encoding.UTF32.GetString(bytes, 0, i);
}
else if (Encoding.Equals("UTF7"))
{
data = System.Text.Encoding.UTF7.GetString(bytes, 0, i);
}
else
{
data = System.Text.Encoding.UTF8.GetString(bytes, 0, i);
}
#if DEBUG
Console.WriteLine("Received: {0}", data);
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Received: " + data);
WriteLogger.WriteLog("-------------------------------");
#endif
// Process the data sent by the client.
data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
for (int z = 0; z < msg.Length; z++)
{
receivedData.Add(msg[z]);
}
if (Stopping.Equals("Standard") && !(i != 0))
{
GetData = false;
}
if (Stopping.Equals("DataAvailable") && !stream.DataAvailable)
{
GetData = false;
}
if (Stopping.Equals("Byte") && receivedData.Contains(0x03))
{
GetData = false;
}
}
// Shutdown and end connection
client.Close();
parser.dataParser(data);
work = false;
//parser.dataParser(receivedData);
}
}
catch (Exception e)
{
#if DEBUG
Console.WriteLine("Exception: {0}", e);
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Exception: " + e);
WriteLogger.WriteLog("-------------------------------");
#endif
}
finally
{
// Stop listening for new clients.
server.Stop();
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Server Stop ");
WriteLogger.WriteLog("-------------------------------");
#endif
}
}
public Parser()
{
_Parser = this;
InitWorkstation();
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("| CTOR Parser |");
WriteLogger.WriteLog("-------------------------------");
#endif
#if !OFFLINE
try
{
TEST.setCurrentOrdination();
// Patient evaluieren
//Workstation workstation = workstationDS.getWorkstations(Host.GetName());
//Anpassung Dr. Stadler
List <Workstation> workstationList;
workstationList = workstationDS.getWorkstations();
Workstation workstation;
if (String.IsNullOrEmpty(_Workstation))
{
workstation = workstationDS.getWorkstations(Host.GetName());
}
else
{
workstation = workstationList.Where(x => x.Hostname == _Workstation).FirstOrDefault();
}
//if (String.IsNullOrEmpty(_Workstation))
//{
// workstation = workstationDS.getWorkstations();
//}else
//{
// workstation = workstationDS.getWorkstations(/*_Workstation*/);
//}
patientId = (long)workstation.PatientId;
patient = new PatientDS().getPatientenById(patientId);
}
catch (Exception exception)
{
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText("Fehler bei der PatientenId: " + exception.Message);
MainWindow.main.Background = Brushes.LightPink;
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Fehler bei Patientenauswahl: " + exception.Message);
WriteLogger.WriteLog("-------------------------------");
}));
}
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.AddToTitle(patient.Vorname + " " + patient.Nachname);
}));
#endif
//aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
//aTimer.Interval = 5000;
//aTimer.Enabled = true;
ReadText();
//OnInitFinished(EventArgs.Empty);
}
public void dataParser(List <byte> receivedData)
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Finding Start and End of Transmission.....");
WriteLogger.WriteLog("-------------------------------");
#endif
//if (findEnd == (int)FindEnd.Time)
//{
// aTimer.Start();
//}
this.recievedDataIndexEnd = 0;
this.recievedDataIndexStart = 0;
this.recievedDataIndex = 0;
int bytezaehler = 0;
myMessurement = receivedData.GetRange((int)this.recievedDataIndexStart, receivedData.Count);
foreach (byte b in receivedData)
{
bytezaehler++;
if (0x02 == b) // 0x02 -> StartCondition
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Start Found!");
WriteLogger.WriteLog("-------------------------------");
#endif
this.receiveState = (int)ReceiveState.Start;
this.recievedDataIndexStart = this.recievedDataIndex;
}
if (findEnd == (int)FindEnd.Byte)
{
if (0x03 == b) // 0x03 -> StopCondition
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("End Found -> StopByte(ETX)!");
WriteLogger.WriteLog("-------------------------------");
#endif
this.receiveState = (int)ReceiveState.ReadyToParse;
this.recievedDataIndexEnd = this.recievedDataIndex;
}
}
else if (findEnd == (int)FindEnd.Length)
{
if (bytezaehler >= receivedData.Count) // alle Bytes da?
{
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("End Found -> Length!");
WriteLogger.WriteLog("-------------------------------");
#endif
this.receiveState = (int)ReceiveState.ReadyToParse;
this.recievedDataIndexEnd = this.recievedDataIndex;
}
}
this.recievedDataIndex++;
}
if (this.receiveState == (int)ReceiveState.ReadyToParse)
{
List <byte> Messurement = new List <byte>();
Messurement = receivedData.GetRange((int)this.recievedDataIndexStart, ((this.recievedDataIndexEnd + 1) - (int)this.recievedDataIndexStart));
byte[] tohexstring = new byte[Messurement.Count()];
tohexstring = Messurement.ToArray <byte>();
string hexstring = BitConverter.ToString(tohexstring);
hexstring = hexstring.Replace("-", "");
string ergstring = Converter.Hex2String(hexstring);
List <Laborergebnisse> laborergebnisse = parse(ergstring);
if (!ExceptionOccuredParser && !saved)
{
saveLaborergebnisse(laborergebnisse);
}
}
}
public List <Laborergebnisse> parse(string buffer)
{
//DateTime datum = new DateTime();
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Start Parsing!");
WriteLogger.WriteLog("-------------------------------");
#endif
Measurings = new List <Laborergebnisse>();
buffer = buffer.Replace("\n", "");
string[] werte = buffer.Split('\r');
if (werte.Count() > 0)
{
int count = 0;
DateTime datum = new DateTime();
foreach (string w in werte)
{
count++;
if (!String.IsNullOrEmpty(w))
{
if (w.Substring(0, 1) == "Q" || w.Substring(0, 1) == "q")
{
if (!String.IsNullOrEmpty(w.Substring(2)))
{
string test = w.Substring(2).Replace("h", ":").Replace("H", ":").Replace("mn", ":").Replace("MN", ":").Replace("s", "").Replace("S", "").Replace("/", ".");
datum = DateTime.ParseExact(test, "yy.MM.dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
}
//datum = Convert.ToDateTime(w.Substring(2).Replace("h", ":").Replace("mn", ":").Replace("s", ""));
//DateTime myDatum = DateTime.ParseExact(test, "dd.MM.yy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
//Datum = myDatum.Day.ToString("D2") + myDatum.Month.ToString("D2") + myDatum.Year.ToString("D4");
}
else
{
try
{
//string p = parameter[w.Substring(0, 1)];
string p1 = w.Substring(0, 1);
result = new Laborergebnisse
{
PatientId = patientId,
Datum = datum,
Parameter = parameter[p1],
Langbezeichnung = parameterext[p1],
Wert = w.Substring(2, 5).TrimStart('0'),
Bewertung = w.Substring(7, 2).Replace("l", "-").Replace("h", "+").Replace("L", "-").Replace("H", "+").Replace(" ", "").Replace("U", "-").Replace("u", "-"),
Referenz = reference[p1].Split('_')[0],
Dimension = reference[p1].Split('_')[1],
Reihenfolge = 40000,
Quelle = Title,
};
//if (result.Wert.Length >= 1)
if (!String.IsNullOrEmpty(result.Wert) && result.Wert.Length >= 1)
{
result.Wert = result.Wert.TrimStart();
if (result.Wert[0] == '.')
{
result.Wert = "0" + result.Wert;
}
}
bool addResult = true;
if (!SaveEmptyEntries)
{
addResult = float.TryParse(result.Wert, out float n);
}
foreach (Laborergebnisse l in Measurings)
{
if (l.Parameter == result.Parameter)
{
addResult = false;
}
}
if (addResult)
{
Measurings.Add(result);
}
}
catch (KeyNotFoundException)
{
;
}
catch (Exception ex)
{
ExceptionOccuredParser = true;
MainWindow.main.Dispatcher.Invoke(new Action(delegate()
{
MainWindow.main.SetInfoText("Fehler bei Parsen: " + ex.Message);
MainWindow.main.Background = Brushes.LightPink;
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("Fehler beim Parser: " + ex.Message);
WriteLogger.WriteLog("-------------------------------");
}));
}
}
}
}
}
#if DEBUG
WriteLogger.WriteLog("-------------------------------");
WriteLogger.WriteLog("End Parsing!");
WriteLogger.WriteLog("-------------------------------");
#endif
return(Measurings);
}
