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);
}
}
