GitHub/sdrtrunk
1
0
Fork 0
mirror of https://github.com/DSheirer/sdrtrunk.git synced 2026-11-12 16:47:31 -05:00
Code Issues Packages Projects Releases 2 Wiki Activity

#1444 Adds: (#1447)

Browse Source 
* DMR Recording viewer utility
* DMR talker aliases
* DMR SMS messages
* DMR Hytera Tier-III compressed talkgroups support
* DMR UDT packet sequences
* DMR Hytera Aloha and other unknown CSBK and Link Control messages

Co-authored-by: Dennis Sheirer <dsheirer@github.com>
This commit is contained in:
Denny Sheirer
2023-02-18 08:36:55 -05:00
committed by GitHub
parent b51a0102ef
commit 8f68a989b9
41 changed files with 2983 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/main/java/io/github/dsheirer/module/decode/dmr/DMRDecoderState.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -59,6 +59,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.header.HeaderMessage;
import io.github.dsheirer.module.decode.dmr.message.data.lc.LCMessage;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.GPSInformation;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.GroupVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasComplete;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.UnitToUnitVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.hytera.HyteraGroupVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.hytera.HyteraUnitToUnitVoiceChannelUser;
@@ -66,6 +67,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.lc.full.motorola.Capaci
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.motorola.CapacityPlusWideAreaVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.shorty.CapacityPlusRestChannel;
import io.github.dsheirer.module.decode.dmr.message.data.packet.DMRPacketMessage;
import io.github.dsheirer.module.decode.dmr.message.data.packet.UDTShortMessageService;
import io.github.dsheirer.module.decode.dmr.message.data.terminator.Terminator;
import io.github.dsheirer.module.decode.dmr.message.type.ServiceOptions;
import io.github.dsheirer.module.decode.dmr.message.voice.VoiceMessage;
@@ -75,13 +77,12 @@ import io.github.dsheirer.module.decode.event.PlottableDecodeEvent;
import io.github.dsheirer.protocol.Protocol;
import io.github.dsheirer.source.tuner.channel.rotation.AddChannelRotationActiveStateRequest;
import io.github.dsheirer.util.PacketUtil;
import org.jdesktop.swingx.mapviewer.GeoPosition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.jdesktop.swingx.mapviewer.GeoPosition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Decoder state for an DMR channel. Maintains the call/data/idle state of the channel and produces events by
@@ -207,6 +208,10 @@ public class DMRDecoderState extends TimeslotDecoderState
{
processPacket((DMRPacketMessage)message);
}
else if(message instanceof UDTShortMessageService sms)
{
processSMS(sms);
}
else if(message instanceof DMRMessage)
{
broadcast(new DecoderStateEvent(this, Event.CONTINUATION, State.ACTIVE, getTimeslot()));
@@ -269,6 +274,24 @@ public class DMRDecoderState extends TimeslotDecoderState
}
}
/**
* Processes a short data message carrying SMS text
* @param sms
*/
private void processSMS(UDTShortMessageService sms)
{
broadcast(new DecoderStateEvent(this, Event.START, State.DATA, getTimeslot()));
DecodeEvent smsEvent = DMRDecodeEvent.builder(sms.getTimestamp())
.eventType(DecodeEventType.SMS)
.eventDescription(DecodeEventType.SMS.toString())
.details("MESSAGE: " + sms.getSMS())
.identifiers(new IdentifierCollection(sms.getIdentifiers()))
.timeslot(sms.getTimeslot())
.build();
broadcast(smsEvent);
}
/**
* Processes a packet message
*/
@@ -1127,6 +1150,12 @@ public class DMRDecoderState extends TimeslotDecoderState
broadcast(gpsEvent);
}
break;
case FULL_STANDARD_TALKER_ALIAS_COMPLETE:
if(message instanceof TalkerAliasComplete tac && tac.hasTalkerAliasIdentifier())
{
getIdentifierCollection().update(tac.getTalkerAliasIdentifier());
}
break;
}
}

104
src/main/java/io/github/dsheirer/module/decode/dmr/DMRMessageProcessor.java
View File

