private PttState GetPtt(string pttSrcId) { PttState ptt = PttState.NoPtt; if (!Tx || (Top.Rd.PttSource == PttSource.NoPtt) || (Top.Lc.Activity && (Top.Mixer.SplitMode != SplitMode.LcTf))) { if (!string.IsNullOrEmpty(pttSrcId) && pttSrcId != Top.HostId) { ptt = PttState.ExternPtt; } } else if (pttSrcId == Top.HostId) { ptt = PttState.PttOnlyPort; } else if (pttSrcId == "NO_CARRIER") { ptt = PttState.CarrierError; } else if (pttSrcId == "ERROR") { ptt = PttState.Error; } else if (!string.IsNullOrEmpty(pttSrcId)) { ptt = PttState.Blocked; } return(ptt); }
public void Reset(SquelchState st) { _Squelch = st; switch (_Squelch) { case SquelchState.Unavailable: _TempRtxGroup = _RtxGroup; break; case SquelchState.SquelchOnlyPort: if (_Ptt == PttState.PttPortAndMod) { _Ptt = PttState.PttOnlyPort; } break; case SquelchState.SquelchPortAndMod: if (_Ptt == PttState.PttOnlyPort) { _Ptt = PttState.PttPortAndMod; } break; } }
private void OnFrRxChanged(object sender) { Rs <RdSrvRxRs> rs = (Rs <RdSrvRxRs>)sender; Debug.Assert(_AssociateRxRs.Contains(rs)); if (Rx) { string rsId = rs.Id.ToUpper(); _Logger.Debug("*** OnFrRxchanged({2}). rs.IsValid es {0} {1}:", rs.IsValid, Pos, rsId); if (rs.IsValid) { // Debug.Assert(!_RxPorts.ContainsKey(rsId)); if (_RxPorts.ContainsKey(rsId)) { //_RxPorts.Remove(rsId); /* Provocar el paso por aspas cuando se cae la red*/ RxOff(); // Provocar la liberación del transmisor HF // en caso de que estuviera ocupado por este usuario if (_TipoFrecuencia == TipoFrecuencia_t.HF) { _RtxGroup = Math.Min(_RtxGroup, 0); Tx = false; Top.Registry.SetTx(_Literal, false, _Priority, false); } _Rx = AssignState.Idle; _RtxGroup = 0; _Squelch = SquelchState.Unavailable; _Ptt = PttState.Unavailable; _PttSrcId = string.Empty; _Estado = RdSrvFrRs.FrequencyStatusType.NotAvailable; General.SafeLaunchEvent(StateChanged, this); /* Fin cambio */ } _Logger.Debug("*** OnFrRxchanged({2}). Llamando a CreateRdRxPort({0}, pos {1})", rsId, Pos, rsId); CreateRxAudio(rs, rsId); } else { int port; if (_RxPorts.TryGetValue(rsId, out port)) { Top.Mixer.Unlink(port); _Logger.Debug("*** OnFrRxChanged({2}). Llamando a DestroyRdRxPort({0})", port, rsId); SipAgent.DestroyRdRxPort(port); _RxPorts.Remove(rsId); } } } }
public void Reset(RdInfo dst) { if (dst.Dst == "") { Reset(); } else { _Frecuency = dst.Dst; _Alias = dst.Alias; _TempAlias = string.Empty; _Ptt = dst.Ptt; _Squelch = dst.Squelch; _Tx = dst.Tx; _Rx = dst.Rx || _Tx; _AudioVia = _Rx ? dst.AudioVia : RdRxAudioVia.NoAudio; _Monitoring = dst.Monitoring;// && !Unavailable; _RtxGroup = _TempRtxGroup = dst.RtxGroup; _TipoFrecuencia = dst.TipoFrecuencia; _State = dst.Estado; _qidxResource = _qidxMethod = string.Empty; _qidxValue = 0; _RxOnly = dst.RxOnly; /** 20180321. AGL. ALIAS a mostrar en la tecla... */ if (Properties.Settings.Default.RadioAlias == true) { _KeyAlias = dst.KeyAlias == dst.Dst ? "" : dst.KeyAlias; } else { _KeyAlias = (_TempAlias != string.Empty && _TempAlias != _Alias) ? _TempAlias : _Alias; } /** */ if (!Restored && Unavailable && (dst.Ptt != PttState.Unavailable || dst.Squelch != SquelchState.Unavailable)) { _Restored = true; } else { _Restored = false; } Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio)); Debug.Assert(!_Tx || Rx); if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort)) { _Ptt = PttState.PttPortAndMod; } else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod)) { _Ptt = PttState.PttOnlyPort; } //_PttSrcId = dst.PttSrcId; } }
public RdInfo(string dst, string alias, bool tx, bool rx, PttState ptt, SquelchState squelch, RdRxAudioVia audioVia, int rtxGroup, TipoFrecuencia_t tipoFrecuencia, bool monitoring, FrequencyState estado, bool rxOnly) { Dst = dst; Alias = alias; Tx = tx; Rx = rx; Ptt = ptt; Squelch = squelch; AudioVia = audioVia; RtxGroup = rtxGroup; TipoFrecuencia = tipoFrecuencia; Monitoring = monitoring; Estado = estado; RxOnly = rxOnly; }
public void Reset(RdState st) { if (Unavailable && (st.Ptt != PttState.Unavailable || st.Squelch != SquelchState.Unavailable)) { _Restored = true; } else { _Restored = false; } _Ptt = st.Ptt; _Squelch = st.Squelch; _Tx = st.Tx; _Rx = st.Rx || _Tx; // || _Monitoring || _Tx; _AudioVia = _Rx ? st.AudioVia : RdRxAudioVia.NoAudio; // !_Monitoring ? st.AudioVia : RdRxAudioVia.Speaker; if (_RtxGroup != _TempRtxGroup) { _RtxGroup = st.RtxGroup; } else { _RtxGroup = _TempRtxGroup = st.RtxGroup; } //_RtxGroup = st.RtxGroup; Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio)); Debug.Assert(!_Tx || Rx); if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort)) { _Ptt = PttState.PttPortAndMod; } else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod)) { _Ptt = PttState.PttOnlyPort; } // BSS Information _qidxMethod = st.QidxMethod; _qidxResource = st.QidxResource; _qidxValue = st.QidxValue; _State = st.State; _PttSrcId = st.PttSrcId; }
public RdState(bool tx, bool rx, string pttSrcId, PttState ptt, SquelchState squelch, RdRxAudioVia audioVia, int rtxGroup, FrequencyState state, string qidxMethod, uint qidxValue, string qidxResource) { Tx = tx; Rx = rx; Ptt = ptt; Squelch = squelch; AudioVia = audioVia; RtxGroup = rtxGroup; State = state; // BSS Information QidxMethod = qidxMethod; QidxValue = qidxValue; QidxResource = qidxResource; PttSrcId = pttSrcId; }
public void ResetToIdle() { _Tx = false; _Rx = false; _Ptt = PttState.NoPtt; _Squelch = SquelchState.NoSquelch; _AudioVia = RdRxAudioVia.NoAudio; _RtxGroup = _TempRtxGroup = 0; _Monitoring = false; _Restored = true; _TipoFrecuencia = TipoFrecuencia_t.Basica; _qidxResource = _qidxMethod = string.Empty; _qidxValue = 0; _State = FrequencyState.NotAvailable; _RxOnly = false; /** 20190205 */ _PttSrcId = string.Empty; }
/// <summary> /// Función que determina si el audio debe ser inhibido /// 1-Si la frecuencia esta en un grupo de RTX, y estoy en el puesto propietario del grupo /// y hay SQ y la retransmisión esta activa, no conecto mi audio porque se debe escuchar el que se está retransmitiendo. /// 2-Si tengo PTT propio no conecto mi audio /// </summary> /// <param name="frRs"> Datos de frecuencia</param> /// <param name="frRs"> Datos de frecuencia</param> private bool InhiboMiAudio(PttState ptt, RdSrvFrRs frRs) { if (ptt == PttState.ExternPtt && frRs.RtxGroupId != 0 && frRs.RtxGroupOwner == Top.HostId && frRs.Squelch == RdSrvFrRs.SquelchType.SquelchOnlyPort && frRs.PttSrcId.StartsWith("Rtx_")) { return(true); } else if (ptt == PttState.PttOnlyPort) { return(true); } else if (_PttOffTimer.Enabled) { return(true); //Si el timer activado despues de Ptt off sigue activo, el audio se inhibe } else { return(false); } }
private void controlPtt(SerialPort port, PttState newState) { switch (newState) { case PttState.Open: if (cbComPort.Text == "VOX") { ThreadStart childref = new ThreadStart(CallToVoxThread); voxThread = new Thread(childref); voxThread.Start(); toolStripStatusLabel1.Text = "VOX tone active."; Pause(ExtraPauseForVox); } else { if (port.IsOpen) { port.Close(); Thread.Sleep(int.Parse(txtPauseBetweenLines.Text)); } try { port.Open(); toolStripStatusLabel1.Text = "PTT open."; } catch (Exception ex) { toolStripStatusLabel1.Text = "Error opening PTT: " + ex.Message; } } statusStrip1.BackColor = transmittingColor; break; case PttState.Closed: if (cbComPort.Text == "VOX") { if (voxThread != null) { voxThread.Abort(); } toolStripStatusLabel1.Text = ""; Pause(ExtraPauseForVox); } else { if (port.IsOpen) { try { port.Close(); toolStripStatusLabel1.Text = "PTT closed."; } catch (Exception ex) { toolStripStatusLabel1.Text = "Error closing PTT: " + ex.Message; } } } statusStrip1.BackColor = SystemColors.Control; break; default: break; } }
private void OnFrChanged(object sender) { Rs <RdSrvFrRs> rs = (Rs <RdSrvFrRs>)sender; bool changed = false; bool changedQidx = false; if (!rs.IsValid) { RxOff(); // Provocar la liberación del transmisor HF // en caso de que estuviera ocupado por este usuario if (_TipoFrecuencia == TipoFrecuencia_t.HF) { _RtxGroup = Math.Min(_RtxGroup, 0); Tx = false; Top.Registry.SetTx(_Literal, false, _Priority, false); } _Rx = AssignState.Idle; _RtxGroup = 0; _Squelch = SquelchState.Unavailable; _Ptt = PttState.Unavailable; _PttSrcId = string.Empty; _Estado = RdSrvFrRs.FrequencyStatusType.NotAvailable; _QidxValue = 0; _QidxResource = string.Empty; changed = true; } else { RdSrvFrRs frRs = rs.Info; if (frRs.PttSrcId == "TxHfOff") { if (_Tx == AssignState.Set) { // Reflejar el estado real de Tx. Puede que el recurso no // esté disponble en la configuración de la pasarela. En // cuyo caso se debe quitar de transmisión _Tx = AssignState.Idle; _Ptt = PttState.NoPtt; _PttSrcId = frRs.PttSrcId; // Actualizar estado de Tx a Off General.SafeLaunchEvent(StateChanged, this); // Enviar mensaje para ventana de error General.SafeLaunchEvent(TxHfAlreadyAssigned, this, (uint)0xFE); } frRs.PttSrcId = string.Empty; //return; } // // Tratamiento del cambio en el estado de Squelch // switch (_TipoFrecuencia) { case TipoFrecuencia_t.FD: if (_Squelch != (SquelchState)frRs.Squelch) { _Squelch = (SquelchState)frRs.Squelch; changed = true; } if (ChangeInQidxInfo(frRs)) { // BSS Information _QidxMethod = frRs.QidxMethod; _QidxResource = _Squelch == SquelchState.NoSquelch ? string.Empty : frRs.SqSite; _QidxValue = _Squelch == SquelchState.NoSquelch ? 0 : frRs.QidxValue; changedQidx = true; } break; // EM case TipoFrecuencia_t.ME: if (_Squelch != (SquelchState)frRs.Squelch && (frRs.SqSite == Alias || frRs.SqSite == string.Empty)) { _Squelch = (SquelchState)frRs.Squelch; changed = true; // BSS Information _QidxMethod = frRs.QidxMethod; _QidxResource = frRs.SqSite; _QidxValue = frRs.QidxValue; } break; default: if (_Squelch != (SquelchState)frRs.Squelch) { _Squelch = (SquelchState)frRs.Squelch; changed = true; } break; } if (_Squelch != (SquelchState)frRs.Squelch && (frRs.SqSite == Alias || frRs.SqSite == string.Empty)) { _Squelch = (SquelchState)frRs.Squelch; changed = true; } // // Tratamiento del cambio en el estado de PTT // PttState ptt = GetPtt(frRs.PttSrcId); if ((frRs.PttSrcId != _PttSrcId) && (ptt == PttState.Error)) { Top.Rd.GenerateBadOperationTone(2000); } // Es posible que no cambie el ptt (externo) pero si cambie su procedencia: // Cambio de ptt externo de rtx a externo de otro HMI. // En este caso hay que evaluar el audio if (ptt != _Ptt || changed || frRs.PttSrcId != _PttSrcId) { if (ptt != _Ptt) { if (ptt == PttState.NoPtt) { if ((_Ptt == PttState.ExternPtt) || (_Ptt == PttState.PttOnlyPort) || (_Ptt == PttState.PttPortAndMod)) { //Al desactivarse el Ptt arranca un timer durante el cual se inhibe el audio de Rd Rx //Solo cuando el estado anterior es un ptt #3830 _PttOffTimer.Enabled = true; } } else { //Cualquier activacion del Ptt anula el timer _PttOffTimer.Enabled = false; } } // Si estoy en Ptt o // Estoy en RTX de otro SQ del grupo y soy dueño del grupo (dejo el otro audio) // no conecto mi audio if (InhiboMiAudio(ptt, frRs) == true) { foreach (int port in _RxPorts.Values) { Top.Mixer.Unlink(port); } } else { foreach (int port in _RxPorts.Values) { if (Rx) { if (Squelch == SquelchState.SquelchOnlyPort) { MixerDev dev = (_AudioVia == RdRxAudioVia.HeadPhones ? MixerDev.MhpRd : (_AudioVia == RdRxAudioVia.HfSpeaker ? MixerDev.SpkHf : MixerDev.SpkRd)); Top.Mixer.Link(port, dev, MixerDir.Send, Mixer.RD_PRIORITY, FuentesGlp.RxRadio); } else if (Squelch == SquelchState.NoSquelch) { Top.Mixer.Unlink(port); } } } } _Ptt = ptt; _PttSrcId = frRs.PttSrcId; changed = true; } // // Tratamiento del cambio en el estado de la retransmisión // int rtxGroup = 0; if (frRs.RtxGroupId != 0) { rtxGroup = frRs.RtxGroupOwner == Top.HostId ? (int)frRs.RtxGroupId : -1; } if (rtxGroup != _RtxGroup) { _RtxGroup = rtxGroup; changed = true; } // // Tratamiento del cambio en el estado de disponibilidad de la frecuencia. // if (frRs.FrequencyStatus != _Estado) { _Estado = frRs.FrequencyStatus; changed = true; } } if (changed || changedQidx) { General.SafeLaunchEvent(StateChanged, this); } }