private static void SendVoiceCallRecievedNotification()
{
//BAUSTELLE Anrufer-Nummer herausfinden
//AT^SCNI
//^SCNI: <id> [, < cs > [, < number > , < type > ]]
Gsm_Basics.AddAtCommand("AT^SCNI");
string subject = "Sprachanruf > ";
string body = string.Format("Sprachanruf {0} weitergeleitet. ", DateTime.Now);
MailAddressCollection to = new MailAddressCollection();
foreach (var address in PermanentEmailRecievers)
{
to.Add(address);
}
Send(to, body, subject);
#if DEBUG
Console.WriteLine("Send Email: 'Eingehender Anruf' und sperre erneute E-mail für 30 sec.");
#endif
var t = Task.Run(async delegate
{
await Task.Delay(30000); //es wird maximal alle 30 sec eine mail rausgeschickt.
});
t.Wait();
VoiceCallRecieved = false;
}
public static void Connect()
{
Gsm_Basics.GsmEvent += ParseGsmRecEvent;
Gsm_Basics.GsmConnected += SetupGsm;
Gsm_Basics.Connect();
//Startet Timer zum wiederholten Abrufen von Nachrichten
SetCyclicTimer();
}
static void HandleSmsSentEvent(object sender, Sms e)
{
//Neue bzw. erneut SMS-Nachricht versendet
//Neue SMS-Nachricht empfangen
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.SmsSent, e.Message);
Sql.InsertMessageSent(e.Message, e.Phone, e.MessageReference);
}
static void HandleSmsRecievedEvent(object sender, Sms e)
{
//Neue SMS-Nachricht empfangen
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.SmsRec, e.Message);
//Neue Nachricht in DB speichern
Sql.InsertMessageRec(e.Message, e.Phone);
if (e.Message.Trim().ToLower() == GlobalProperty.SmsRouteTestTrigger.ToLower())
{
//SMS mit 'MeldeAbruf' Empfangen
//if (!Gsm.SmsSendQueue.Contains(e))
{
//Gsm.SmsSend(e.Phone, e.Message + " um " + DateTime.Now);
//Gsm.SmsToDelete.Add(e.Index);
//Gsm.SmsDeletePending();
const string ctrlz = "\u001a";
//Senden
Gsm_Basics.AddAtCommand("AT+CMGS=\"+" + e.Phone + "\"\r");
Gsm_Basics.AddAtCommand(e.Message + " um " + DateTime.Now + ctrlz);
}
}
else
{
bool isBlocked = Sql.IsMessageBlockedNow(e.Message);
if (isBlocked)
{
Sql.Log(MelBoxSql.LogTopic.Shift, MelBoxSql.LogPrio.Info, "Keine SMS: " + e.Message);
}
else
{
//Für jeden Empfänger (Bereitschaft) eine SMS vorbereiten
foreach (ulong phone in Sql.GetCurrentShiftPhoneNumbers())
{
//Nachricht per SMS weiterleiten
Gsm.SmsSend(phone, e.Message);
}
}
//Nachricht per email weiterleiten
System.Net.Mail.MailAddressCollection mailTo = Sql.GetCurrentShiftEmail();
foreach (string mail in Email.PermanentEmailRecievers)
{
mailTo.Add(new System.Net.Mail.MailAddress(mail));
}
Email.Send(mailTo, e, isBlocked);
}
Gsm.ReadGsmMemory();
}
/// <summary>
/// Löscht eine SMS aus dem Speicher
/// </summary>
/// <param name="smsId">Id der SMS im GSM-Speicher</param>
static void SmsDelete(int smsId)
{
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.SmsStatus, "Die SMS mit der Id " + smsId + " wird gelöscht.");
string cmd = "AT+CMGD=" + smsId;
//if (Gsm_Com.ATCommandQueue.Contains(cmd)) return;
Gsm_Basics.AddAtCommand(cmd);
}
/// <summary>
/// Waretet eine Zeit und stößt dann das Lesen des GSM-Speichers an
/// </summary>
internal static void SetCyclicTimer()
{
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmSystem, "Erste Abfrage: " + DateTime.Now.AddSeconds(GsmReadCycleSeconds));
System.Timers.Timer aTimer = new System.Timers.Timer(GsmReadCycleSeconds * 1000); //sec
aTimer.Elapsed += (sender, eventArgs) =>
{
#region Test Übersicht Nachrichten im Speicher
#if DEBUG
int n = 0;
foreach (var sms in Gsm.SmsSendQueue)
{
DebugShowSms(sms, "Sendeliste " + ++n);
}
n = 0;
foreach (var sms in Gsm.SmsTrackingQueue)
{
DebugShowSms(sms, "Trackingliste " + ++n);
}
#endif
#endregion
//Zeitüberschreitung Empfangsbestätigung prüfen
foreach (var sms in Gsm.SmsTrackingQueue)
{
if (sms.SmsProviderTimeStamp.AddMinutes(Properties.Settings.Default.SmsAckTimeoutMinutes).CompareTo(DateTime.UtcNow) > 0) // > 0; t1 ist später als oder gleich t2.
{
Email.Send(
Email.MelBox2Admin,
string.Format("Zeitüberschreitung SMS-Empfangsbestätigung (nach {0} min) für SMS an \r\n+{1}\r\n{2}\r\n\r\nSendeversuch um {3}", Properties.Settings.Default.SmsAckTimeoutMinutes, sms.Phone, sms.Message, sms.SmsProviderTimeStamp),
"Fehlende SMS-Empfangsbestätigung"
);
//SmsTrackingQueue.Remove(sms);
}
}
Gsm_Basics.AddAtCommand("AT+CREG?");
Gsm_Basics.AddAtCommand("AT+CSQ");
ReadGsmMemory();
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmSystem, "Nächste Abfrage: " + DateTime.Now.AddSeconds(GsmReadCycleSeconds));
};
aTimer.AutoReset = true;
aTimer.Enabled = true;
}
static void HandleSmsStatusReportEvent(object sender, Sms e)
{
//Empfangener Statusreport (z.B. Sendebestätigung)
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.SmsStatus, string.Format("Empfangsbestätigung erhalten für SMS-Referrenz {0}", e.MessageReference));
Sql.InsertMessageStatus(e.MessageReference, e.SendStatus); //provisorisch - später entfernen?
Sql.UpdateMessageSentStatus(MelBoxSql.SendWay.Sms, e.MessageReference, e.SmsProviderTimeStamp, e.SendStatus);
//Status prüfen 0-31 erfolgreich versandt; 32-63 versucht weiter zu senden: 64-127 Sendeversuch abgebrochen
if (63 > e.SendStatus && e.SendStatus < 128)
{
//BAUSTELLE: In DB prüfen, ob die Nachricht schonal erfolglos versdnet wurde, wenn ja Abbruch, wenn nein; Sendewiederholung
Email.Send(Email.MelBox2Admin, string.Format("Sendeabbruch. Wiederhole SMS senden an \r\n+{0}\r\n{1}\r\n\r\nSendeversuch um {2}", e.Phone, e.Message, e.SmsProviderTimeStamp), "SMS-Sendeversuch wiederholen");
Gsm.SmsSend(e.Phone, e.Message);
}
}
/// <summary>
/// Lese die Referenz einer zuvor gesendeten Nachricht aus und weise sie der gesendeten SMS zu.
/// Gebe das Senden der nächsten SMS frei.
/// </summary>
/// <param name="input"></param>
private static void ParseSmsReference(string input)
{
if (input == null)
{
return;
}
//CMGS=[...] CMSS=[...]
/* z.B.
+CMGS: 67 +CMSS: 67
* OK OK
*/
Regex r = new Regex(@"\+CM[GS]S: (\d+)");
Match m = r.Match(input);
while (m.Success)
{
if (byte.TryParse(m.Groups[1].Value, out byte trackingId))
{
if (CurrentSmsSend == null)
{
//Fehler: Empfangsbestätigung, aber keine SMS gesendet
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmError, string.Format("Erhaltene Empfangsbestätigung {0} konnte nicht zugewiesen werden.", trackingId), trackingId);
break;
}
Console.WriteLine("Tracking-ID {0} erfasst für Nachricht an:\r\n+{1}\r\n{2}", trackingId, CurrentSmsSend.Phone, CurrentSmsSend.Message);
CurrentSmsSend.MessageReference = trackingId;
CurrentSmsSend.SmsProviderTimeStamp = DateTime.UtcNow; // für Timeout Sendungsverfolgung
SmsTrackingQueue.Add(CurrentSmsSend);
MelBox2.GlobalProperty.SmsPendingReports = SmsTrackingQueue.Count;
RaiseSmsSentEvent(CurrentSmsSend);
//Wieder frei machen für nächste zu sendende SMS
CurrentSmsSend = null;
//Nächste Nachricht senden
//SmsSendFromList();
}
m = m.NextMatch();
}
}
/// <summary>
/// Sendet die erste SMS aus der Sendeliste
/// Sperrt weiteres SMS-senden, bis der gesendeten SMS vom Modem eine Referenz zugewiesen wurde.
/// </summary>
private static void SmsSendFromList()
{
//CurrentSmsSend wird zur Sendefreigabe auf null gesetzt. Siehe Modem-Antwort '+CMGS: <mr>'
if (SmsSendQueue.Count == 0)
{
return;
}
if (CurrentSmsSend != null)
{
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmSystem, "SMS-Sendeplatz noch nicht frei. Warte auf: " + CurrentSmsSend.Message);
return;
}
Console.WriteLine("### zu sendende SMSen {0} ###", SmsSendQueue.Count);
foreach (Sms sms in SmsSendQueue)
{
Console.WriteLine("Index: {0}\tAn: {1}\t{2}", sms.Index, sms.Phone, sms.Message);
}
CurrentSmsSend = SmsSendQueue.FirstOrDefault();
SmsSendQueue.Remove(SmsSendQueue.FirstOrDefault()); //.RemoveAt(0);
GlobalProperty.LastSmsSend = CurrentSmsSend.Message;
const string ctrlz = "\u001a";
//Senden
Gsm_Basics.AddAtCommand("AT+CMGS=\"+" + CurrentSmsSend.Phone + "\"\r");
Gsm_Basics.AddAtCommand(CurrentSmsSend.Message + ctrlz);
//Danach warten auf Antwort von GSM-Modem '+CMGS: <mr>' um CurrentSmsSend die Referenz für Empfangsbestätigung zuzuweisen.
//Nach Zuweisung der Referenz:
//1) CurrentSmsSend als gesendete SMS in DB schreiben
//2) CurrentSmsSend = null setzen
//3) diese Methode erneut aufrufen.
}
/// <summary>
/// (Manuelles) Anstoßen des Lesens und Verarbeitens des GSM-Modem-Speichers
/// </summary>
public static void ReadGsmMemory()
{
SmsDeletePending();
Gsm_Basics.AddAtCommand("AT+CMGL=\"ALL\"");
}
private static void SetupGsm(object sender, GsmEventArgs e)
{
//Nur beim Verbinden ausführen
if (e == null || e.Type != GsmEventArgs.Telegram.GsmConnection || !e.Message.ToLower().Contains("verbunden"))
{
return;
}
System.Threading.Thread.Sleep(2000); //Angstpause
//Test, ob Modem antwortet
Gsm_Basics.AddAtCommand("AT");
//Sicherstellen, dass die ANfrage in der Antwort wiederholt wird.
//Gsm_Basics.AddAtCommand("ATE1");
Gsm_Basics.AddAtCommand("AT^SSET=1");
//Set AT+CMEE =2 to enable extended error text.
Gsm_Basics.AddAtCommand("AT+CMEE=2");
//Erzwinge, dass bei Fehlerhaftem SMS-Senden "+CMS ERROR: <err>" ausgegeben wird statt "OK"
Gsm_Basics.AddAtCommand("AT^SM20=0,0");
//Benachrichtigung bei SIM-Karten erkannt oder Sim-Slot offen/zu
Gsm_Basics.AddAtCommand("AT^SCKS=1");
Gsm_Basics.AddAtCommand("AT^SCKS?");
//EIgene Telefonnumer-Nummer der SIM-Karte auslesen
Gsm_Basics.AddAtCommand("AT+CNUM");
//SIM-Karte im Mobilfunknetz registriert?
Gsm_Basics.AddAtCommand("AT+CREG=1");
//Name Mobilfunknetz?
Gsm_Basics.AddAtCommand("AT+COPS?");
//Signalqualität
Gsm_Basics.AddAtCommand("AT+CSQ");
//Nicht getestet: Zeit zwischen setzen und Abfragen notwendig?
Gsm_Basics.AddAtCommand("AT+CREG?");
//SMS-Service-Center Adresse
Gsm_Basics.AddAtCommand("AT+CSCA?");
//Modemhersteller
Gsm_Basics.AddAtCommand("AT+CGMI");
//Textmode
Gsm_Basics.AddAtCommand("AT+CMGF=1");
//SendATCommand("AT+CPMS=\"SM\""); //ME, SM, MT
//SendATCommand("AT+CPMS=\"MT\",\"MT\",\"MT\"");
Gsm_Basics.AddAtCommand("AT+CPMS=\"MT\",\"MT\",\"MT\"");
//Sendeempfangsbestätigungen abonieren
//Quelle: https://www.codeproject.com/questions/271002/delivery-reports-in-at-commands
//Quelle: https://www.smssolutions.net/tutorials/gsm/sendsmsat/
//AT+CSMP=<fo> [, <vp> / <scts> [, <pid> [, <dcs> ]]]
// <fo> First Octet:
// <vp> Validity-Period: 0 - 143 (vp+1 x 5min), 144 - 167 (12 Hours + ((VP-143) x 30 minutes)), [...]
Gsm_Basics.AddAtCommand("AT+CSMP=49,1,0,0");
Gsm_Basics.AddAtCommand("AT+CNMI=2,1,2,2,1");
//möglich AT+CNMI=2,1,2,2,1
ReadGsmMemory();
//Rufumleitung BAUSTELLE: nicht ausreichend getestet //
//Gsm_Basics.AddAtCommand("ATD*61*+" + Properties.Settings.Default.RelayIncomingCallsTo + "*11*05#;"); //Antwort ^SCCFC : <reason>, <status> (0: inaktiv, 1: aktiv), <class> [,.
Gsm_Basics.AddAtCommand("ATD*61*+" + Properties.Settings.Default.RelayIncomingCallsTo + "*05#;");
System.Threading.Thread.Sleep(4000); //Antwort abwarten - Antwort wird nicht ausgewertet.
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmSystem, "GSM-Setup wird ausgeführt.");
}
/// <summary>
/// Wird bei jedem Empfang von Daten durch COM aufgerufen!
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
static void ParseGsmRecEvent(object sender, GsmEventArgs e)
{
if (e.Type != GsmEventArgs.Telegram.GsmRec)
{
return;
}
string input = e.Message;
if (input == null)
{
return;
}
if (input == "\r\nOK\r\n")
{
return;
}
#region SMS-Verarbeitung
//COM-Antwort auf Gesendete SMS: Referenzzuweisung für Empfangsbestätigung
if (input.Contains("+CMGS:") || input.Contains("+CMSS:")) //
{
ParseSmsReference(input);
}
//Liste der Nachrichten im GSM-Speicher
if (input.Contains("+CMGL:"))
{
//Empfangsbestätigungen lesen
ParseStatusReport(input);
SmsDeletePending();
//Empfangen neuer Nachrichten
ParseSmsMessages(input);
SmsDeletePending();
}
//Indikator neuen Statusreport empfangen
if (input.Contains("+CDSI:"))
{
/*
* Meldung einer neu eingegangenen Nachricht von GSM-Modem
*
* Neuen Statusreport empfangen:
* bei AT+CNMI= [ <mode> ][, <mt> ][, <bm> ][, 2 ][, <bfr> ]
* erwartete Antwort: +CDSI: <mem3>, <index>
* //*/
ReadGsmMemory();
}
//Indikator neue SMS empfangen
if (input.Contains("+CMTI:"))
{
/*
* Meldung einer neu eingegangenen Nachricht von GSM-Modem
*
* Neue SMS emfangen:
* bei AT+CNMI= [ <mode> ][, 1 ][, <bm> ][, <ds> ][, <bfr> ]
* erwartete Antwort: +CMTI: <mem3>, <index>
* //*/
ReadGsmMemory();
}
//Fehlermeldung von Modem bei SMS senden oder Empfangen
if (input.Contains("+CMS ERROR:"))
{
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmError, "Am GSM-Modem ist ein Fehler beim Senden oder Empfangen einer SMSM aufgetreten", input);
}
#endregion
#region Sprachanruf
//+CRING: VOICE
if (input.Contains("+CRING: VOICE"))
{
Email.VoiceCallRing();
}
#endregion
#region SIM-Status
//GSM-Signalqualität
if (input.Contains("+CSQ:"))
{
//+CSQ: <rssi> , <ber>
//<rssi> Mögliche Werte: 2 - 9 marginal, 10 - 14 OK, 15 - 19 Good, 20 - 30 Excellent, 99 = kein Signal
//<ber> Bit-Error-Rate: 0 bis 7 = Sprachqualität absteigend, 99 = unbekannt
Regex rS = new Regex(@"CSQ:\s([0-9]+),([0-9]+)");
Match m = rS.Match(input);
if (!int.TryParse(m.Groups[1].Value, out int rawQuality))
{
return;
}
int qualityPercent = 0;
if (rawQuality < 99)
{
qualityPercent = rawQuality * 100 / 31;
}
while (m.Success)
{
RaiseGsmSignalQualityEvent(new GsmEventArgs(GsmEventArgs.Telegram.GsmSignal, string.Format("GSM Signalstärke {0:00}%", qualityPercent), qualityPercent));
m = m.NextMatch();
}
}
//Eigene Rufnummer lesen
if (input.Contains("+CNUM:"))
{
Regex r = new Regex(@"\+CNUM: ""(.+)"",""(.+)"",(.*)"); //SAMBA75
Match m = r.Match(input);
//Console.WriteLine(input);
while (m.Success)
{
string name = m.Groups[1].Value;
string strPhone = m.Groups[2].Value;
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmOwnPhone, string.Format("Eigene Nummer: '{0}' {1}", name, strPhone), GsmConverter.StrToPhone(strPhone));
m = m.NextMatch();
}
}
//BAUSTELLE
//Herstellername Modem
if (input.Contains("+CGMI:"))
{
Regex r = new Regex(@"\+CGMI\n(.+)");
Match m = r.Match(input);
if (m.Success)
{
GlobalProperty.ModemManufacturer = m.Groups[1].Value;
}
}
//BAUSTELLE
//SMS Service-Center Adresse // +CSCA: "+491710760000",145 //+CSCA: "+491710760000",145
if (input.Contains("+CSCA: "))
{
//+CSCA: "+491710760000",145
Regex r = new Regex(@"\+CSCA: ""(.+)"",(\d+)");
Match m = r.Match(input);
if (m.Success)
{
GlobalProperty.NetworkServiceCenterNumber = m.Groups[1].Value;
}
}
//SIM-Schubfach / SIM erkannt
if (input.Contains("^SCKS:"))
{
//Antwort auf 'AT^SCKS?': '^SCKS: <mode>,<SimStatus>'
Regex r = new Regex(@"\^SCKS: (\d+),(\d+)");
Match m = r.Match(input);
if (m.Success)
{
if (int.TryParse(m.Groups[2].Value, out int simCardHolderStatus))
{
if (simCardHolderStatus == 1)
{
GlobalProperty.SimHolderDetected = true;
}
else
{
GlobalProperty.SimHolderDetected = false;
}
}
}
else
{
//Meldung von Modem nach Ereignis 'Sim-Schublade'
r = new Regex(@"\^SCKS: (\d+)");
m = r.Match(input);
if (m.Success)
{
if (int.TryParse(m.Groups[1].Value, out int simCardHolderStatus))
{
if (simCardHolderStatus == 1)
{
GlobalProperty.SimHolderDetected = true;
}
else
{
GlobalProperty.SimHolderDetected = false;
}
}
}
}
}
//Registrierung im Mobilfunknetz
if (input.Contains("+CREG:"))
{
Regex r = new Regex(@"\+CREG: (\d),(\d)"); //SAMBA75
Match m = r.Match(input);
while (m.Success)
{
if (int.TryParse(m.Groups[2].Value, out int networkRegStatus))
{
switch (networkRegStatus)
{
case 0:
GlobalProperty.NetworkRegistrationStatus = "nicht registriert";
break;
case 1:
GlobalProperty.NetworkRegistrationStatus = "registriert";
SetupGsm(null, null);
break;
case 2:
GlobalProperty.NetworkRegistrationStatus = "Netzsuche";
break;
case 3:
GlobalProperty.NetworkRegistrationStatus = "Registrierung abgelehnt";
break;
case 5:
GlobalProperty.NetworkRegistrationStatus = "Roaming";
break;
default:
GlobalProperty.NetworkRegistrationStatus = "unbekannt";
break;
}
}
m = m.NextMatch();
}
if (input.Contains("+CREG: 0,0"))
{
Gsm_Basics.RaiseGsmEvent(GsmEventArgs.Telegram.GsmError, "Das GSM-Modem ist nicht im Mobilfunknetz angemeldet.");
}
}
//Anbietername Mobilfunknetz
if (input.Contains("+COPS:"))
{
Regex r = new Regex(@"\+COPS: (\d),(\d),""(.*)"""); //z.B. +COPS: 0,0,"T-Mobile D"
Match m = r.Match(input);
while (m.Success)
{
GlobalProperty.NetworkProviderName = m.Groups[3].Value;
m = m.NextMatch();
}
}
#endregion
}
private static void Main()
{
try
{
Console.BufferHeight = 1000; //Max. Zeilen in Konsole, bei Überlauf werden älteste Zeilen entfernt
Console.WriteLine("Programm gestartet. Konsole mit max. {0} Zeilen.", Console.BufferHeight);
Email.PermanentEmailRecievers = Properties.Settings.Default.PermanentEmailRecievers.Cast <string>().ToList();
Email.MelBox2Admin = new System.Net.Mail.MailAddress("*****@*****.**", "MelBox2 Admin"); //Properties gehen nicht?
Gsm_Basics.ComPortName = Properties.Settings.Default.ComPort;
Gsm_Basics.BaudRate = Properties.Settings.Default.BaudRate;
Gsm_Basics.GsmConnected += HandleGsmEvent;
Gsm_Basics.GsmEvent += HandleGsmEvent;
Gsm.GsmSignalQualityEvent += HandleGsmEvent;
Gsm.SmsRecievedEvent += HandleSmsRecievedEvent;
Gsm.SmsSentEvent += HandleSmsSentEvent;
Gsm.SmsStatusreportEvent += HandleSmsStatusReportEvent;
MelBoxWeb.StartWebServer();
Sql.Log(MelBoxSql.LogTopic.Start, MelBoxSql.LogPrio.Info, string.Format("MelBox2 - Anwendung gestartet. {0}, {1} Baud", Gsm_Basics.ComPortName, Gsm_Basics.BaudRate));
InitDailyCheck(Properties.Settings.Default.HourOfDailyCheck); //Führt täglich morgens um 8 Uhr Routinecheck aus
//TEST
Sql.InsertMessageRec("Testnachricht am " + DateTime.Now.Date, 4915142265412);
//Auskommentiert für Test WebServer
Gsm.Connect();
#if DEBUG
Console.WriteLine("\r\nDEBUG Mode: es wird keine StartUp-Info an MelBox2-Admin gesendet.");
//Email.Send(Email.MelBox2Admin, "MelBox2 - Anwendung neu gestartet um " + DateTime.Now);
#else
//Gsm.SmsSend(Properties.Settings.Default.MelBoxAdminPhone, "MelBox2 - Anwendung neu gestartet um " + DateTime.Now); //besser Email
Email.Send(Email.MelBox2Admin, "MelBox2 - Anwendung neu gestartet um " + DateTime.Now);
#endif
const string help = "\r\n- ENTF zum Aufräumen der Anzeige\r\n" +
"- EINF für AT-Befehl\r\n" +
"- ESC Taste zum beenden...\r\n";
Console.WriteLine(help);
while (true)
{
ConsoleKeyInfo pressed = Console.ReadKey();
//Console.WriteLine("Gedrückt: " + pressed.KeyChar);
if (pressed.Key == ConsoleKey.Escape)
{
break;
}
if (pressed.Key == ConsoleKey.Delete)
{
Console.Clear();
GlobalProperty.ShowOnConsole();
Console.WriteLine(help);
}
//if (pressed.Key == ConsoleKey.O)
//{
// Console.Clear();
// GlobalProperty.ShowOnConsole();
// //Console.WriteLine("\r\nOPTIONEN:\r\n\tModem: Umschalten eingehend");
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmError + ":\t" + GsmEventArgs.Telegram.GsmError);
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmSystem + ":\t" + GsmEventArgs.Telegram.GsmSystem);
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmConnection + ":\t" + GsmEventArgs.Telegram.GsmConnection);
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmSignal + ":\t" + GsmEventArgs.Telegram.GsmSignal);
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmOwnPhone + ":\t" + GsmEventArgs.Telegram.GsmOwnPhone);
// //Console.WriteLine((byte)GsmEventArgs.Telegram.GsmOwnPhone + ":\t" + GsmEventArgs.Telegram.GsmOwnPhone);
// //Console.WriteLine("Konsolenanzeige: Bitweise Filter setzten (sperren):");
// //Console.WriteLine("\r\n\tBitte Nummer auswählen.");
// //string input = Console.ReadLine();
// //if (byte.TryParse(input, out byte a))
// //{
// // ConsoleDisplayBlock = a;
// //}
// Console.Clear();
// Console.WriteLine(help);
//}
if (pressed.Key == ConsoleKey.Insert)
{
Console.WriteLine("AT-Befehl eingeben:");
string at = Console.ReadLine();
Gsm_Basics.AddAtCommand(at);
}
}
}
finally
{
Console.WriteLine("Programm wird geschlossen...");
MelBoxWeb.StopWebServer();
Gsm_Basics.ClosePort();
System.Threading.Thread.Sleep(3000);
}
}