@@ -1,52 +1,56 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* * ******************************************************************************
* * Copyright (C) 2014-2019 Dennis Sheirer
* *
* * This program is free software: you can redistribute it and/or modify
* * it under the terms of the GNU General Public License as published by
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.message.IMessage;
import io.github.dsheirer.module.decode.dmr.channel.ITimeslotFrequencyReceiver;
import io.github.dsheirer.module.decode.dmr.channel.TimeslotFrequency;
import io.github.dsheirer.module.decode.dmr.identifier.DMRTalkgroup;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.DMRBurst;
import io.github.dsheirer.module.decode.dmr.message.data.IDLEMessage;
import io.github.dsheirer.module.decode.dmr.message.data.block.DataBlock;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Aloha;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Preamble;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.announcement.Announcement;
import io.github.dsheirer.module.decode.dmr.message.data.header.MBCHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.PacketSequenceHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.ProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.UDTHeader;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.FLCAssembler;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.FullLCMessage;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasAssembler;
import io.github.dsheirer.module.decode.dmr.message.data.lc.shorty.SLCAssembler;
import io.github.dsheirer.module.decode.dmr.message.data.lc.shorty.ShortLCMessage;
import io.github.dsheirer.module.decode.dmr.message.data.mbc.MBCAssembler;
import io.github.dsheirer.module.decode.dmr.message.data.mbc.MBCContinuationBlock;
import io.github.dsheirer.module.decode.dmr.message.data.packet.PacketSequenceAssembler;
import io.github.dsheirer.module.decode.dmr.message.data.terminator.Terminator;
import io.github.dsheirer.module.decode.dmr.message.voice.VoiceEMBMessage;
import io.github.dsheirer.sample.Listener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Processes DMR messages and performs re-assembly of link control fragments
@@ -54,12 +58,13 @@ import java.util.TreeMap;
public class DMRMessageProcessor implements Listener<IMessage>
{
private final static Logger mLog = LoggerFactory.getLogger(DMRMessageProcessor.class);
private DecodeConfigDMR mConfigDMR;
private FLCAssembler mFLCAssemblerTimeslot1 = new FLCAssembler(1);
private FLCAssembler mFLCAssemblerTimeslot2 = new FLCAssembler(2);
private MBCAssembler mMBCAssembler = new MBCAssembler();
private PacketSequenceAssembler mPacketSequenceAssembler;
private SLCAssembler mSLCAssembler = new SLCAssembler();
private TalkerAliasAssembler mTalkerAliasAssembler = new TalkerAliasAssembler();
private Listener<IMessage> mMessageListener;
private Map<Integer,TimeslotFrequency> mTimeslotFrequencyMap = new TreeMap<>();
@@ -68,6 +73,8 @@ public class DMRMessageProcessor implements Listener<IMessage>
*/
public DMRMessageProcessor(DecodeConfigDMR config)
{
mConfigDMR = config;
for(TimeslotFrequency timeslotFrequency: config.getTimeslotMap())
{
mTimeslotFrequencyMap.put(timeslotFrequency.getNumber(), timeslotFrequency);
@@ -157,22 +164,43 @@ public class DMRMessageProcessor implements Listener<IMessage>
}
//Packet Sequence Message Assembly ...
if(message instanceof Preamble)
if(message instanceof Preamble preamble)
{
mPacketSequenceAssembler.process((Preamble)message);
mPacketSequenceAssembler.process(preamble);
}
else if(message instanceof PacketSequenceHeader)
else if(message instanceof PacketSequenceHeader header)
{
mPacketSequenceAssembler.process((PacketSequenceHeader)message);
mPacketSequenceAssembler.process(header);
}
else if(message instanceof ProprietaryDataHeader)
else if(message instanceof ProprietaryDataHeader header)
{
mPacketSequenceAssembler.process(((ProprietaryDataHeader)message));
mPacketSequenceAssembler.process(header);
}
else if(message instanceof DataBlock)
else if(message instanceof DataBlock dataBlock)
{
mPacketSequenceAssembler.process((DataBlock)message);
mPacketSequenceAssembler.process(dataBlock);
}
else if(message instanceof UDTHeader header)
{
mPacketSequenceAssembler.process(header);
}
else if((message instanceof IDLEMessage || message instanceof Aloha || message instanceof Announcement) &&
message.getTimeslot() != 0)
{
mPacketSequenceAssembler.dispatchPacketSequence(message.getTimeslot());
}
//Reset talker alias assembler on Idle or Terminator
if(message.isValid() && (message instanceof IDLEMessage || message instanceof Terminator))
{
mTalkerAliasAssembler.reset(message.getTimeslot());
}
}
//Assemble Talker Alias from FLC message fragments (header & blocks 1-3)
if(message instanceof FullLCMessage flc && flc.getOpcode().isTalkerAliasOpcode() && message.isValid())
{
dispatch(mTalkerAliasAssembler.process(flc));
}
//Now that the message has been (potentially) enriched, dispatch it to the modules
@@ -186,6 +214,26 @@ public class DMRMessageProcessor implements Listener<IMessage>
{
if(mMessageListener != null && message != null)
{
//Configure compressed talkgroups for the DMR talkgroup identifiers in the message.
if(mConfigDMR.isUseCompressedTalkgroups())
{
try
{
for(Identifier identifier: message.getIdentifiers())
{
if(identifier instanceof DMRTalkgroup talkgroup)
{
talkgroup.setCompressed(true);
}
}
}
catch(Exception e)
{
mLog.error("Error applying compressed talkgroup setting to identifier in message: " + message +
" [" + message.getClass() + "]");
}
}
mMessageListener.receive(message);
}
}

31
src/main/java/io/github/dsheirer/module/decode/dmr/DecodeConfigDMR.java
View File

@@ -1,7 +1,6 @@
/*
* ******************************************************************************
* sdrtrunk
* Copyright (C) 2014-2020 Dennis Sheirer, Zhenyu Mao
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -15,7 +14,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* *****************************************************************************
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr;
@@ -25,7 +24,6 @@ import io.github.dsheirer.module.decode.DecoderType;
import io.github.dsheirer.module.decode.config.DecodeConfiguration;
import io.github.dsheirer.module.decode.dmr.channel.TimeslotFrequency;
import io.github.dsheirer.source.tuner.channel.ChannelSpecification;
import java.util.ArrayList;
import java.util.List;
@@ -40,6 +38,7 @@ public class DecodeConfigDMR extends DecodeConfiguration
private int mTrafficChannelPoolSize = TRAFFIC_CHANNEL_LIMIT_DEFAULT;
private boolean mIgnoreDataCalls = true;
private boolean mIgnoreCRCChecksums = false;
private boolean mUseCompressedTalkgroups = false;
private List<TimeslotFrequency> mTimeslotMap = new ArrayList<>();
public DecodeConfigDMR()
@@ -109,6 +108,28 @@ public class DecodeConfigDMR extends DecodeConfiguration
mIgnoreCRCChecksums = ignore;
}
/**
* Indicates if decoder should use compressed talkgroups
*/
@JacksonXmlProperty(isAttribute = true, localName = "use_compressed_talkgroups")
public boolean isUseCompressedTalkgroups()
{
return mUseCompressedTalkgroups;
}
/**
* Sets flag to use compressed talkgroups.
*
* Converts the air interface value to a compressed value described in ETSI 102 361-2, V.2.4.1, Paragraph C2.1.2
* This has been observed in use on Hytera Tier III systems.
* See: https://cwh050.blogspot.com/2021/03/converting-flat-number-to-dmr-id.html?m=1
* @param useCompressedTalkgroups true to use compressed talkgroups.
*/
public void setUseCompressedTalkgroups(boolean useCompressedTalkgroups)
{
mUseCompressedTalkgroups = useCompressedTalkgroups;
}
/**
* Traffic channel pool size.
* @return

128
src/main/java/io/github/dsheirer/module/decode/dmr/identifier/DMRTalkgroup.java
View File

@@ -1,23 +1,20 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* * ******************************************************************************
* * Copyright (C) 2014-2019 Dennis Sheirer
* *
* * This program is free software: you can redistribute it and/or modify
* * it under the terms of the GNU General Public License as published by
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.identifier;
@@ -26,16 +23,33 @@ import io.github.dsheirer.identifier.Role;
import io.github.dsheirer.identifier.talkgroup.TalkgroupIdentifier;
import io.github.dsheirer.protocol.Protocol;
/**
* DMR Talkgroup identifier
*/
public class DMRTalkgroup extends TalkgroupIdentifier
{
public DMRTalkgroup(Integer value)
private boolean mCompressed = false;
private int mOriginalValue;
/**
* Constructs an instance
* @param value of the talkgroup
*/
public DMRTalkgroup(int value)
{
super(value, Role.TO);
mOriginalValue = value;
}
public DMRTalkgroup(Integer value, Role role)
/**
* Constructs an instance
* @param value of the talkgroup
* @param role of the talkgroup
*/
public DMRTalkgroup(int value, Role role)
{
super(value, role);
mOriginalValue = value;
}
@Override
@@ -44,6 +58,84 @@ public class DMRTalkgroup extends TalkgroupIdentifier
return Protocol.DMR;
}
@Override
public String toString()
{
if(mCompressed)
{
return super.toString() + "(c)";
}
else
{
return super.toString();
}
}
/**
* Sets the compressed flag for this value.
*
* Talkgroup compression is an alternate format for DMR systems that allows the end user to dial a 7-digit number
* on their mobile keypad using just the digits 0 - 9, to address a talkgroup. The downside to this is that the
* total available talkgroup address space is reduced to just those dialable talkgroups.
*
* @param compressed true when using compressed talkgroup format.
*/
public void setCompressed(boolean compressed)
{
mCompressed = compressed;
if(mCompressed)
{
setValue(getCompressed(mOriginalValue));
}
else
{
setValue(mOriginalValue);
}
}
/**
* Converts the air interface value to a compressed value described in ETSI 102 361-2, V.2.4.1, Paragraph C2.1.2
*
* This has been observed in use on Hytera Tier III systems.
*
* See: https://cwh050.blogspot.com/2021/03/converting-flat-number-to-dmr-id.html?m=1
*
* @param original value to convert
* @return converted value.
*/
public static int getCompressed(int original)
{
int converted = 0;
int units = original / 1_464_100;
converted += (units * 1_000_000);
original -= (units * 1_464_100);
units = original / 146_410;
converted += (units * 100_000);
original -= (units * 146_410);
units = original / 14_641;
converted += (units * 10_000);
original -= (units * 14_641);
units = original / 1_331;
converted += (units * 1_000);
original -= (units * 1_331);
units = original / 121;
converted += (units * 100);
original -= (units * 121);
units = original / 11;
converted += (units * 10);
original -= (units * 11);
converted += original;
return converted;
}
/**
* Creates a DMR TO talkgroup identifier
*/

28
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/CSBKMessageFactory.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -24,7 +24,12 @@ import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraAdjacentSiteInformation;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraAloha;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraAnnouncement;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraCsbko32;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraCsbko44;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraCsbko47;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraSmsWaitingNotification;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraXPTPreamble;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera.HyteraXPTSiteState;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.motorola.CapacityMaxAloha;
@@ -49,6 +54,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Aloha;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Clear;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.MoveTSCC;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Preamble;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Protect;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.acknowledge.Acknowledge;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.acknowledge.AcknowledgeStatus;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.acknowledge.RegistrationAccepted;
@@ -78,7 +84,6 @@ import io.github.dsheirer.module.decode.dmr.message.data.mbc.MBCContinuationBloc
import io.github.dsheirer.module.decode.dmr.message.data.mbc.UnknownMultiCSBK;
import io.github.dsheirer.module.decode.dmr.message.type.AnnouncementType;
import io.github.dsheirer.module.decode.dmr.message.type.ServiceKind;
import java.util.List;
/**
@@ -200,6 +205,9 @@ public class CSBKMessageFactory
case STANDARD_PRIVATE_VOICE_CHANNEL_GRANT:
csbk = new PrivateVoiceChannelGrant(pattern, message, cach, slotType, timestamp, timeslot);
break;
case STANDARD_PROTECT:
csbk = new Protect(pattern, message, cach, slotType, timestamp, timeslot);
break;
case STANDARD_TALKGROUP_DATA_CHANNEL_GRANT_SINGLE_ITEM:
csbk = new TalkgroupDataChannelGrant(pattern, message, cach, slotType, timestamp, timeslot);
break;
@@ -213,6 +221,9 @@ public class CSBKMessageFactory
csbk = new Preamble(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_ALOHA:
csbk = new HyteraAloha(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_08_ANNOUNCEMENT:
case HYTERA_68_ANNOUNCEMENT:
AnnouncementType announcementType = HyteraAnnouncement.getAnnouncementType(message);
@@ -232,7 +243,18 @@ public class CSBKMessageFactory
case HYTERA_XPT_SITE_STATE:
csbk = new HyteraXPTSiteState(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_CSBKO_32:
csbk = new HyteraCsbko32(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_CSBKO_44:
csbk = new HyteraCsbko44(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_CSBKO_47:
csbk = new HyteraCsbko47(pattern, message, cach, slotType, timestamp, timeslot);
break;
case HYTERA_CSBKO_62:
csbk = new HyteraSmsWaitingNotification(pattern, message, cach, slotType, timestamp, timeslot);
break;
case MOTOROLA_CAPMAX_ALOHA:
csbk = new CapacityMaxAloha(pattern, message, cach, slotType, timestamp, timeslot);
break;

18
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/Opcode.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -20,7 +20,6 @@
package io.github.dsheirer.module.decode.dmr.message.data.csbk;
import io.github.dsheirer.module.decode.dmr.message.type.Vendor;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;
@@ -50,8 +49,8 @@ public enum Opcode
STANDARD_ACKNOWLEDGE_RESPONSE_INBOUND_PAYLOAD(Vendor.STANDARD, 35, "ACKNOWLEDGE RESPONSE INBOUND PAYLOAD"),
STANDARD_UNIFIED_DATA_TRANSPORT_FOR_DGNA_OUTBOUND_HEADER(Vendor.STANDARD, 36, "UNIFIED DATA TRANSPORT OUTBOUND HEADER"),
STANDARD_UNIFIED_DATA_TRANSPORT_FOR_DGNA_INBOUND_HEADER(Vendor.STANDARD, 37, "UNIFIED DATA TRANSPORT OUTBOUND HEADER"),
STANDARD_ANNOUNCEMENT(Vendor.STANDARD, 40, "ANNOUNCEMENT"),
STANDARD_NEGATIVE_ACKNOWLEDGE_RESPONSE(Vendor.STANDARD, 38, "NEGATIVE ACKNOWLEDGE RESPONSE"),
STANDARD_ANNOUNCEMENT(Vendor.STANDARD, 40, "ANNOUNCEMENT"),
STANDARD_MAINTENANCE(Vendor.STANDARD, 42, "MAINTENANCE"),
STANDARD_CLEAR(Vendor.STANDARD, 46, "CLEAR"),
STANDARD_PROTECT(Vendor.STANDARD, 47, "PROTECT"),
@@ -90,12 +89,17 @@ public enum Opcode
MOTOROLA_CAPPLUS_PREAMBLE(Vendor.MOTOROLA_CAPACITY_PLUS, 61, "PREAMBLE"),
MOTOROLA_CAPPLUS_SYSTEM_STATUS(Vendor.MOTOROLA_CAPACITY_PLUS, 62, "SYSTEM STATUS"),
HYTERA_XPT_SITE_STATE(Vendor.HYTERA_68, 10, "HYTERA XPT SITE STATE"),
HYTERA_CSBKO_32(Vendor.HYTERA_8, 32, "T-III HYTERA 08 CSBKO 32"),
HYTERA_08_ANNOUNCEMENT(Vendor.HYTERA_8, 40, "T-III 08 ANNOUNCEMENT"),
HYTERA_68_ANNOUNCEMENT(Vendor.HYTERA_68, 40, "T-III 68 ANNOUNCEMENT"),
HYTERA_CSBKO_44(Vendor.HYTERA_8, 44, "T-III HYTERA 08 CSBKO 44"),
HYTERA_CSBKO_47(Vendor.HYTERA_8, 47, "T-III HYTERA 08 CSBKO 47"),
HYTERA_XPT_SITE_STATE(Vendor.HYTERA_68, 10, "HYTERA XPT SITE STATE"),
HYTERA_ALOHA(Vendor.HYTERA_68, 25, "HYTERA ALOHA"),
HYTERA_68_ANNOUNCEMENT(Vendor.HYTERA_68, 40, "T-III 68 ANNOUNCEMENT"),
HYTERA_XPT_PREAMBLE(Vendor.HYTERA_68, 61, "HYTERA XPT PREAMBLE"), //Opcode 54 and/or 55 - See patent on Hytera call forwarding
HYTERA_CSBKO_62(Vendor.HYTERA_68, 62, "HYTERA CSBKO 62"),
//Opcode 54 and/or 55 - See patent on Hytera call forwarding
HYTERA_XPT_PREAMBLE(Vendor.HYTERA_68, 61, "HYTERA XPT PREAMBLE"),
UNKNOWN(Vendor.UNKNOWN, -1, "UNKNOWN");

198
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraAloha.java Normal file
View File

@@ -0,0 +1,198 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.radio.RadioIdentifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.identifier.DMRRadio;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import io.github.dsheirer.module.decode.dmr.message.type.ServiceFunction;
import io.github.dsheirer.module.decode.dmr.message.type.SystemIdentityCode;
import io.github.dsheirer.module.decode.dmr.message.type.Version;
import java.util.ArrayList;
import java.util.List;
/**
* Hytera DMR Tier III - Aloha Message
*/
public class HyteraAloha extends CSBKMessage
{
//TODO: not sure what bits 16 to 31 are used for ... awaiting documentation.
//TODO: bits 32 to 79 seem to align with the standard aloha.
private static final int[] RESERVED = new int[]{16, 17};
private static final int SITE_TIMESLOT_SYNCHRONIZATION = 18;
private static final int[] VERSION = new int[]{19, 20, 21};
private static final int TIMING_OFFSET = 22;
private static final int ACTIVE_NETWORK_CONNECTION_FLAG = 23;
private static final int[] MASK = new int[]{24, 25, 26, 27, 28};
private static final int[] SERVICE_FUNCTION = new int[]{29, 30};
private static final int[] N_RAND_WAIT = new int[]{31, 32, 33, 34};
private static final int REGISTRATION_REQUIRED_FLAG = 35;
private static final int[] BACKOFF = new int[]{36, 37, 38, 39};
private static final int SYSTEM_IDENTITY_CODE_OFFSET = 40;
private static final int[] RADIO = new int[]{56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79};
private SystemIdentityCode mSystemIdentityCode;
private RadioIdentifier mRadioIdentifier;
private List<Identifier> mIdentifiers;
/**
* Constructs an instance
*
* @param syncPattern for the CSBK
* @param message bits
* @param cach for the DMR burst
* @param slotType for this message
* @param timestamp
* @param timeslot
*/
public HyteraAloha(DMRSyncPattern syncPattern, CorrectedBinaryMessage message, CACH cach, SlotType slotType, long timestamp, int timeslot)
{
super(syncPattern, message, cach, slotType, timestamp, timeslot);
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
if(!isValid())
{
sb.append("[CRC-ERROR] ");
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA ALOHA");
if(hasRadioIdentifier())
{
sb.append(" TO:").append(getRadioIdentifier());
}
sb.append(" ").append(getSystemIdentityCode().getModel());
sb.append(" NETWORK:").append(getSystemIdentityCode().getNetwork());
sb.append(" SITE:").append(getSystemIdentityCode().getSite());
if(hasActiveNetworkConnection())
{
sb.append(" NET-CONNECTED");
}
else
{
sb.append(" NET-DISCONNECTED");
}
sb.append(" SERVICES:").append(getServiceFunction());
sb.append(" ETSI VER:").append(getVersion());
sb.append(" MASK:").append(getMask());
if(getSystemIdentityCode().getPAR().isMultipleControlChannels())
{
sb.append(" ").append(getSystemIdentityCode().getPAR());
}
sb.append(" ").append(getMessage().toHexString());
return sb.toString();
}
/**
* Services provided by the control channel.
*/
public ServiceFunction getServiceFunction()
{
return ServiceFunction.fromValue(getMessage().getInt(SERVICE_FUNCTION));
}
/**
* Mobile subscriber ID masking value. See: 102 361-4 p6.1.3
*/
public int getMask()
{
return getMessage().getInt(MASK);
}
public boolean hasActiveNetworkConnection()
{
return getMessage().get(ACTIVE_NETWORK_CONNECTION_FLAG);
}
/**
* DMR Tier III ETSI 102 361-4 ICD Version Number supported by this system
*/
public Version getVersion()
{
return Version.fromValue(getMessage().getInt(VERSION));
}
/**
* Acknowledged radio identifier
*/
public RadioIdentifier getRadioIdentifier()
{
if(mRadioIdentifier == null)
{
mRadioIdentifier = DMRRadio.createTo(getMessage().getInt(RADIO));
}
return mRadioIdentifier;
}
public boolean hasRadioIdentifier()
{
return getMessage().getInt(RADIO) != 0;
}
/**
* System Identity Code structure
*/
public SystemIdentityCode getSystemIdentityCode()
{
if(mSystemIdentityCode == null)
{
mSystemIdentityCode = new SystemIdentityCode(getMessage(), SYSTEM_IDENTITY_CODE_OFFSET, true);
}
return mSystemIdentityCode;
}
@Override
public List<Identifier> getIdentifiers()
{
if(mIdentifiers == null)
{
mIdentifiers = new ArrayList<>();
if(hasRadioIdentifier())
{
mIdentifiers.add(getRadioIdentifier());
}
mIdentifiers.add(getSystemIdentityCode().getNetwork());
mIdentifiers.add(getSystemIdentityCode().getSite());
}
return mIdentifiers;
}
}

5
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraAnnouncement.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -28,7 +28,6 @@ import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import io.github.dsheirer.module.decode.dmr.message.type.AnnouncementType;
import io.github.dsheirer.module.decode.dmr.message.type.SystemIdentityCode;
import java.util.ArrayList;
import java.util.List;
@@ -78,7 +77,7 @@ public class HyteraAnnouncement extends CSBKMessage
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA ").append(getAnnouncementType());
sb.append(" HYTERA ANNOUNCEMENT-TYPE:").append(getAnnouncementType());
sb.append(" ").append(getSystemIdentityCode().getModel());
sb.append(" NETWORK:").append(getSystemIdentityCode().getNetwork());
sb.append(" SITE:").append(getSystemIdentityCode().getSite());

137
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraCsbko32.java Normal file
View File

@@ -0,0 +1,137 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.radio.RadioIdentifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.identifier.DMRRadio;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import java.util.ArrayList;
import java.util.List;
/**
* Hytera DMR Tier III - CSBKO 32 - Possibly Acknowledge Response
*
* Analysis: ... this was transmitted on the traffic channel while the mobile was at the end of a call, in the terminator
* sequence. Since this comes from the SMS gateway 16776906, I wonder if this is a traffic channel message waiting notification?
*/
public class HyteraCsbko32 extends CSBKMessage
{
private static final int[] UNKNOWN_1 = new int[]{16, 17, 18, 19, 20, 21, 22, 23};
private static final int[] UNKNOWN_2 = new int[]{24, 25, 26, 27, 28, 29, 30, 31};
private static final int[] DESTINATION_RADIO = new int[]{32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55};
private static final int[] SOURCE_RADIO = new int[]{56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79};
private List<Identifier> mIdentifiers;
private RadioIdentifier mDestinationRadio;
private RadioIdentifier mSourceRadio;
/**
* Constructs an instance
*
* @param syncPattern for the CSBK
* @param message bits
* @param cach for the DMR burst
* @param slotType for this message
* @param timestamp
* @param timeslot
*/
public HyteraCsbko32(DMRSyncPattern syncPattern, CorrectedBinaryMessage message, CACH cach, SlotType slotType, long timestamp, int timeslot)
{
super(syncPattern, message, cach, slotType, timestamp, timeslot);
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
if(!isValid())
{
sb.append("[CRC-ERROR] ");
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA CSBKO=32 PROBABLE ACKNOWLEDGE RESPONSE");
sb.append(" FM:").append(getSourceRadio());
sb.append(" TO:").append(getDestinationRadio());
sb.append(" UNK1:").append(getUnknown1());
sb.append(" UNK2:").append(getUnknown2());
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
/**
* Addressed (ie TO) radio identifier
* @return radio identifier
*/
public RadioIdentifier getDestinationRadio()
{
if(mDestinationRadio == null)
{
mDestinationRadio = DMRRadio.createTo(getMessage().getInt(DESTINATION_RADIO));
}
return mDestinationRadio;
}
public String getUnknown1()
{
return getMessage().getHex(UNKNOWN_1, 2);
}
public String getUnknown2()
{
return getMessage().getHex(UNKNOWN_2, 2);
}
/**
* Source radio. Should be 16,777,906 the Hytera SMS gateway.
*/
public RadioIdentifier getSourceRadio()
{
if(mSourceRadio == null)
{
mSourceRadio = DMRRadio.createFrom(getMessage().getInt(SOURCE_RADIO));
}
return mSourceRadio;
}
@Override
public List<Identifier> getIdentifiers()
{
if(mIdentifiers == null)
{
mIdentifiers = new ArrayList<>();
mIdentifiers.add(getDestinationRadio());
mIdentifiers.add(getSourceRadio());
}
return mIdentifiers;
}
}

80
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraCsbko44.java Normal file
View File

@@ -0,0 +1,80 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import java.util.Collections;
import java.util.List;
/**
* Hytera DMR Tier III - CSBKO 44 -
*
* Analysis: ... this was transmitted on the Tier III traffic channel during call termination. This CSBK was
* interleaved with every other Terminator message, starting after the first 2x terminator messages. This continued
* through the final teardown which was 3x Clear messages.
*/
public class HyteraCsbko44 extends CSBKMessage
{
private static final int[] UNKNOWN_1 = new int[]{16, 17, 18, 19, 20, 21, 22, 23};
private List<Identifier> mIdentifiers;
/**
* Constructs an instance
*
* @param syncPattern for the CSBK
* @param message bits
* @param cach for the DMR burst
* @param slotType for this message
* @param timestamp
* @param timeslot
*/
public HyteraCsbko44(DMRSyncPattern syncPattern, CorrectedBinaryMessage message, CACH cach, SlotType slotType, long timestamp, int timeslot)
{
super(syncPattern, message, cach, slotType, timestamp, timeslot);
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
if(!isValid())
{
sb.append("[CRC-ERROR] ");
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA UNKNOWN CSBKO=44");
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
@Override
public List<Identifier> getIdentifiers()
{
return Collections.emptyList();
}
}

138
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraCsbko47.java Normal file
View File

@@ -0,0 +1,138 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.radio.RadioIdentifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.identifier.DMRRadio;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import java.util.ArrayList;
import java.util.List;
/**
* Hytera DMR Tier III - CSBKO 47 -
*
* Analysis: ... this was transmitted on the traffic channel while the mobile was at the end of a call, in the terminator
* sequence. Since this comes from the SMS gateway 16776906, I wonder if this is a traffic channel message waiting notification?
*/
public class HyteraCsbko47 extends CSBKMessage
{
private static final int[] UNKNOWN_1 = new int[]{16, 17, 18, 19, 20, 21, 22, 23};
private static final int[] UNKNOWN_2 = new int[]{24, 25, 26, 27, 28, 29, 30, 31};
private static final int[] DESTINATION_RADIO = new int[]{32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55};
private static final int[] SOURCE_RADIO = new int[]{56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79};
private List<Identifier> mIdentifiers;
private RadioIdentifier mDestinationRadio;
private RadioIdentifier mSourceRadio;
/**
* Constructs an instance
*
* @param syncPattern for the CSBK
* @param message bits
* @param cach for the DMR burst
* @param slotType for this message
* @param timestamp
* @param timeslot
*/
public HyteraCsbko47(DMRSyncPattern syncPattern, CorrectedBinaryMessage message, CACH cach, SlotType slotType, long timestamp, int timeslot)
{
super(syncPattern, message, cach, slotType, timestamp, timeslot);
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
if(!isValid())
{
sb.append("[CRC-ERROR] ");
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA CSBKO=47 ######### UNKNOWN");
sb.append(" FM:").append(getSourceRadio());
sb.append(" TO:").append(getDestinationRadio());
sb.append(" UNK1:").append(getUnknown1());
sb.append(" UNK2:").append(getUnknown2());
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
/**
* Addressed (ie TO) radio identifier
* @return radio identifier
*/
public RadioIdentifier getDestinationRadio()
{
if(mDestinationRadio == null)
{
mDestinationRadio = DMRRadio.createTo(getMessage().getInt(DESTINATION_RADIO));
}
return mDestinationRadio;
}
public String getUnknown1()
{
return getMessage().getHex(UNKNOWN_1, 2);
}
public String getUnknown2()
{
return getMessage().getHex(UNKNOWN_2, 2);
}
/**
* Source radio. Should be 16,777,906 the Hytera SMS gateway.
*/
public RadioIdentifier getSourceRadio()
{
if(mSourceRadio == null)
{
mSourceRadio = DMRRadio.createFrom(getMessage().getInt(SOURCE_RADIO));
}
return mSourceRadio;
}
@Override
public List<Identifier> getIdentifiers()
{
if(mIdentifiers == null)
{
mIdentifiers = new ArrayList<>();
mIdentifiers.add(getDestinationRadio());
mIdentifiers.add(getSourceRadio());
}
return mIdentifiers;
}
}

138
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/hytera/HyteraSmsWaitingNotification.java Normal file
View File

@@ -0,0 +1,138 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.csbk.hytera;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.radio.RadioIdentifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.identifier.DMRRadio;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import io.github.dsheirer.module.decode.dmr.message.data.SlotType;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import java.util.ArrayList;
import java.util.List;
/**
* Hytera DMR Tier III - CSBKO 62 -
*
* Analysis: this message gets sent on timeslot 2 (not the Tier III control timeslot 1) from the SMS gateway (16776906)
* and gets sent to each of the radios involved in the SMS transfer (sender/receiver). I suspect that the network tells
* each of the radios to join the control channel and prepare for the SMS message.
*/
public class HyteraSmsWaitingNotification extends CSBKMessage
{
private static final int[] UNKNOWN_1 = new int[]{16, 17, 18, 19, 20, 21, 22, 23};
private static final int[] UNKNOWN_2 = new int[]{24, 25, 26, 27, 28, 29, 30, 31};
private static final int[] DESTINATION_RADIO = new int[]{32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55};
private static final int[] SOURCE_RADIO = new int[]{56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79};
private List<Identifier> mIdentifiers;
private RadioIdentifier mDestinationRadio;
private RadioIdentifier mSourceRadio;
/**
* Constructs an instance
*
* @param syncPattern for the CSBK
* @param message bits
* @param cach for the DMR burst
* @param slotType for this message
* @param timestamp
* @param timeslot
*/
public HyteraSmsWaitingNotification(DMRSyncPattern syncPattern, CorrectedBinaryMessage message, CACH cach, SlotType slotType, long timestamp, int timeslot)
{
super(syncPattern, message, cach, slotType, timestamp, timeslot);
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
if(!isValid())
{
sb.append("[CRC-ERROR] ");
}
sb.append("CC:").append(getSlotType().getColorCode());
sb.append(" HYTERA PREPARE FOR SMS MESSAGE FOR:").append(getDestinationRadio());
sb.append(" FM:").append(getSourceRadio());
sb.append(" UNK1:").append(getUnknown1());
sb.append(" UNK2:").append(getUnknown2());
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
/**
* Addressed (ie TO) radio identifier
* @return radio identifier
*/
public RadioIdentifier getDestinationRadio()
{
if(mDestinationRadio == null)
{
mDestinationRadio = DMRRadio.createTo(getMessage().getInt(DESTINATION_RADIO));
}
return mDestinationRadio;
}
public String getUnknown1()
{
return getMessage().getHex(UNKNOWN_1, 2);
}
public String getUnknown2()
{
return getMessage().getHex(UNKNOWN_2, 2);
}
/**
* Source radio. Should be 16,777,906 the Hytera SMS gateway.
*/
public RadioIdentifier getSourceRadio()
{
if(mSourceRadio == null)
{
mSourceRadio = DMRRadio.createFrom(getMessage().getInt(SOURCE_RADIO));
}
return mSourceRadio;
}
@Override
public List<Identifier> getIdentifiers()
{
if(mIdentifiers == null)
{
mIdentifiers = new ArrayList<>();
mIdentifiers.add(getDestinationRadio());
mIdentifiers.add(getSourceRadio());
}
return mIdentifiers;
}
}

4
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/csbk/standard/Clear.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -37,7 +37,6 @@ import io.github.dsheirer.module.decode.dmr.message.data.csbk.CSBKMessage;
import io.github.dsheirer.module.decode.dmr.message.data.mbc.MBCContinuationBlock;
import io.github.dsheirer.module.decode.dmr.message.type.AbsoluteChannelParameters;
import io.github.dsheirer.module.decode.dmr.message.type.DataType;
import java.util.ArrayList;
import java.util.List;
@@ -118,6 +117,7 @@ public class Clear extends CSBKMessage implements ITimeslotFrequencyReceiver
sb.append(" CLEAR - RETURN TO ").append(getMoveToChannel());
sb.append(" FM:").append(getSourceRadio());
sb.append(" TO:").append(getDestinationId());
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}

21
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/header/UDTHeader.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -32,7 +32,6 @@ import io.github.dsheirer.module.decode.dmr.message.data.csbk.Opcode;
import io.github.dsheirer.module.decode.dmr.message.type.ServiceAccessPoint;
import io.github.dsheirer.module.decode.dmr.message.type.UnifiedDataTransportFormat;
import io.github.dsheirer.module.decode.dmr.message.type.Vendor;
import java.util.ArrayList;
import java.util.List;
@@ -84,13 +83,13 @@ public class UDTHeader extends DataHeader
sb.append(" [CRC ERROR]");
}
sb.append(" UDT HEADER");
if(isSupplementaryData())
if(isShortData())
{
sb.append(" SUPPLEMENTARY DATA");
sb.append(" SHORT DATA");
}
else
{
sb.append(" SHORT DATA");
sb.append(" SUPPLEMENTARY DATA");
}
sb.append(" FM:").append(getSourceLLID());
sb.append(" TO:").append(getDestinationLLID());
@@ -106,7 +105,7 @@ public class UDTHeader extends DataHeader
sb.append(" OPCODE:").append(getOpcode());
}
sb.append(" PAD NIBBLES:").append(getPadNibbleCount());
sb.append(" ").append(getServiceAccessPoint());
sb.append(" SAP:").append(getServiceAccessPoint());
return sb.toString();
}
@@ -121,7 +120,15 @@ public class UDTHeader extends DataHeader
}
/**
* Indicates if the header contains supplementary data (true) or short data (false)
* Indicates if the header is for a short data sequence
*/
public boolean isShortData()
{
return !isSupplementaryData();
}
/**
* Indicates if the header is for supplementary data
*/
public boolean isSupplementaryData()
{

13
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/LCMessageFactory.java
View File

@@ -26,6 +26,10 @@ import io.github.dsheirer.edac.ReedSolomon_12_9_4_DMR;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.FullLCMessage;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.GPSInformation;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.GroupVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasBlock1;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasBlock2;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasBlock3;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TalkerAliasHeader;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.TerminatorData;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.UnitToUnitVoiceChannelUser;
import io.github.dsheirer.module.decode.dmr.message.data.lc.full.UnknownFullLCMessage;
@@ -83,7 +87,6 @@ public class LCMessageFactory
//RS(12,9,4) can correct up to floor(4/2) = 1 bit error.
valid = REED_SOLOMON_12_9_4_DMR.correctFullLinkControl(message,
isTerminator ? TERMINATOR_LINK_CONTROL_CRC_MASK : VOICE_LINK_CONTROL_CRC_MASK);
mLog.warn("Doing the reed solomon thing .... valid: " + valid);
}
else
{
@@ -125,9 +128,17 @@ public class LCMessageFactory
flc = new HyteraTerminator(message, timestamp, timeslot);
break;
case FULL_STANDARD_TALKER_ALIAS_HEADER:
flc = new TalkerAliasHeader(message, timestamp, timeslot);
break;
case FULL_STANDARD_TALKER_ALIAS_BLOCK_1:
flc = new TalkerAliasBlock1(message, timestamp, timeslot);
break;
case FULL_STANDARD_TALKER_ALIAS_BLOCK_2:
flc = new TalkerAliasBlock2(message, timestamp, timeslot);
break;
case FULL_STANDARD_TALKER_ALIAS_BLOCK_3:
flc = new TalkerAliasBlock3(message, timestamp, timeslot);
break;
default:
flc = new UnknownFullLCMessage(message, timestamp, timeslot);
break;

16
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/LCOpcode.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -20,8 +20,8 @@
package io.github.dsheirer.module.decode.dmr.message.data.lc;
import io.github.dsheirer.module.decode.dmr.message.type.Vendor;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;
import java.util.TreeMap;
@@ -39,6 +39,7 @@ public enum LCOpcode
FULL_STANDARD_TALKER_ALIAS_BLOCK_1(Vendor.STANDARD,true, 5, "TALKER ALIAS BLOCK 1"),
FULL_STANDARD_TALKER_ALIAS_BLOCK_2(Vendor.STANDARD,true, 6, "TALKER ALIAS BLOCK 2"),
FULL_STANDARD_TALKER_ALIAS_BLOCK_3(Vendor.STANDARD,true, 7, "TALKER ALIAS BLOCK 3"),
FULL_STANDARD_TALKER_ALIAS_COMPLETE(Vendor.STANDARD, true, -1, "TALKER ALIAS COMPLETE"), //Not part of ICD
FULL_STANDARD_GPS_INFO(Vendor.STANDARD,true, 8, "GPS INFO"),
FULL_STANDARD_TERMINATOR_DATA(Vendor.STANDARD, true, 48, "TERMINATOR DATA"),
FULL_STANDARD_UNKNOWN(Vendor.STANDARD,true, -1, "FULL UNKNOWN"),
@@ -67,6 +68,9 @@ public enum LCOpcode
SHORT_STANDARD_UNKNOWN(Vendor.STANDARD,false,-1, "SHORT UNKNOWN");
private static final EnumSet<LCOpcode> TALKER_ALIAS_OPCODES = EnumSet.of(FULL_STANDARD_TALKER_ALIAS_HEADER,
FULL_STANDARD_TALKER_ALIAS_BLOCK_1, FULL_STANDARD_TALKER_ALIAS_BLOCK_2, FULL_STANDARD_TALKER_ALIAS_BLOCK_3);
private Vendor mVendor;
private boolean mFull;
private int mValue;
@@ -111,6 +115,14 @@ public enum LCOpcode
return !mFull;
}
/**
* Indicates if this entry is one of the four talker alias opcodes.
*/
public boolean isTalkerAliasOpcode()
{
return TALKER_ALIAS_OPCODES.contains(this);
}
public int getValue()
{
return mValue;

224
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasAssembler.java Normal file
View File

@@ -0,0 +1,224 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
/**
* Aggregates a sequence of talker alias full link control messages to reconstruct the talker alias.
*/
public class TalkerAliasAssembler
{
//Timeslot 1 fragments
private TalkerAliasHeader mHeaderTs1;
private TalkerAliasBlock1 mBlock1Ts1;
private TalkerAliasBlock2 mBlock2Ts1;
private TalkerAliasBlock3 mBlock3Ts1;
//Timeslot 2 fragments
private TalkerAliasHeader mHeaderTs2;
private TalkerAliasBlock1 mBlock1Ts2;
private TalkerAliasBlock2 mBlock2Ts2;
private TalkerAliasBlock3 mBlock3Ts2;
//Flags indicating if we have any non-null fragments for the specified timeslot to support resetting.
private boolean mEmptyTs1 = true;
private boolean mEmptyTs2 = true;
/**
* Constructs an instance.
*/
public TalkerAliasAssembler()
{
}
/**
* Resets the contents of either timeslot 1 or 2 when a terminator or idle message is received.
* @param timeslot 1 or 2
*/
public void reset(int timeslot)
{
if(timeslot == 1 && !mEmptyTs1)
{
mHeaderTs1 = null;
mBlock1Ts1 = null;
mBlock2Ts1 = null;
mBlock3Ts1 = null;
mEmptyTs1 = true;
}
else if(timeslot == 2 && !mEmptyTs2)
{
mHeaderTs2 = null;
mBlock1Ts2 = null;
mBlock2Ts2 = null;
mBlock3Ts2 = null;
mEmptyTs2 = true;
}
}
/**
* Processes the FLC talker alias header or block and returns a fully assembled alias when all fragments are received.
* @param message containing FLC talker alias header or blocks 1-3
* @return fully assembled talker alias, if available, or null.
*/
public TalkerAliasComplete process(FullLCMessage message)
{
switch(message.getOpcode())
{
case FULL_STANDARD_TALKER_ALIAS_HEADER:
if(message instanceof TalkerAliasHeader tah)
{
if(message.getTimeslot() == 1)
{
mHeaderTs1 = tah;
mEmptyTs1 = false;
return assemble(1);
}
else
{
mHeaderTs2 = tah;
mEmptyTs2 = false;
return assemble(2);
}
}
case FULL_STANDARD_TALKER_ALIAS_BLOCK_1:
if(message instanceof TalkerAliasBlock1 tab1)
{
if(message.getTimeslot() == 1)
{
mBlock1Ts1 = tab1;
mEmptyTs1 = false;
return assemble(1);
}
else
{
mBlock1Ts2 = tab1;
mEmptyTs2 = false;
return assemble(2);
}
}
case FULL_STANDARD_TALKER_ALIAS_BLOCK_2:
if(message instanceof TalkerAliasBlock2 tab2)
{
if(message.getTimeslot() == 1)
{
mBlock2Ts1 = tab2;
mEmptyTs1 = false;
return assemble(1);
}
else
{
mBlock2Ts2 = tab2;
mEmptyTs2 = false;
return assemble(2);
}
}
case FULL_STANDARD_TALKER_ALIAS_BLOCK_3:
if(message instanceof TalkerAliasBlock3 tab3)
{
if(message.getTimeslot() == 1)
{
mBlock3Ts1 = tab3;
mEmptyTs1 = false;
return assemble(1);
}
else
{
mBlock3Ts2 = tab3;
mEmptyTs2 = false;
return assemble(2);
}
}
}
return null;
}
/**
* Assembles the complete alias.
* @param timeslot to assemble.
* @return assembled alias or null.
*/
private TalkerAliasComplete assemble(int timeslot)
{
if(timeslot == 1)
{
return assemble(mHeaderTs1, mBlock1Ts1, mBlock2Ts1, mBlock3Ts1);
}
else
{
return assemble(mHeaderTs2, mBlock1Ts2, mBlock2Ts2, mBlock3Ts2);
}
}
/**
* Assembles a complete alias from the header and block fragments.
* @param header of the alias
* @param block1 of the alias, optional
* @param block2 of the alias, optional
* @param block3 of the alias, optional
* @return assembled alias or null.
*/
private TalkerAliasComplete assemble(TalkerAliasHeader header,
TalkerAliasBlock1 block1,
TalkerAliasBlock2 block2,
TalkerAliasBlock3 block3)
{
if(header != null)
{
int bitLength = header.getTotalBitLength();
if(1 <= bitLength && bitLength <= 49)
{
return new TalkerAliasComplete(header.getPayloadFragment(), header.getFormat(), header.getCharacterLength(),
header.getTimestamp(), header.getTimeslot());
}
else if(50 <= bitLength && bitLength <= 105 && block1 != null)
{
CorrectedBinaryMessage message = new CorrectedBinaryMessage(105);
message.load(0, header.getPayloadFragment());
message.load(49, block1.getPayloadFragment());
return new TalkerAliasComplete(message, header.getFormat(), header.getCharacterLength(),
header.getTimestamp(), header.getTimeslot());
}
else if(106 <= bitLength && bitLength <= 161 && block1 != null && block2 != null)
{
CorrectedBinaryMessage message = new CorrectedBinaryMessage(161);
message.load(0, header.getPayloadFragment());
message.load(49, block1.getPayloadFragment());
message.load(105, block2.getPayloadFragment());
return new TalkerAliasComplete(message, header.getFormat(), header.getCharacterLength(),
header.getTimestamp(), header.getTimeslot());
}
else if(162 <= bitLength && bitLength <= 217 && block1 != null && block2 != null && block3 != null)
{
CorrectedBinaryMessage message = new CorrectedBinaryMessage(217);
message.load(0, header.getPayloadFragment());
message.load(49, block1.getPayloadFragment());
message.load(105, block2.getPayloadFragment());
message.load(161, block3.getPayloadFragment());
return new TalkerAliasComplete(message, header.getFormat(), header.getCharacterLength(),
header.getTimestamp(), header.getTimeslot());
}
}
return null;
}
}

70
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasBlock1.java Normal file
View File

@@ -0,0 +1,70 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import java.util.Collections;
import java.util.List;
/**
* Talker alias continuation block 1.
*/
public class TalkerAliasBlock1 extends FullLCMessage
{
private static final int PAYLOAD_START = 16;
private static final int PAYLOAD_END = 72;
/**
* Constructs an instance
*
* @param message for link control payload
* @param timestamp for the message
* @param timeslot where the message was transmitted
*/
public TalkerAliasBlock1(CorrectedBinaryMessage message, long timestamp, int timeslot)
{
super(message, timestamp, timeslot);
}
/**
* Payload fragment carried by the header.
* @return payload fragment.
*/
public CorrectedBinaryMessage getPayloadFragment()
{
return getMessage().getSubMessage(PAYLOAD_START, PAYLOAD_END);
}
@Override
public List<Identifier> getIdentifiers()
{
return Collections.emptyList();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("FLC TALKER ALIAS BLOCK 1");
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
}

70
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasBlock2.java Normal file
View File

@@ -0,0 +1,70 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import java.util.Collections;
import java.util.List;
/**
* Talker alias continuation block 2.
*/
public class TalkerAliasBlock2 extends FullLCMessage
{
private static final int PAYLOAD_START = 16;
private static final int PAYLOAD_END = 72;
/**
* Constructs an instance
*
* @param message for link control payload
* @param timestamp for the message
* @param timeslot where the message was transmitted
*/
public TalkerAliasBlock2(CorrectedBinaryMessage message, long timestamp, int timeslot)
{
super(message, timestamp, timeslot);
}
/**
* Payload fragment carried by the header.
* @return payload fragment.
*/
public CorrectedBinaryMessage getPayloadFragment()
{
return getMessage().getSubMessage(PAYLOAD_START, PAYLOAD_END);
}
@Override
public List<Identifier> getIdentifiers()
{
return Collections.emptyList();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("FLC TALKER ALIAS BLOCK 2");
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
}

70
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasBlock3.java Normal file
View File

@@ -0,0 +1,70 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import java.util.Collections;
import java.util.List;
/**
* Talker alias continuation block 3.
*/
public class TalkerAliasBlock3 extends FullLCMessage
{
private static final int PAYLOAD_START = 16;
private static final int PAYLOAD_END = 72;
/**
* Constructs an instance
*
* @param message for link control payload
* @param timestamp for the message
* @param timeslot where the message was transmitted
*/
public TalkerAliasBlock3(CorrectedBinaryMessage message, long timestamp, int timeslot)
{
super(message, timestamp, timeslot);
}
/**
* Payload fragment carried by the header.
* @return payload fragment.
*/
public CorrectedBinaryMessage getPayloadFragment()
{
return getMessage().getSubMessage(PAYLOAD_START, PAYLOAD_END);
}
@Override
public List<Identifier> getIdentifiers()
{
return Collections.emptyList();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("FLC TALKER ALIAS BLOCK 3");
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
}

180
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasComplete.java Normal file
View File

@@ -0,0 +1,180 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.alias.DmrTalkerAliasIdentifier;
import io.github.dsheirer.module.decode.dmr.message.data.lc.LCOpcode;
import io.github.dsheirer.module.decode.dmr.message.type.TalkerAliasDataFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Complete talker alias assembled from talker alias header and 0 or more talker alias blocks.
*/
public class TalkerAliasComplete extends FullLCMessage
{
private static final Logger LOGGER = LoggerFactory.getLogger(TalkerAliasComplete.class);
private TalkerAliasDataFormat mDataFormat;
private int mCharacterCount;
private String mAlias;
private DmrTalkerAliasIdentifier mTalkerAliasIdentifier;
/**
* Constructs an instance
*
* @param message for link control payload
* @param timestamp for the header
* @param timeslot for the header and blocks
*/
public TalkerAliasComplete(CorrectedBinaryMessage message, TalkerAliasDataFormat format, int characterCount,
long timestamp, int timeslot)
{
super(message, timestamp, timeslot);
mDataFormat = format;
mCharacterCount = characterCount;
}
@Override
public LCOpcode getOpcode()
{
return LCOpcode.FULL_STANDARD_TALKER_ALIAS_COMPLETE;
}
@Override
public int getOpcodeValue()
{
return getOpcode().getValue();
}
/**
* Alias value
* @return alias value if it can be decoded or empty string.
*/
public String getAliasValue()
{
if(mAlias == null)
{
switch(mDataFormat)
{
//Note: there are 31 possible 7-bit characters, 27 possible 8-bit characters and 13.5 possible 16-bit
//characters. We check each format to ensure character count is at least one and no more than max.
case BIT_7:
if(1 <= mCharacterCount && mCharacterCount <= 31)
{
mAlias = getMessage().parseISO7(0, mCharacterCount);
}
break;
case BIT_8:
if(1 <= mCharacterCount && mCharacterCount <= 27)
{
mAlias = getMessage().parseISO8(1, mCharacterCount);
}
break;
case UTF_8:
if(1 <= mCharacterCount && mCharacterCount <= 27)
{
try
{
mAlias = getMessage().parseUTF8(1, mCharacterCount);
}
catch(Exception e)
{
LOGGER.info("Error decoding talker alias as UTF-8: " + e.getLocalizedMessage());
}
}
break;
case UNICODE_UTF_16_BE:
if(1 <= mCharacterCount && mCharacterCount <= 13)
{
mAlias = getMessage().parseUnicode(1, mCharacterCount);
}
break;
}
//If we couldn't decode, set it to empty so that we don't reprocess every time.
if(mAlias == null)
{
mAlias = "";
}
}
return mAlias;
}
/**
* Talker Alias identifier.
* @return identifier or null if the alias string is null or empty, meaning it could not be decoded.
*/
public DmrTalkerAliasIdentifier getTalkerAliasIdentifier()
{
if(mTalkerAliasIdentifier == null && getAliasValue() != null && !getAliasValue().isEmpty())
{
mTalkerAliasIdentifier = DmrTalkerAliasIdentifier.create(getAliasValue());
}
return mTalkerAliasIdentifier;
}
/**
* Indicates if the talker alias identifier is non-null.
* @return true if non-null.
*/
public boolean hasTalkerAliasIdentifier()
{
return getTalkerAliasIdentifier() != null;
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("FLC TALKER ALIAS:");
if(hasTalkerAliasIdentifier())
{
sb.append(getTalkerAliasIdentifier());
}
else
{
sb.append("(empty/error)");
}
return sb.toString();
}
@Override
public List<Identifier> getIdentifiers()
{
if(hasTalkerAliasIdentifier())
{
List<Identifier> identifiers = new ArrayList<>();
identifiers.add(getTalkerAliasIdentifier());
return identifiers;
}
return Collections.emptyList();
}
}

109
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/lc/full/TalkerAliasHeader.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.lc.full;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.module.decode.dmr.message.type.TalkerAliasDataFormat;
import java.util.Collections;
import java.util.List;
/**
* Talker alias header with format and length description and a fragment of the alias data.
*/
public class TalkerAliasHeader extends FullLCMessage
{
private static final int[] FORMAT = new int[]{16, 17};
private static final int[] LENGTH = new int[]{18, 19, 20, 21, 22};
private static final int PAYLOAD_START = 23;
private static final int PAYLOAD_END = 72;
/**
* Constructs an instance
*
* @param message for link control payload
* @param timestamp for the message
* @param timeslot where the message was transmitted
*/
public TalkerAliasHeader(CorrectedBinaryMessage message, long timestamp, int timeslot)
{
super(message, timestamp, timeslot);
}
/**
* Formatting used for the alias characters.
* @return format
*/
public TalkerAliasDataFormat getFormat()
{
return TalkerAliasDataFormat.fromValue(getMessage().getInt(FORMAT));
}
/**
* Length of the alias in characters.
* @return length in characters.
*/
public int getCharacterLength()
{
return getMessage().getInt(LENGTH);
}
/**
* Total bit length of the alias characters.
*/
public int getTotalBitLength()
{
int total = getFormat().getBitsPerCharacter() * getCharacterLength();
//Max payload bit length is 217 (49 + 56 + 56 + 56)
if(total > 217)
{
return 217;
}
return total;
}
/**
* Payload fragment carried by the header.
* @return payload fragment.
*/
public CorrectedBinaryMessage getPayloadFragment()
{
return getMessage().getSubMessage(PAYLOAD_START, PAYLOAD_END);
}
@Override
public List<Identifier> getIdentifiers()
{
return Collections.emptyList();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("FLC TALKER ALIAS HEADER");
sb.append(" FORMAT:").append(getFormat());
sb.append(" CHARACTERS:").append(getCharacterLength());
sb.append(" MSG:").append(getMessage().toHexString());
return sb.toString();
}
}

37
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/packet/PacketSequence.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -23,7 +23,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.block.DataBlock;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Preamble;
import io.github.dsheirer.module.decode.dmr.message.data.header.PacketSequenceHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.ProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.UDTHeader;
import java.util.ArrayList;
import java.util.List;
@@ -34,6 +34,7 @@ public class PacketSequence
{
private int mTimeslot;
private PacketSequenceHeader mPacketSequenceHeader;
private UDTHeader mUDTHeader;
private ProprietaryDataHeader mProprietaryDataHeader;
private List<Preamble> mPreambles = new ArrayList<>();
private List<DataBlock> mDataBlocks = new ArrayList<>();
@@ -51,7 +52,11 @@ public class PacketSequence
sb.append(" TS:").append(getTimeslot());
if(mPacketSequenceHeader != null)
{
sb.append(mPacketSequenceHeader.toString());
sb.append(mPacketSequenceHeader);
}
else if(mUDTHeader != null)
{
sb.append(mUDTHeader);
}
sb.append(" HEADER:").append(hasPacketSequenceHeader());
sb.append(" PROPRIETARY HEADER:").append(hasProprietaryDataHeader());
@@ -97,6 +102,15 @@ public class PacketSequence
mPacketSequenceHeader = header;
}
/**
* Unified Data Transport (UDT) header
* @param header for a UDT sequence
*/
public void setUDTHeader(UDTHeader header)
{
mUDTHeader = header;
}
/**
* Proprietary data header
*/
@@ -138,6 +152,23 @@ public class PacketSequence
return mPacketSequenceHeader != null;
}
/**
* UDT header
* @return header or null.
*/
public UDTHeader getUDTHeader()
{
return mUDTHeader;
}
/**
* Indicates if this packet sequence has a UDT header
*/
public boolean hasUDTHeader()
{
return getUDTHeader() != null;
}
/**
* Secondary/Proprietary packet sequence header
*/

30
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/packet/PacketSequenceAssembler.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2021 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.block.DataBlock;
import io.github.dsheirer.module.decode.dmr.message.data.csbk.standard.Preamble;
import io.github.dsheirer.module.decode.dmr.message.data.header.PacketSequenceHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.ProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.UDTHeader;
import io.github.dsheirer.sample.Listener;
/**
@@ -70,7 +71,7 @@ public class PacketSequenceAssembler
}
/**
* Sets the listener to receive packet packet sequence messages
* Sets the listener to receive packet sequence messages
* @param listener to receive messages
*/
public void setMessageListener(Listener<IMessage> listener)
@@ -82,11 +83,11 @@ public class PacketSequenceAssembler
* Dispatches the packet sequence for the specified timeslot and sets the sequence to null.
* @param timeslot to dispatch
*/
private void dispatchPacketSequence(int timeslot)
public void dispatchPacketSequence(int timeslot)
{
PacketSequence packetSequence = (timeslot == 1 ? mTimeslot1Sequence : mTimeslot2Sequence);
if(mMessageListener != null && packetSequence != null && packetSequence.isComplete())
if(packetSequence != null && mMessageListener != null)
{
IMessage message = PacketSequenceMessageFactory.create(packetSequence);
@@ -154,6 +155,27 @@ public class PacketSequenceAssembler
packetSequence.setPacketSequenceHeader(header);
}
/**
* Process a UDT header.
* @param header
*/
public void process(UDTHeader header)
{
int timeslot = header.getTimeslot();
PacketSequence packetSequence = getPacketSequence(timeslot);
//If we already have headers or data blocks for the current sequence, then this is a new sequence
if(packetSequence.hasPacketSequenceHeader() || packetSequence.hasProprietaryDataHeader() ||
packetSequence.hasDataBlocks())
{
dispatchPacketSequence(timeslot);
packetSequence = getPacketSequence(timeslot);
}
packetSequence.setUDTHeader(header);
}
/**
* Processes a proprietary packet sequence header.
*/

85
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/packet/PacketSequenceMessageFactory.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2020 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@ import io.github.dsheirer.module.decode.dmr.message.data.block.DataBlock;
import io.github.dsheirer.module.decode.dmr.message.data.header.HeaderMessage;
import io.github.dsheirer.module.decode.dmr.message.data.header.PacketSequenceHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.ProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.UDTHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.hytera.HyteraProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.data.header.motorola.MNISProprietaryDataHeader;
import io.github.dsheirer.module.decode.dmr.message.type.ApplicationType;
@@ -35,11 +36,10 @@ import io.github.dsheirer.module.decode.ip.ipv4.IPV4Header;
import io.github.dsheirer.module.decode.ip.ipv4.IPV4Packet;
import io.github.dsheirer.module.decode.ip.lrrp.LRRPPacket;
import io.github.dsheirer.module.decode.ip.xcmp.XCMPPacket;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Converts a DMR packet sequence into a message
@@ -55,30 +55,73 @@ public class PacketSequenceMessageFactory
*/
public static IMessage create(PacketSequence packetSequence)
{
if(packetSequence != null && packetSequence.isComplete())
if(packetSequence != null)
{
PacketSequenceHeader primaryHeader = packetSequence.getPacketSequenceHeader();
CorrectedBinaryMessage packet = getPacket(packetSequence, primaryHeader.isConfirmedData());
if(packet != null)
if(packetSequence.hasPacketSequenceHeader())
{
switch(primaryHeader.getServiceAccessPoint())
PacketSequenceHeader primaryHeader = packetSequence.getPacketSequenceHeader();
CorrectedBinaryMessage packet = getPacket(packetSequence, primaryHeader.isConfirmedData());
if(packet != null)
{
case IP_PACKET_DATA:
return createIPPacketData(packetSequence, packet);
case PROPRIETARY_DATA:
return createProprietary(packetSequence, packet);
case SHORT_DATA:
return createDefinedShortData(packetSequence, packet);
default:
mLog.info("Unknown Packet SAP: " + primaryHeader.getServiceAccessPoint() + " - returning unknown packet");
return new DMRPacketMessage(packetSequence, new UnknownPacket(packet, 0), packet,
packetSequence.getTimeslot(), packetSequence.getPacketSequenceHeader().getTimestamp());
switch(primaryHeader.getServiceAccessPoint())
{
case IP_PACKET_DATA:
return createIPPacketData(packetSequence, packet);
case PROPRIETARY_DATA:
return createProprietary(packetSequence, packet);
case SHORT_DATA:
return createDefinedShortData(packetSequence, packet);
default:
mLog.info("Unknown Packet SAP: " + primaryHeader.getServiceAccessPoint() + " - returning unknown packet");
return new DMRPacketMessage(packetSequence, new UnknownPacket(packet, 0), packet,
packetSequence.getTimeslot(), packetSequence.getPacketSequenceHeader().getTimestamp());
}
}
}
else if(packetSequence.hasUDTHeader() && packetSequence.hasDataBlocks())
{
UDTHeader header = packetSequence.getUDTHeader();
if(header.isShortData())
{
CorrectedBinaryMessage payload = getUnconfirmedPayload(packetSequence.getDataBlocks());
return new UDTShortMessageService(header, payload);
}
}
}
//TODO: NOTE: Don't create a DMRPacketMessage unless we have a)Packet and b)Packet Sequence Header
return null;
}
/**
* Assembles the unconfirmed payload bytes from each of the data blocks into a contiguous binary message.
* @param dataBlocks to assemble
* @return assembled unconfirmed payload.
*/
public static CorrectedBinaryMessage getUnconfirmedPayload(List<DataBlock> dataBlocks)
{
if(!dataBlocks.isEmpty())
{
int length = 0;
List<CorrectedBinaryMessage> fragments = new ArrayList<>();
for(DataBlock dataBlock: dataBlocks)
{
CorrectedBinaryMessage fragment = dataBlock.getUnConfirmedPayload();
length += fragment.size();
fragments.add(fragment);
}
CorrectedBinaryMessage combined = new CorrectedBinaryMessage(length);
int pointer = 0;
for(CorrectedBinaryMessage fragment: fragments)
{
combined.load(pointer, fragment);
pointer += fragment.size();
}
return combined;
}
return null;
}

188
src/main/java/io/github/dsheirer/module/decode/dmr/message/data/packet/UDTShortMessageService.java Normal file
View File

@@ -0,0 +1,188 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.data.packet;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.module.decode.dmr.message.DMRMessage;
import io.github.dsheirer.module.decode.dmr.message.data.header.UDTHeader;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Short Message Service (SMS) using Unified Data Transport
*/
public class UDTShortMessageService extends DMRMessage
{
private static final Logger LOGGER = LoggerFactory.getLogger(UDTShortMessageService.class);
private UDTHeader mHeader;
private String mSMS;
/**
* Constructs an instance
*
* @param header for the sequence
* @param payload from the data blocks
*/
public UDTShortMessageService(UDTHeader header, CorrectedBinaryMessage payload)
{
super(payload, header.getTimestamp(), header.getTimeslot());
mHeader = header;
}
@Override
public List<Identifier> getIdentifiers()
{
return mHeader.getIdentifiers();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("CC:").append(mHeader.getSlotType().getColorCode());
sb.append(" SMS MESSAGE:").append(getSMS());
sb.append(" FROM:").append(mHeader.getSourceLLID());
sb.append(" TO:").append(mHeader.getDestinationLLID());
sb.append(" HEX:").append(getMessage().toHexString());
return sb.toString();
}
public String getSMS()
{
if(mSMS == null)
{
switch(mHeader.getFormat())
{
case UNICODE_16:
mSMS = parseUnicodePayload();
break;
case ASCII_7:
mSMS = parseISO7Payload();
break;
case ASCII_8:
mSMS = parseISO8Payload();
break;
case BCD_4_BITS:
mSMS = parseBCD4Payload();
break;
case BINARY:
case MOBILE_SUBSCRIBER_OR_TALKGROUP_ADDRESS:
case NMEA_GPS_LOCATION_CODED:
case IP_ADDRESS:
case VENDOR_PROPRIETARY_8:
case VENDOR_PROPRIETARY_9:
case MIXED_FORMAT:
case UNKNOWN:
LOGGER.warn("Unrecognized UDT Short Data Format: " + mHeader.getFormat() +
" - Please send this to the sdrtrunk developer - Hex:" + getMessage().toHexString() +
" As String:" + new String(getMessage().getBytes()));
mSMS = "Error:" + new String(getMessage().getBytes());
break;
}
}
if(mSMS == null)
{
mSMS = "error - unrecognized format: " + mHeader.getFormat();
}
return mSMS;
}
/**
* Parses a unicode 16-bit payload from the message.
* @return parsed message
*/
private String parseUnicodePayload()
{
int length = getMessage().size();
length -= (mHeader.getPadNibbleCount() * 4);
length -= 16; //Exclude the dangling 32-bit CRC
length -= 16; //Exclude the dangling 0x0006 ACKNOWLEDGE character
if(length > 16)
{
return getMessage().parseUnicode(0, (length / 16));
}
else
{
return "(insufficient data)";
}
}
/**
* Parses an ISO-7 payload from the message.
* @return parsed message
*/
private String parseISO7Payload()
{
int length = getMessage().size();
length -= (mHeader.getPadNibbleCount() * 4);
if(length > 7)
{
return getMessage().parseISO7(0, (length / 7));
}
else
{
return "(insufficient data)";
}
}
/**
* Parses an ISO-8 payload from the message.
* @return parsed message
*/
private String parseISO8Payload()
{
int length = getMessage().size();
length -= (mHeader.getPadNibbleCount() * 4);
if(length > 8)
{
return getMessage().parseISO8(0, (length / 8));
}
else
{
return "(insufficient data)";
}
}
/**
* Parses a BCD 4-bit payload from the message.
* @return parsed message
*/
private String parseBCD4Payload()
{
int length = getMessage().size();
length -= (mHeader.getPadNibbleCount() * 4);
if(length > 4)
{
return getMessage().parseBCD4(0, (length / 4));
}
else
{
return "(insufficient data)";
}
}
}

4
src/main/java/io/github/dsheirer/module/decode/dmr/message/type/AnnouncementType.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -36,7 +36,7 @@ public enum AnnouncementType
ADJACENT_SITE_INFORMATION(6, "NEIGHBOR SITE INFORMATION"),
GENERAL_SITE_INFORMATION(7, "SITE INFORMATION"),
RESERVED_8(8, "RESERVED 8"),
RESERVED_9(9, "RESERVED 8"),
RESERVED_9(9, "RESERVED 9"),
RESERVED_10(10, "RESERVED 10"),
RESERVED_11(11, "RESERVED 11"),
RESERVED_12(12, "RESERVED 12"),

87
src/main/java/io/github/dsheirer/module/decode/dmr/message/type/TalkerAliasDataFormat.java Normal file
View File

@@ -0,0 +1,87 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.module.decode.dmr.message.type;
/**
* Enumeration of talker alias data formatting options.
*
* ETSI 102 361-2 v2.4.1 paragraph 7.2.18
*/
public enum TalkerAliasDataFormat
{
BIT_7(0, 7, "ASCII-7"),
BIT_8(1, 8, "ASCII-8"),
UTF_8(2, 8, "UTF-8"),
UNICODE_UTF_16_BE(3, 16, "UNICODE-16");
private int mValue;
private int mBitsPerCharacter;
private String mLabel;
/**
* Constructs an instance
* @param value ordinal
*/
TalkerAliasDataFormat(int value, int bitsPerCharacter, String label)
{
mValue = value;
mBitsPerCharacter = bitsPerCharacter;
mLabel = label;
}
/**
* Ordinal value of the format
* @return ordinal value.
*/
public int getValue()
{
return mValue;
}
/**
* Number of bits per character for the format.
* @return bits per character
*/
public int getBitsPerCharacter()
{
return mBitsPerCharacter;
}
/**
* Lookup the format from the ordinal value.
* @param value to lookup in range 0-3
* @return format for the value.
*/
public static TalkerAliasDataFormat fromValue(int value)
{
if(value < 0 || value > 3)
{
throw new IllegalArgumentException("Invalid value - out of range (0-3): " + value);
}
return TalkerAliasDataFormat.values()[value];
}
@Override
public String toString()
{
return mLabel;
}
}

5
src/main/java/io/github/dsheirer/module/decode/dmr/message/voice/VoiceAMessage.java
View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
* Copyright (C) 2014-2023 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -23,7 +23,6 @@ import io.github.dsheirer.bits.CorrectedBinaryMessage;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.module.decode.dmr.DMRSyncPattern;
import io.github.dsheirer.module.decode.dmr.message.CACH;
import java.util.Collections;
import java.util.List;
@@ -55,7 +54,7 @@ public class VoiceAMessage extends VoiceMessage
}
else
{
sb.append(" ").append(getSyncPattern());
sb.append("CC:- ").append(getSyncPattern());
}
return sb.toString();

1
src/main/java/io/github/dsheirer/module/decode/event/DecodeEventType.java
View File

@@ -63,6 +63,7 @@ public enum DecodeEventType
RESPONSE("Response"),
RESPONSE_PACKET("Response Packet"),
SDM("Short Data Message"),
SMS("SMS"),
STATION_ID("Station ID"),
STATUS("Status"),
UDP_PACKET("UDP/IP Packet"),