mirror of
https://github.com/lwvmobile/dsd-fme.git
synced 2026-11-13 09:17:20 -05:00
Compare commits
11 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
f6cd915f4d | ||
|
|
1dfd59801e | ||
|
|
c4513fab7a | ||
|
|
a3b8839897 | ||
|
|
9e009867ff | ||
|
|
e95e2218d9 | ||
|
|
a9742043b8 | ||
|
|
05eef039c9 | ||
|
|
818e952b7b | ||
|
|
38b962aacf | ||
|
|
0217202801 |
2
.gitignore
vendored
2
.gitignore
vendored
@@ -5,3 +5,5 @@ build
|
||||
*.sh
|
||||
*.csv
|
||||
examples
|
||||
*.bin
|
||||
*.ans
|
||||
|
||||
23
README.md
23
README.md
@@ -2,29 +2,6 @@
|
||||
|
||||
This branch is for modifications to make a Windows 32-bit binary to be precompiled, please DO NOT use this branch if you are a Linux User, or copy any contents out of here to modify your existing setup!
|
||||
|
||||
# Digital Speech Decoder - Florida Man Edition
|
||||
|
||||
DSD-FME is an evolution of the original DSD project from 'DSD Author' using the base code of [szechyjs](https://github.com/szechyjs/dsd "szechyjs"), some code and ideas from [LouisErigHerve](https://github.com/LouisErigHerve/dsd "LouisErigHerve"), [Boatbod OP25](https://github.com/boatbod/op25 "Boatbod OP25") and
|
||||
[Osmocom OP25](https://gitea.osmocom.org/op25/op25 "Osmocom OP25"), along with other snippets of code, information, and inspirations from other projects including [DSDcc](https://github.com/f4exb/dsdcc "DSDcc"), [SDTRunk](https://github.com/DSheirer/sdrtrunk "SDRTrunk"), [MMDVMHost](https://github.com/g4klx/MMDVMHost "MMDVMHost"), [LFSR](https://github.com/mattames/LFSR "LFSR"), [OK-DMRlib](https://github.com/OK-DMR/ok-dmrlib "OK-DMRlib"), and [EZPWD-Reed-Solomon](https://github.com/pjkundert/ezpwd-reed-solomon "EZPWD"), Eric Cottrell, SP5WWP and others. Finally, this is all brought together with original code to extend the fuctionality and add new features including NCurses Terminal and Menu system, Pulse Audio, TCP Direct Link Audio, RIGCTL, Trunking Features, LRRP/GPS Mapping, P25 Phase 2, EDACS, OP25 Capture Bin compatability, etc. DSD-FME is primarily focused with Linux Desktop users, so please understand that this version may not compile, compile easily, or run correctly in other environments.
|
||||
|
||||
This project wouldn't be possible without a few good people providing me plenty of sample audio files to run over and over again. Special thanks to jurek1111, KrisMar, noamlivne, racingfan360, iScottyBotty, LimaZulu and others for the many hours of wav samples submitted by them. Most importantly, HRH17, whose insight, information, samples, and willingness to let me remote into a computer half-way across the globe in order to test trunking features are what make DSD-FME what it has become. Thank you everybody.
|
||||
|
||||
Click image below for video of current DMR/P25 trunking capabilities.
|
||||
|
||||
[](https://www.youtube.com/watch?v=hGIijBbbUxg "DSD-FME Trunking Demo")
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## Information
|
||||
|
||||
See the [examples](https://github.com/lwvmobile/dsd-fme/tree/main/examples "examples") folder for information on [cloning and installing](https://github.com/lwvmobile/dsd-fme/blob/main/examples/Install_Notes.md "cloning and installing"), [example usage](https://github.com/lwvmobile/dsd-fme/blob/main/examples/Example_Usage.md "example usage"), and [trunking examples](https://github.com/lwvmobile/dsd-fme/blob/main/examples/trunking.sh "trunking examples").
|
||||
|
||||
## Notice
|
||||
|
||||
The pulseaudio branch has been deleted in favor of the new main branch which also uses Pulse Audio. Users moving to the main branch should review the help file and example usage files for changes in syntax. Users can download the last pulse audio branch version from the release link if they prefer the older version. Any pre-compiled windows versions found in the release link will be considered legacy as well, and do not feature trunking support and have older handling for some other modes. Users are free to use those, but keep in mind the use case syntax may and will be different between versions. Furthermore, any wiki articles with 'auto intstall scripts' made for windows users may contain outdated information for building the deleted pulseaudio branch, please adjust any information found in those accordingly.
|
||||
|
||||
## License
|
||||
Copyright (C) 2010 DSD Author
|
||||
GPG Key ID: 0x3F1D7FD0 (74EF 430D F7F2 0A48 FCE6 F630 FAA2 635D 3F1D 7FD0)
|
||||
|
||||
@@ -1,158 +0,0 @@
|
||||
### Example Usage and Notes!
|
||||
|
||||
`dsd-fme` is all you need to run for pulse input, pulse output, and auto detect for DMR BS/MS, and P25 (1 and 2) . To use other decoding methods which cannot be auto detected, please use the following command line switches. Make sure to route audio into and out of DSD-FME using pavucontrol and virtual sinks as needed.
|
||||
|
||||
```
|
||||
-ft XDMA decoder class (P25 1 and 2, and DMR Stereo)
|
||||
-fs DMR Stereo, also may need to use -xr if inverted DMR
|
||||
-fa Legacy Auto (not recommended)
|
||||
-fi NXDN48
|
||||
-fn NXDN96
|
||||
-fp ProVoice
|
||||
-fm dPMR, also may need to use -xd if inverted dPMR.
|
||||
-fr DMR Mono, also may need to use -xr if inverted DMR.
|
||||
-f1 P25P1
|
||||
-f2 P25P2 (will need to specify wacn/sys/nac manually)
|
||||
-fx X2-TDMA
|
||||
```
|
||||
|
||||
## Trunking Examples
|
||||
Please see trunking.sh for sample start up scripts or scroll down to the bottom for more explanation.
|
||||
|
||||
## Example Usage - Default Decoder, Ncurses Terminal, Pulse Input/Output, and Log Console to file
|
||||
`dsd-fme -N 2> voice.log`
|
||||
|
||||
and in a second terminal tab, same folder, run
|
||||
|
||||
`tail -n 40 -f voice.log`
|
||||
|
||||
Then you can open up your pavucontrol "Pulse Audio Volume Control" or "Volume Control" application and route input into DSD-FME from any application and DSD-FME output to the left and right speakers respectively. (unlock the channel in the application stream and adjust left and right independently)
|
||||
|
||||
### Input ###
|
||||
|
||||
--TCP Direct Audio Link with SDR++
|
||||
|
||||
`dsd-fme -i tcp` Currently defaults to localhost:7355 (SDR++ defaults)
|
||||
|
||||
`dsd-fme -i tcp:192.168.7.5:7356` (remote host and custom port)
|
||||
|
||||
--48000/9600 Mono Wav File Input
|
||||
|
||||
`dsd-fme -i filename.wav` 48k/1 Audio (SDR++, GQRX wav recordings)
|
||||
|
||||
`dsd-fme -i filename.wav -s 96000` 96k/1 (DSDPlus Raw Signal Wav Files)
|
||||
|
||||
Wav File Input Note: Due to 96000 rate audio requiring me to double the symbol rate and center, be sure to use the -s 96000 at the very end of the startup command. Also, some NXDN48/96 may have difficulties decoding properly with wav file input.
|
||||
|
||||
## Example Usage - RTL2832 Dongle Input
|
||||
`dsd-fme -ft -i rtl:0:154.9875M:26:-2:8:0:6020 `
|
||||
|
||||
```
|
||||
RTL-SDR options:
|
||||
WARNING! Old CLI Switch Handling has been depreciated in favor of rtl:<parms>
|
||||
Usage: rtl:dev:freq:gain:ppm:bw:sq:udp
|
||||
dev <num> RTL-SDR Device Index Number
|
||||
freq <num> RTL-SDR Frequency (851800000 or 851.8M)
|
||||
gain <num> RTL-SDR Device Gain (0-49) (default = 26)(0 = Hardware AGC, not recommended)
|
||||
ppm <num> RTL-SDR PPM Error (default = 0)
|
||||
bw <num> RTL-SDR VFO Bandwidth kHz (default = 12)(6, 8, 12, 24)
|
||||
sq <num> RTL-SDR Squelch Level (0 - Open, 25 - Little, 50 - Higher)
|
||||
udp <num> RTL-SDR UDP Remote Port (default = 6020)
|
||||
Example: dsd-fme -fp -i rtl:0:851.375M:22:-2:12:0:6021
|
||||
|
||||
```
|
||||
|
||||
## Example Usage - Extra Payload/PDU Logging
|
||||
|
||||
`dsd-fme -Z -N 2>> log.ans`
|
||||
|
||||
and in a second terminal tab, same folder, run
|
||||
|
||||
`tail -n 40 -f log.ans`
|
||||
|
||||
### EDACS/P25/NXDN/DMR Simple/Single VFO Trunking ###
|
||||
|
||||
EDACS Trunking (w/ channel map import)
|
||||
|
||||
--EDACS/PV Trunking using RIGCTL and TCP Direct Link Audio inside of SDR++ (Tested and Working on EDACS/EDACS-EA with Provoice only, no analog voice monitoring)
|
||||
|
||||
`dsd-fme -i tcp -fp -C channel_map.csv -G group.csv -T -U 4532 -N 2> log.ans`
|
||||
|
||||
--NXDN48 Trunking (standard band plan) with SDR++ (untested for frequency accuracy)
|
||||
|
||||
`dsd-fme -fi -i tcp -T -U 4532 -N 2> log.ans`
|
||||
|
||||
--NXDN48 Trunking (w/ channel map import) with SDR++ (put control channel frequency at channel 0 in channel_map.csv)
|
||||
|
||||
`dsd-fme -fi -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans`
|
||||
|
||||
--DMR Trunking (w/ channel map import) with SDR++ (put control channel frequency at channel 0 (TIII and Con+) in channel_map.csv)
|
||||
|
||||
`dsd-fme -fs -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans`
|
||||
|
||||
--P25 Trunking P1 and P2 (C4FM) with SDR++
|
||||
|
||||
`dsd-fme -i tcp -T -U 4532 -N 2> log.ans`
|
||||
|
||||
--P25 Trunking (CQPSK) with P1 Control Channel (Should switch symbol rate and center on Phase 2 audio channels)
|
||||
|
||||
`dsd-fme -i tcp -T -U 4532 -N -mq 2> log.ans`
|
||||
|
||||
--P25 Trunking Phase 2 TDMA Control Channel systems with CQPSK (non Phase 1 systems)
|
||||
|
||||
`dsd-fme -i tcp -T -U 4532 -N -f2 -m2 2> log.ans`
|
||||
|
||||
Trunking Note1: All samples above can also be run with the RTL input method and setting of RTL UDP remote port. In terms of performance, however, SDR++ will do a much better job on weaker/marginal signal compared to the RTL input. RTL input should only be used on strong signal.
|
||||
|
||||
`dsd-fme -fp -i rtl:0:851.8M:22:-2:24:0:6020 -T -C channel_map.csv -G group.csv -N 2> log.ans`
|
||||
|
||||
Trunking Note2: CQPSK Phase 1 and Phase 2 Systems are subceptible to LSM distortion issues, but seem to do okay, but require really good signal. Some CRC issues still occur with Phase 2 TDMA LCCH Mac Signal that can affect reliability, I believe this issue is ultimately caused by the PSK demodulation inside of FME. I also don't believe this will work on 8-level PSK, but I cannot determine that at the moment. Update: I have improved the LCCH Mac Signal decoding my increasing the QPSK decision point buffers to their maximum values.
|
||||
|
||||
Trunking Note3: DMR Trunking has been coded, and some testing and tweaks have been carried out. Cap+, Con+, and TIII systems seem to do well with trunking now. Placing the frequency for the control channel at channel map 0 in your channel_map.csv file is not required now if using RIGCTL or the RTL Input, both can poll the VFO for the current frequency if it believes its on a control channel, but setting a fake channel number (i.e. 999) first with the CC frequency will result in finding the CC faster on startup if desired. If you need to map out your channels for TIII, you can observe the console output and look for channel numbers. For conveniece I have included the DSDPlus channel numbering (as best as I can figure it, but they seem consistent) into the console print so it will make it easier for users from DSDPlus to map frequencies into the channel_map.csv file. Make sure your channel numbers are the Cd (channel decimal) values from the log, and not the C+ (dsdplus) values. Notice: TIII Site ID value needs work to determine proper DMRLA values for system area and sub area.
|
||||
|
||||
```
|
||||
Talkgroup Voice Channel Grant (TV_GRANT) - Logical
|
||||
Ch [036] Cd [0054] C+ [0110] - TS [1] - Target [01900500] - Source [01900505]
|
||||
```
|
||||
|
||||
Use channel 54 in your import file, which would correspond to dsdplus channels 109 and 110 (109 = TS0 / 110 = TS1).
|
||||
|
||||
For Connect Plus, enumerate your list from 1 to the last channel and add the frequency. For Capacity Plus, Rest Channels 1 and 2 will share the same frequency, 3 and 4 will share, 5 and 6 will share, and 7-8 will share, as Capacity Plus counts each RF frequency as two seperate channels, one for each time slot. Capacity Plus Quirk: DSD-FME makes its best effort to follow the rest channel in the event that the sync is lost for longer than the hangtime, but occassionally, DSD-FME will lose the rest channel and will have to hunt through all frequencies to find it again.
|
||||
|
||||
Currently uncoded/unknown DMR trunking systems include Hytera XPT.
|
||||
|
||||
Trunking Note4: NXDN TRunking will require a channel map. Please see the example folder for an appropriate channel map. ~NXDN Trunking may also require a channel map file, depending on the system. If it uses a custom range (above 800), then channels will need to be mapped. If channels do not require mapping (have channels below 800) but you are not tuning properly, then please use a channel_map and please report the issue in the issues along with the channels you are tuning and the actual rf frequency so corrections can be made.~
|
||||
|
||||
Channel Map and Group CSV Note: Leave the top line of the channel_map.csv and group.csv as the label, do not delete the line, if no line is there, dsd_import skips the first line so it will not import the first channel or first group in those files if there is something there that isn't a label.
|
||||
|
||||
## NCurses Keyboard Shortcuts ##
|
||||
|
||||
Some Keyboard Shortcuts have been implemented for testing to see how users like them. Just hope nobody pushes a key on accident and doesn't know which one it was or what it does. The current list of keyboard shortcuts include:
|
||||
|
||||
```
|
||||
esc or arrow keys - ncurses menu
|
||||
q - quit
|
||||
c - toggle compact mode
|
||||
h - toggle call history
|
||||
z - toggle console payloads
|
||||
a - toggle call alert beep
|
||||
4 - force dmr privacy key assertion over fid and svc bits
|
||||
i - toggle signal inversion on types that can't auto detect (dmr, dpmr)
|
||||
m - toggle c4fm/qpsk 10/4 (everything but phase 2 signal)
|
||||
M - toggle c4fm/qpsk 8/3 (phase 2 tdma control channel)
|
||||
R - start capturing symbol capture bin (date/time name file)
|
||||
r - stop capturing symbol capture bin
|
||||
spacebar - replay last symbol capture bin (captures must be stopped first)
|
||||
s - stop playing symbol capture bin or wav input file
|
||||
P - start per call decoded wav files
|
||||
p - stop per call decoded wav files
|
||||
t - toggle trunking (needs either rtl input, or rigctl connection)
|
||||
1 - Lockout Tuning/Playback of TG in Slot 1 or Conventional (Current Session Only)
|
||||
2 - Lockout Tuning/Playback of TG in Slot 2 (Current Session Only)
|
||||
0 - Toggle Audio Smoothing - May produce crackling if enabled on RTL/TCP or wav/bin files
|
||||
w - Toggle Trunking/Playback White List (Allow A Groups Only) / Black List (Block B or DE groups only) Mode
|
||||
g - Toggle Trunking Tuning to Group Calls (DMR T3, Con+, Cap+, P25)
|
||||
u - Toggle Trunking Tuning to Private Calls (DMR T3, P25)
|
||||
d - Toggle Trunking Tuning to Data Calls (DMR T3)
|
||||
|
||||
```
|
||||
@@ -1,131 +0,0 @@
|
||||
## Notice
|
||||
|
||||
These should not be followed for the 'lite' branch
|
||||
|
||||
## How to clone and build this branch
|
||||
|
||||
### Ubuntu 22.04/20.04/LM20/Debian Bullseye or Newer:
|
||||
|
||||
Using the included download-and-install.sh should make for a simple and painless clone, build, and install on newer Debian/Ubuntu/Mint/Pi systems. Simply acquire or copy the script, and run it. Update: Ubuntu 22.04 and RPi Bullseye 64-bit has been tested working with the installer script and functions appropriately.
|
||||
|
||||
If you need all dependencies build and installed first (only on Debian/Ubuntu/Mint/Pi), run:
|
||||
|
||||
```
|
||||
wget https://raw.githubusercontent.com/lwvmobile/dsd-fme/main/download-and-install.sh
|
||||
chmod +x download-and-install.sh
|
||||
./download-and-install.sh
|
||||
```
|
||||
|
||||
If you have dependencies already installed (i.e. need a fresh clean install on a system with DSD-FME already or using system other than Debian/Ubuntu, etc), please run this instead:
|
||||
|
||||
```
|
||||
wget https://raw.githubusercontent.com/lwvmobile/dsd-fme/main/download-and-install-nodeps.sh
|
||||
chmod +x download-and-install-nodeps.sh
|
||||
./download-and-install-nodeps.sh
|
||||
```
|
||||
|
||||
### Ubuntu 18.04/LM19/Buster Note:
|
||||
The above install.sh should now function on older system types. You can elect to manually follow the steps down below. Do NOT Manually build and install ITPP 4.3.1 on older systems, it is currently not wanting to build on Ubuntu 18.04 and Linux Mint 19. Install it from the repository instead.
|
||||
|
||||
## Manual Install
|
||||
|
||||
First, install dependency packages. This guide will assume you are using Debian/Ubuntu based distros. Check your package manager for equivalent packages if different.
|
||||
|
||||
```
|
||||
sudo apt update
|
||||
sudo apt install libpulse-dev pavucontrol libsndfile1-dev libfftw3-dev liblapack-dev socat libusb-1.0-0-dev libncurses5 libncurses5-dev rtl-sdr librtlsdr-dev libusb-1.0-0-dev cmake git wget make build-essential libitpp-dev libncursesw5-dev
|
||||
```
|
||||
## Headless
|
||||
|
||||
If running headless, swap out pavucontrol for pulsemixer, and also install pulseaudio as well. Attempting to install pavucontrol in a headless environment may attempt to install a minimal desktop environment. Note: Default behavior of pulseaudio in a headless environment may be to be muted, so check by opening pulsemixer and unmuting and routing audio appropriately.
|
||||
|
||||
```
|
||||
sudo apt install libpulse-dev libsndfile1-dev libfftw3-dev liblapack-dev socat libusb-1.0-0-dev libncurses5 libncurses5-dev rtl-sdr librtlsdr-dev libusb-1.0-0-dev cmake git wget make build-essential libitpp-dev libncursesw5-dev pulsemixer pulseaudio
|
||||
```
|
||||
|
||||
### Build and Install ITPP - ONLY IF NOT IN REPO!!
|
||||
|
||||
```
|
||||
wget -O itpp-latest.tar.bz2 http://sourceforge.net/projects/itpp/files/latest/download?source=files
|
||||
tar xjf itpp*
|
||||
#if you can't cd into this folder, double check folder name first
|
||||
cd itpp-4.3.1
|
||||
mkdir build
|
||||
cd build
|
||||
cmake ..
|
||||
make -j `nproc`
|
||||
sudo make install
|
||||
sudo ldconfig
|
||||
cd ..
|
||||
cd ..
|
||||
```
|
||||
|
||||
MBELib is considered a requirement in this build. You must read this notice prior to continuing. [MBElib Patent Notice](https://github.com/lwvmobile/mbelib#readme "MBElib Patent Notice") This version of MBELib is 1.3.2 and prints to STDERR, using the stock 1.3.0 MBElib may cause problems with print alignments if paired with this version of DSD-FME, or cause future compatibility issues.
|
||||
|
||||
```
|
||||
git clone https://github.com/lwvmobile/mbelib
|
||||
cd mbelib
|
||||
mkdir build
|
||||
cd build
|
||||
cmake ..
|
||||
make -j `nproc`
|
||||
sudo make install
|
||||
sudo ldconfig
|
||||
cd ..
|
||||
cd ..
|
||||
```
|
||||
|
||||
Note: Some environment/distro users (Cygwin, Arch, and others) may need to manually copy any libmbe files found in the build folder to the /usr/lib folder on root.
|
||||
`sudo cp libmbe* /usr/lib`
|
||||
|
||||
Finish by running these steps to clone and build DSD-FME.
|
||||
|
||||
```
|
||||
git clone https://github.com/lwvmobile/dsd-fme
|
||||
cd dsd-fme
|
||||
sudo cp tone8.wav /usr/share/
|
||||
sudo cp tone24.wav /usr/share/
|
||||
sudo cp tone48.wav /usr/share/
|
||||
sudo chmod 777 /usr/share/tone8.wav
|
||||
sudo chmod 777 /usr/share/tone24.wav
|
||||
sudo chmod 777 /usr/share/tone48.wav
|
||||
mkdir build
|
||||
cd build
|
||||
cmake ..
|
||||
make -j `nproc`
|
||||
sudo make install
|
||||
sudo ldconfig
|
||||
|
||||
```
|
||||
Optional 'Virtual Sinks' for routing audio from SDR++ or GQRX, Media Players, etc. into DSD-FME
|
||||
|
||||
You may wish to direct sound into DSD-FME via Virtual Sinks. You may set up a Virtual Sink or two on your machine for routing audio in and out of applications to other applications using the following command, and opening up pavucontrol "PulseAudio Volume Control" in the menu (or `pulsemixer` in headless mode) to change line out of application to virtual sink, and line in of DSD-FME to monitor of virtual sink. This command will not persist past a reboot, so you will need to invoke them each time you reboot, or search for how to add this to your conf files for persistency if desired.
|
||||
|
||||
```
|
||||
pacmd load-module module-null-sink sink_name=virtual_sink sink_properties=device.description=Virtual_Sink
|
||||
pacmd load-module module-null-sink sink_name=virtual_sink2 sink_properties=device.description=Virtual_Sink2
|
||||
```
|
||||
|
||||
Already have this branch, and just want to pull the latest build? You can run the rebuild.sh file in the dsd-fme folder, or manually do the pull with the commands:
|
||||
|
||||
```
|
||||
##Open your clone folder##
|
||||
git pull
|
||||
##cd into your build folder##
|
||||
cd build
|
||||
cmake ..
|
||||
make -j `nproc`
|
||||
sudo make install
|
||||
sudo ldconfig
|
||||
```
|
||||
|
||||
If the call alert wav files aren't playing, then make sure to run the following in the dsd-fme folder to copy the wav files to the /usr/share/ folder and give them adequate permission to be accessed.
|
||||
|
||||
```
|
||||
sudo cp tone8.wav /usr/share/
|
||||
sudo cp tone24.wav /usr/share/
|
||||
sudo cp tone48.wav /usr/share/
|
||||
sudo chmod 777 /usr/share/tone8.wav
|
||||
sudo chmod 777 /usr/share/tone24.wav
|
||||
sudo chmod 777 /usr/share/tone48.wav
|
||||
```
|
||||
@@ -1,10 +0,0 @@
|
||||
ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
|
||||
1,858606250
|
||||
2,858606250
|
||||
3,859606250
|
||||
4,859606250
|
||||
5,860606250
|
||||
6,860606250
|
||||
7,861606250
|
||||
8,861606250
|
||||
|
||||
|
@@ -1,19 +0,0 @@
|
||||
ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
|
||||
999,862093750,default cc (come here first), optional use non-existent channel as first entry
|
||||
1,863093750
|
||||
2,862093750
|
||||
3,861093750
|
||||
4,860093750
|
||||
5,859093750
|
||||
6,863593750
|
||||
7,862593750
|
||||
8,861593750
|
||||
9,860593750
|
||||
10,859593750
|
||||
11,863393750
|
||||
12,862393750
|
||||
13,861393750
|
||||
14,860393750
|
||||
15,859393750
|
||||
|
||||
|
||||
|
@@ -1,8 +0,0 @@
|
||||
ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
|
||||
999,456318750,default cc (come here first), optional use non-existent channel as first entry
|
||||
36,455756250
|
||||
54,455981250
|
||||
81,456318750
|
||||
|
||||
|
||||
|
||||
|
@@ -1,6 +0,0 @@
|
||||
ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
|
||||
1,851375000
|
||||
2,851800000
|
||||
3,855987500
|
||||
4,858487500
|
||||
5,852312500
|
||||
|
@@ -1,5 +0,0 @@
|
||||
DEC,Mode(A- Allow, B - Block, DE - Digital Enc),Name of Group,Tag (do not delete this line or won't import properly)
|
||||
100,B,Example Name,Tag
|
||||
1449,A,Fire Dispatch,Fire
|
||||
929,A,Fire Tac,Fire
|
||||
22033,DE,Law Dispatch,Law
|
||||
|
@@ -1,8 +0,0 @@
|
||||
channel(dec), freq(Hz)
|
||||
141,423862500
|
||||
142,424337500
|
||||
143,424912500
|
||||
203,424100000
|
||||
204,424625000
|
||||
271,422650000
|
||||
302,423287500
|
||||
|
@@ -1,5 +0,0 @@
|
||||
key(dec), value(dec), load any single keys as key 0
|
||||
0,23466
|
||||
1,12345
|
||||
2,32700
|
||||
63,32767
|
||||
|
@@ -1,40 +0,0 @@
|
||||
#example trunking sh scripts (SDR++ and RTL Input) -T = trunking
|
||||
#make sure to put a # in front of all lines except the one you wish to use
|
||||
|
||||
#P25 P1 FDMA CC with C4FM
|
||||
#dsd-fme -i tcp -U 4532 -T -N 2> log.ans
|
||||
#dsd-fme -i rtl:0:850M:26:-2:8:0:6020 -T -N 2> log.ans
|
||||
|
||||
#P25 P1 FDMA CC with QPSK (Simulcast)
|
||||
#dsd-fme -i tcp:192.168.7.8:7355 -U 4532 -T -mq -N 2> log.ans
|
||||
#dsd-fme -i rtl:0:855.625M:26:-2:12:0:6020 -T -mq -N 2> log.ans
|
||||
|
||||
#P25 P2 TDMA CC with QPSK (Simulcast)
|
||||
#dsd-fme -i tcp:192.168.7.8:7355 -U 4532 -T -f2 -m2 -N 2> log.ans
|
||||
#dsd-fme -i rtl:0:855.625M:26:-2:12:0:6020 -T -f2 -m2 -N 2> log.ans
|
||||
|
||||
#DMR TIII, Con+, Cap+
|
||||
dsd-fme -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans
|
||||
#dsd-fme -fs -i rtl:0:450M:26:-2:8:0:6020 -T -C connect_plus_chan.csv -G group.csv -N 2> log.ans
|
||||
|
||||
#EDACS/EDACS-EA Digital Only
|
||||
#dsd-fme -fp -i tcp:192.168.7.5:7355 -U 4532 -T -C edacs_channel_map.csv -G group.csv -N 2> log.ans
|
||||
#dsd-fme -fp -i rtl:0:850M:26:-2:24:0:6020 -T -C edacs_channel_map.csv -G group.csv -N 2> log.ans
|
||||
|
||||
#NXDN48 Trunking with Standard Band Plan (Channels 0-800)
|
||||
#dsd-fme -fi -i tcp -T -U 4532 -N 2> log.ans
|
||||
#dsd-fme -fi -i rtl:0:450M:26:-2:8:75:6020 -T -G group.csv -N 2> log.ans
|
||||
|
||||
#NXDN48 Trunking with Channel Map (Custom Channels > 800)
|
||||
#dsd-fme -fi -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans
|
||||
#dsd-fme -fi -i rtl:0:450M:26:-2:8:75:6020 -T -G group.csv -C channel_map.csv -N 2> log.ans
|
||||
|
||||
#Notes: parameters after -i tcp can be omitted if using localhost as the default hostname to connect
|
||||
#and 7355 as the default port number. -U is the port number for RIGCTL and will mirror the tcp hostname
|
||||
#running under the assumption that the user will be connnecting the VFO to the same instance of SDR++
|
||||
#You can also specify an ip address to connect to a remote SDR++ instance, make sure that the settings
|
||||
#inside of SDR++ match, i.e., change in SDR++ from 'localhost' to an IP to bind to (machine's IP address)
|
||||
|
||||
#Note2: RTL input should only be used on strong signal, the SDR++ VFO will perform much better on marginal signal
|
||||
|
||||
#Having a -G group.csv is purely optional, but useful if you want to block groups, or give groups names
|
||||
@@ -527,17 +527,19 @@ typedef struct
|
||||
int directmode;
|
||||
|
||||
int dmr_stereo_payload[144]; //load up 144 dibit buffer for every single DMR TDMA frame
|
||||
uint8_t data_header_blocks[2]; //collect number of blocks to follow from data header per slot
|
||||
int data_header_blocks[2]; //collect number of blocks to follow from data header per slot
|
||||
int data_block_counter[2]; //counter for number of data blocks collected
|
||||
uint8_t data_header_valid[2]; //flag for verifying the data header if still valid (in case of tact/burst fec errs)
|
||||
uint8_t data_header_padding[2]; //collect number of padding octets in last block per slot
|
||||
uint8_t data_header_format[2]; //collect format of data header (conf or unconf) per slot
|
||||
uint8_t data_header_sap[2]; //collect sap info per slot
|
||||
uint8_t data_block_counter[2]; //counter for number of data blocks collected
|
||||
uint8_t data_p_head[2]; //flag for dmr proprietary header to follow
|
||||
|
||||
//new stuff below here
|
||||
uint8_t data_conf_data[2]; //flag for confirmed data blocks per slot
|
||||
uint8_t dmr_pdu_sf[2][288]; //unified pdu 'superframe' //[slot][byte]
|
||||
uint8_t cap_plus_csbk_bits[12*8*4]; //CSBK Cap+ FL initial and appended block bit storage
|
||||
uint8_t data_conf_data[2]; //flag for confirmed data blocks per slot
|
||||
uint8_t dmr_pdu_sf[2][288]; //unified pdu 'superframe' //[slot][byte]
|
||||
uint8_t cap_plus_csbk_bits[12*8*8]; //CSBK Cap+ FL initial and appended block bit storage
|
||||
uint8_t cap_plus_block_num; //received block number storage
|
||||
uint8_t data_block_crc_valid[2][25]; //flag each individual block as good crc on confirmed data
|
||||
char dmr_embedded_signalling[2][7][48]; //embedded signalling 2 slots by 6 vc by 48 bits (replacing TS1SuperFrame.TimeSlotRawVoiceFrame.Sync structure)
|
||||
|
||||
@@ -654,8 +656,8 @@ typedef struct
|
||||
uint32_t nxdn_location_sys_code;
|
||||
uint16_t nxdn_location_site_code;
|
||||
|
||||
//multi-key array for nxdn keys
|
||||
unsigned long long int rkey_array[0x1FF];
|
||||
//multi-key array
|
||||
unsigned long long int rkey_array[0xFFFF];
|
||||
|
||||
//dmr late entry mi
|
||||
uint64_t late_entry_mi_fragment[2][7][3];
|
||||
@@ -926,11 +928,12 @@ void dmrMSData (dsd_opts * opts, dsd_state * state);
|
||||
void dmrMSBootstrap (dsd_opts * opts, dsd_state * state);
|
||||
|
||||
//dmr data header and multi block types (header, 1/2, 3/4, 1, Unified)
|
||||
void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors);
|
||||
void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t dheader_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors);
|
||||
void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_len, uint8_t databurst, uint8_t type);
|
||||
void dmr_pdu (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
|
||||
void dmr_reset_blocks (dsd_opts * opts, dsd_state * state);
|
||||
uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
|
||||
void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
|
||||
void dmr_locn (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
|
||||
|
||||
//dmr alg stuff
|
||||
void dmr_alg_reset (dsd_opts * opts, dsd_state * state);
|
||||
@@ -950,6 +953,7 @@ uint8_t crc7(uint8_t bits[], unsigned int len);
|
||||
//LFSR code courtesy of https://github.com/mattames/LFSR/
|
||||
void LFSR(dsd_state * state);
|
||||
void LFSRN (char * BufferIn, char * BufferOut, dsd_state * state);
|
||||
void LFSR64(dsd_state * state);
|
||||
|
||||
void Hamming_7_4_init();
|
||||
void Hamming_7_4_encode(unsigned char *origBits, unsigned char *encodedBits);
|
||||
|
||||
794
src/dmr_block.c
794
src/dmr_block.c
@@ -8,286 +8,377 @@
|
||||
|
||||
#include "dsd.h"
|
||||
|
||||
void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
|
||||
//hopefully a more simplified (or logical) version...once you get past all the variables
|
||||
void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t dheader_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
|
||||
{
|
||||
|
||||
uint32_t i, j, k;
|
||||
uint8_t slot = state->currentslot;
|
||||
|
||||
//clear out unified pdu 'superframe' slot
|
||||
for (short int i = 0; i < 288; i++)
|
||||
{
|
||||
state->dmr_pdu_sf[slot][i] = 0;
|
||||
}
|
||||
for (short int i = 0; i < 288; i++) state->dmr_pdu_sf[slot][i] = 0;
|
||||
|
||||
//TODO: ONLY RUN ON GOOD CRC?
|
||||
//reset block counter to 1
|
||||
state->data_block_counter[slot] = 1;
|
||||
|
||||
//collect relevant data header info, figure out format, and grab appropriate info from it
|
||||
if (state->data_p_head[slot] == 0)
|
||||
if (IrrecoverableErrors == 0 && CRCCorrect == 1) //&&CRCCorrect == 1
|
||||
{
|
||||
|
||||
uint8_t gi = dheader_bits[0]; //group or individual data
|
||||
uint8_t a = dheader_bits[1]; //response requested flag
|
||||
uint8_t ab = (uint8_t)ConvertBitIntoBytes(&dheader_bits[2], 2); //appended blocks
|
||||
uint8_t dpf = (uint8_t)ConvertBitIntoBytes(&dheader_bits[4], 4); //data packet format
|
||||
uint8_t sap = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 4); //service access point
|
||||
uint8_t poc = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 4); //padding octets
|
||||
|
||||
uint32_t target = (uint32_t)ConvertBitIntoBytes(&dheader_bits[16], 24); //destination llid
|
||||
uint32_t source = (uint32_t)ConvertBitIntoBytes(&dheader_bits[40], 24); //source llid
|
||||
|
||||
//store source for dmr pdu packet handling (lrrp) when not available in completed message
|
||||
if (dpf != 15) state->dmr_lrrp_source[slot] = source;
|
||||
|
||||
//set dpf to storage for later use (UDT, SD, etc)
|
||||
state->data_header_format[slot] = dpf;
|
||||
|
||||
//Type Strings
|
||||
char sap_string[20];
|
||||
char mfid_string[20];
|
||||
char udtf_string[20];
|
||||
char sddd_string[20];
|
||||
sprintf (sap_string, "%s", "");
|
||||
sprintf (mfid_string, "%s", "");
|
||||
sprintf (udtf_string, "%s", "");
|
||||
sprintf (sddd_string, "%s", "");
|
||||
|
||||
//see 9.3 - ETSI TS 102 361-1 V2.5.1 (2017-10) for more info
|
||||
uint8_t f = dheader_bits[64]; //F -- Full message flag (F)
|
||||
uint8_t bf = (uint8_t)ConvertBitIntoBytes(&dheader_bits[65], 7); //Blocks to Follow (BF)
|
||||
|
||||
//confirmed data header
|
||||
uint8_t s = dheader_bits[72]; //S -- Re-Synchronize Flag
|
||||
uint8_t ns = (uint8_t)ConvertBitIntoBytes(&dheader_bits[73], 3); //N(S) -- send sequence number
|
||||
uint8_t fsn = (uint8_t)ConvertBitIntoBytes(&dheader_bits[76], 4); //Fragment Sequence Number (FSN)
|
||||
|
||||
//response header
|
||||
uint8_t r_class = (uint8_t)ConvertBitIntoBytes(&dheader_bits[72], 2);
|
||||
uint8_t r_type = (uint8_t)ConvertBitIntoBytes(&dheader_bits[74], 3);
|
||||
uint8_t r_status = (uint8_t)ConvertBitIntoBytes(&dheader_bits[77], 3);
|
||||
|
||||
//short data - status/precoded
|
||||
uint8_t s_ab_msb = (uint8_t)ConvertBitIntoBytes(&dheader_bits[2], 2); //appended block, msb
|
||||
uint8_t s_ab_lsb = (uint8_t)ConvertBitIntoBytes(&dheader_bits[12], 4);//appended block, lsb
|
||||
uint8_t s_ab_fin = (s_ab_msb << 2) | s_ab_lsb; //appended blocks, final value
|
||||
uint8_t s_source_port = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 3);
|
||||
uint8_t s_dest_port = (uint8_t)ConvertBitIntoBytes(&dheader_bits[67], 3);
|
||||
uint8_t s_status_precoded = (uint8_t)ConvertBitIntoBytes(&dheader_bits[70], 10);
|
||||
|
||||
//short data - raw
|
||||
uint8_t sd_sarq = dheader_bits[70]; //Selective Automatic Repeat reQuest
|
||||
uint8_t sd_f = dheader_bits[71]; //full message flag
|
||||
uint8_t sd_bp = (uint8_t)ConvertBitIntoBytes(&dheader_bits[72], 8); //bit padding
|
||||
|
||||
//short data - defined
|
||||
uint8_t dd_format = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 6);
|
||||
|
||||
//Unified Data Transport (UDT)
|
||||
uint8_t udt_format = (uint8_t)ConvertBitIntoBytes(&dheader_bits[12], 4);
|
||||
uint8_t udt_padnib = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 5);
|
||||
uint8_t udt_uab = (uint8_t)ConvertBitIntoBytes(&dheader_bits[70], 2); //udt appended blocks
|
||||
uint8_t udt_sf = dheader_bits[72];
|
||||
uint8_t udt_pf = dheader_bits[73];
|
||||
uint8_t udt_op = (uint8_t)ConvertBitIntoBytes(&dheader_bits[74], 6);
|
||||
|
||||
//p_head
|
||||
uint8_t p_sap = (uint8_t)ConvertBitIntoBytes(&dheader_bits[0], 4);
|
||||
uint8_t p_mfid = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 8);
|
||||
uint8_t p_pot = (uint8_t)ConvertBitIntoBytes(&dheader_bits[3], 5); //looking for LRRP pot_report
|
||||
|
||||
fprintf (stderr, "%s ", KGRN);
|
||||
state->data_block_counter[slot] = 1; //reset block counter to 1
|
||||
state->data_header_format[slot] = dheader[0]; //collect the entire byte, we can check group or individual, response requested as well on this
|
||||
state->data_header_sap[slot] = (dheader[1] & 0xF0) >> 4;
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, " Slot %d Data Header - ", slot+1);
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0x2)
|
||||
if (gi == 1 && dpf != 15) fprintf(stderr, "GROUP - ");
|
||||
if (gi == 0 && dpf != 15) fprintf(stderr, "INDIV - ");
|
||||
|
||||
if (dpf == 0) fprintf (stderr, "Unified Data Transport (UDT) ");
|
||||
else if (dpf == 1) fprintf (stderr, "Response Packet ");
|
||||
else if (dpf == 2) fprintf (stderr, "Unconfirmed Delivery ");
|
||||
else if (dpf == 3) fprintf (stderr, "Confirmed Delivery ");
|
||||
else if (dpf == 13) fprintf (stderr, "Short Data: Defined ");
|
||||
else if (dpf == 14) fprintf (stderr, "Short Data: Raw or S/P ");
|
||||
else if (dpf == 15) fprintf (stderr, "Proprietary Packet Data");
|
||||
else fprintf (stderr, "Reserved/Unknown DPF %X ", dpf);
|
||||
|
||||
if (a == 1 && dpf != 15) fprintf(stderr, "- Response Requested ");
|
||||
if (dpf != 15) fprintf (stderr, "- Source: %d Target: %d ", source, target);
|
||||
|
||||
//sap string handling
|
||||
if (dpf == 15) sap = p_sap;
|
||||
|
||||
if (sap == 0) sprintf (sap_string, "%s", "UDT Data"); //apparently, both dpf and sap for UDT is 0
|
||||
else if (sap == 2) sprintf (sap_string, "%s", "TCP Comp"); //TCP/IP header compression
|
||||
else if (sap == 3) sprintf (sap_string, "%s", "UDP Comp"); //UDP/IP header compression
|
||||
else if (sap == 4) sprintf (sap_string, "%s", "IP Based"); //IP based Packet Data
|
||||
else if (sap == 5) sprintf (sap_string, "%s", "ARP Prot"); //Address Resoution Protocol (ARP)
|
||||
else if (sap == 9) sprintf (sap_string, "%s", "Prop PDU"); //Proprietary Packet Data
|
||||
else if (sap == 10) sprintf (sap_string, "%s", "Short DT"); //Short Data
|
||||
else sprintf (sap_string, "%s", "Reserved"); //reserved, or err/unk
|
||||
|
||||
//mfid string handling
|
||||
if (dpf == 15)
|
||||
{
|
||||
state->data_conf_data[slot] = 0; //flag as unconfirmed data, no need for additional CRC/Serial checks
|
||||
state->data_header_padding[slot] = dheader[1] & 0xF; //number of padding octets on last block
|
||||
state->data_header_blocks[slot] = dheader[8] & 0x7F; //number of blocks to follow, most useful for when to poll the super array for data
|
||||
fprintf (stderr, "\n Unconfirmed Data Header: DPF %01X - SAP %02X - Block Count %02X - Padding Octets %02X",
|
||||
state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
|
||||
state->data_header_blocks[slot], state->data_header_padding[slot] );
|
||||
if (p_mfid == 0x10) sprintf (mfid_string, "%s", "Motorola");
|
||||
else if (p_mfid == 0x58) sprintf (mfid_string, "%s", "Tait ");
|
||||
else if (p_mfid == 0x68) sprintf (mfid_string, "%s", "Hytera ");
|
||||
else if (p_mfid == 0x08) sprintf (mfid_string, "%s", "Hytera ");
|
||||
else if (p_mfid == 0x06) sprintf (mfid_string, "%s", "Trid/Mot");
|
||||
else if (p_mfid == 0x00) sprintf (mfid_string, "%s", "Standard");
|
||||
else sprintf (mfid_string, "%s", "Other ");
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0x3)
|
||||
//udt format string handling
|
||||
if (dpf == 0)
|
||||
{
|
||||
state->data_conf_data[slot] = 1; //set flag to indicate the following blocks are confirmed data so we know to run additional CRC etc on it.
|
||||
state->data_header_padding[slot] = dheader[1] & 0xF; //number of padding octets on last block
|
||||
state->data_header_blocks[slot] = dheader[8] & 0x7F; //number of blocks to follow, most useful for when to poll the super array for data
|
||||
fprintf (stderr, "\n Confirmed Data Header: DPF %01X - SAP %02X - Block Count %02X - Padding Octets %02X",
|
||||
state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
|
||||
state->data_header_blocks[slot], state->data_header_padding[slot] );
|
||||
if (udt_format == 0x00) sprintf (udtf_string, "%s", "Binary");
|
||||
else if (udt_format == 0x01) sprintf (udtf_string, "%s", "MS/TG Adr");
|
||||
else if (udt_format == 0x02) sprintf (udtf_string, "%s", "4-bit BCD");
|
||||
else if (udt_format == 0x03) sprintf (udtf_string, "%s", "ISO7 Char");
|
||||
else if (udt_format == 0x04) sprintf (udtf_string, "%s", "ISO8 Char");
|
||||
else if (udt_format == 0x05) sprintf (udtf_string, "%s", "NMEA LOCN");
|
||||
else if (udt_format == 0x06) sprintf (udtf_string, "%s", "IP Addr");
|
||||
else if (udt_format == 0x07) sprintf (udtf_string, "%s", "UTF-16"); //16-bit Unicode Chars
|
||||
else if (udt_format == 0x08) sprintf (udtf_string, "%s", "Manu Spec"); //Manufacturer Specific
|
||||
else if (udt_format == 0x09) sprintf (udtf_string, "%s", "Manu Spec"); //Manufacturer Specific
|
||||
else if (udt_format == 0x0A) sprintf (udtf_string, "%s", "Mixed UTF"); //Appended block contains addr and 16-bit UTF-16BE
|
||||
else sprintf (udtf_string, "%s", "Reserved");
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0xD) //DD_HEAD
|
||||
//short data dd_head format string
|
||||
if (dpf == 13)
|
||||
{
|
||||
//The Response Requested (A) information element of the header shall be set to 0 for unconfirmed data and shall be set
|
||||
//to 1 for confirmed data. ETSI TS 102 361-3 V1.2.1 (2013-07) - 6.1.2
|
||||
if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
|
||||
if (dd_format == 0x00) sprintf (sddd_string, "%s", "Binary");
|
||||
else if (dd_format == 0x01) sprintf (sddd_string, "%s", "BCD ");
|
||||
else if (dd_format == 0x02) sprintf (sddd_string, "%s", "7-bit Char");
|
||||
else if (dd_format == 0x03) sprintf (sddd_string, "%s", "IEC 8859-1");
|
||||
else if (dd_format == 0x04) sprintf (sddd_string, "%s", "IEC 8859-2");
|
||||
else if (dd_format == 0x05) sprintf (sddd_string, "%s", "IEC 8859-3");
|
||||
else if (dd_format == 0x06) sprintf (sddd_string, "%s", "IEC 8859-4");
|
||||
else if (dd_format == 0x07) sprintf (sddd_string, "%s", "IEC 8859-5");
|
||||
else if (dd_format == 0x08) sprintf (sddd_string, "%s", "IEC 8859-6");
|
||||
else if (dd_format == 0x09) sprintf (sddd_string, "%s", "IEC 8859-7");
|
||||
else if (dd_format == 0x0A) sprintf (sddd_string, "%s", "IEC 8859-8");
|
||||
else if (dd_format == 0x0B) sprintf (sddd_string, "%s", "IEC 8859-9");
|
||||
else if (dd_format == 0x0C) sprintf (sddd_string, "%s", "IEC 8859-10");
|
||||
else if (dd_format == 0x0D) sprintf (sddd_string, "%s", "IEC 8859-11");
|
||||
else if (dd_format == 0x0E) sprintf (sddd_string, "%s", "IEC 8859-13"); //there is no 8059-12
|
||||
else if (dd_format == 0x0F) sprintf (sddd_string, "%s", "IEC 8859-14");
|
||||
else if (dd_format == 0x10) sprintf (sddd_string, "%s", "IEC 8859-15");
|
||||
else if (dd_format == 0x11) sprintf (sddd_string, "%s", "IEC 8859-16");
|
||||
else if (dd_format == 0x12) sprintf (sddd_string, "%s", "UTF-8 ");
|
||||
else if (dd_format == 0x13) sprintf (sddd_string, "%s", "UTF-16 ");
|
||||
else if (dd_format == 0x14) sprintf (sddd_string, "%s", "UTF-16BE");
|
||||
else if (dd_format == 0x15) sprintf (sddd_string, "%s", "UTF-16LE");
|
||||
else if (dd_format == 0x16) sprintf (sddd_string, "%s", "UTF-32 ");
|
||||
else if (dd_format == 0x17) sprintf (sddd_string, "%s", "UTF-32BE");
|
||||
else if (dd_format == 0x18) sprintf (sddd_string, "%s", "UTF-32LE");
|
||||
else sprintf (sddd_string, "%s", "Reserved");
|
||||
}
|
||||
|
||||
if (dpf == 0) //UDT
|
||||
{
|
||||
//UDT packet info -- samples needed for testing
|
||||
//NOTE: This format's completed message has a CRC16 - like MBC - but has number of blocks (appended blocks) like R 1/2, etc.
|
||||
fprintf (stderr, "\n SAP %02X [%s] - FMT %d [%s] - PDn %d - BLOCKS %d SF %d - PF %d OP %02X", sap, sap_string, udt_format, udtf_string, udt_padnib, udt_uab, udt_sf, udt_pf, udt_op);
|
||||
|
||||
//set number of blocks to follow (appended blocks) for block assembler
|
||||
state->data_header_blocks[slot] = udt_uab;
|
||||
|
||||
//set data header to valid
|
||||
state->data_header_valid[slot] = 1;
|
||||
|
||||
//send to assembler as type 3, rearrange into CSBK type PDU (to verify), and send to dmr_cspdu
|
||||
dmr_block_assembler (opts, state, dheader, 12, 0x0B, 3);
|
||||
|
||||
}
|
||||
|
||||
if (dpf == 1) //response data packet header
|
||||
{
|
||||
//mostly fleshed out response packet info
|
||||
fprintf (stderr, "\n SAP %02X [%s] - Class %d - Type %0d - ", sap, sap_string, r_class, r_type);
|
||||
if (r_class == 0 && r_type == 1) fprintf (stderr, "ACK - Success");
|
||||
if (r_class == 1)
|
||||
{
|
||||
state->data_conf_data[slot] = 1;
|
||||
fprintf (stderr, "NACK - ");
|
||||
if (r_type == 0) fprintf (stderr, "Illegal Format");
|
||||
if (r_type == 1) fprintf (stderr, "Illegal Format");
|
||||
if (r_type == 2) fprintf (stderr, "Packet CRC ERR");
|
||||
if (r_type == 3) fprintf (stderr, "Memory Full");
|
||||
if (r_type == 4) fprintf (stderr, "FSN Out of Seq");
|
||||
if (r_type == 5) fprintf (stderr, "Undeliverable");
|
||||
if (r_type == 6) fprintf (stderr, "PKT Out of Seq");
|
||||
if (r_type == 7) fprintf (stderr, "Invalid User");
|
||||
}
|
||||
else state->data_conf_data[slot] = 0;
|
||||
if (r_class == 2) fprintf (stderr, "SACK - Retry");
|
||||
if (r_status) fprintf (stderr, " - %d", r_status); //the object/value of the ack/nack/sack
|
||||
|
||||
state->data_header_padding[slot] = dheader[7] & 0xF;
|
||||
state->data_header_blocks[slot] = ( (dheader[0] & 0x30) | ((dheader[1] & 0xF) >> 0) ); //what a pain MSB | LSB
|
||||
fprintf (stderr, "\n Short Data - Defined: DPF %01X - SAP %02X - Appended Blocks %02X - Padding Bits %02X",
|
||||
state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
|
||||
state->data_header_blocks[slot], state->data_header_padding[slot] );
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0xE) //SP_HEAD or R_HEAD
|
||||
//Confirmed or Unconfirmed Data Packets Header
|
||||
if (dpf == 2 || dpf == 3)
|
||||
{
|
||||
//The Response Requested (A) information element of the header shall be set to 0 for unconfirmed data and shall be set
|
||||
//to 1 for confirmed data. ETSI TS 102 361-3 V1.2.1 (2013-07) - 6.2.2
|
||||
if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
|
||||
if (dpf == 2) fprintf (stderr, "\n SAP %02X [%s] - FMF %d - BLOCKS %02d - PAD %02d - FSN %d", sap, sap_string, f, bf, poc, fsn);
|
||||
if (dpf == 3) fprintf (stderr, "\n SAP %02X [%s] - FMF %d - BLOCKS %02d - PAD %02d - S %d - NS %d - FSN %d", sap, sap_string, f, bf, poc, s, ns, fsn);
|
||||
state->data_header_blocks[slot] = bf;
|
||||
if (dpf == 3) state->data_conf_data[slot] = 1; //set confirmed data delivery flag for additional CRC checks, block assembly, etc.
|
||||
|
||||
}
|
||||
|
||||
//Short Data DD_Head (13), and R_Head or SP_Head (14)
|
||||
if (dpf == 13 || dpf == 14)
|
||||
{
|
||||
//only set if not all zeroes
|
||||
if (s_ab_fin) state->data_header_blocks[slot] = s_ab_fin;
|
||||
|
||||
//Short Data: Defined
|
||||
if (dpf == 13) fprintf (stderr, "\n SD:D [DD_HEAD] - SAP %02d [%s] - BLOCKS %02d - DD %02X - PADb %d - FMT %02X [%s]", sap, sap_string, s_ab_fin, dd_format, sd_bp, dd_format, sddd_string);
|
||||
//Short Data: Raw or S/P
|
||||
if (dpf == 14)
|
||||
{
|
||||
state->data_conf_data[slot] = 1;
|
||||
//S/P has all appended block bits set to zero -- any other way to tell difference?
|
||||
if (s_ab_fin == 0) fprintf (stderr, "\n SD:S/P [SP_HEAD] - SAP %02d [%s] - SP %02d - DP %02d - S/P %02X", sap, sap_string, s_source_port, s_dest_port, s_status_precoded);
|
||||
|
||||
//Raw
|
||||
else fprintf (stderr, "\n SD:RAW [R_HEAD] - SAP %02d [%s] - BLOCKS %02d - SP %02d - DP %02d - SARQ %d - FMF %d - PDb %d", sap, sap_string, s_ab_fin, s_source_port, s_dest_port, sd_sarq, sd_f, sd_bp);
|
||||
}
|
||||
else state->data_conf_data[slot] = 0;
|
||||
|
||||
state->data_header_padding[slot] = dheader[7] & 0xF;
|
||||
state->data_header_blocks[slot] = ( (dheader[0] & 0x30) | ((dheader[1] & 0xF) >> 0) );
|
||||
fprintf (stderr, "\n Short Data - Raw or Precoded: DPF %01X - SAP %02X - Appended Blocks %02X - Padding Bits %02X",
|
||||
state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
|
||||
state->data_header_blocks[slot], state->data_header_padding[slot] );
|
||||
//6.2.2 The Response Requested (A) information element of the header shall be set to 0
|
||||
//for unconfirmed data and shall be set to 1 for confirmed data. DD_HEAD, R_HEAD, or SP_HEAD (double check)
|
||||
if (a == 1)
|
||||
{
|
||||
state->data_conf_data[slot] = 1;
|
||||
fprintf (stderr, " - Confirmed Data");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
//do we still need this? since we have ample PDU storage
|
||||
if (state->data_header_blocks[slot] > 7)
|
||||
{
|
||||
state->data_header_blocks[slot] = 7;
|
||||
}
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
//end collecting data header info
|
||||
|
||||
fprintf (stderr, "%s ", KYEL);
|
||||
|
||||
if (state->data_header_sap[slot] == 0x4 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n IP Data - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
|
||||
|
||||
//Remus! Uncomment these line
|
||||
// if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "IP DATA SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
|
||||
}
|
||||
|
||||
if (state->data_header_sap[slot] == 0x0 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n Unified Data Transport - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
|
||||
|
||||
//Remus! Uncomment these line
|
||||
// if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "UDT SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
|
||||
}
|
||||
|
||||
if (state->data_header_sap[slot] == 0x9 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n Proprietary Packet Data - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
|
||||
|
||||
//Remus! Uncomment this line
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "P_HEAD SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
|
||||
}
|
||||
|
||||
if (state->data_header_sap[slot] == 0x2 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n TCP/IP Header Compression Data - Source: ");
|
||||
fprintf (stderr, "[%d]", dheader[3]);
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", dheader[2]);
|
||||
|
||||
state->dmr_lrrp_source[slot] = dheader[3];
|
||||
|
||||
//Remus! Uncomment these line
|
||||
// if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "IPC SRC [%d] DST [%d] ", dheader[3], dheader[2]);
|
||||
|
||||
}
|
||||
|
||||
if (state->data_header_sap[slot] == 0x3 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n UDP/IP Header Compression Data - Source: ");
|
||||
fprintf (stderr, "[%d]", dheader[3]);
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", dheader[2]);
|
||||
|
||||
state->dmr_lrrp_source[slot] = dheader[3];
|
||||
|
||||
//Remus! Uncomment these line
|
||||
// if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "UDP SRC [%d] DST [%d] ", dheader[3], dheader[2]);
|
||||
|
||||
}
|
||||
|
||||
if (state->data_header_sap[slot] == 0x5 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n ARP - Address Resolution Protocol ");
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF ) == 0xD && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n Short Data - Defined - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
//Remus! Uncomment this line
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "SD-D SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0xE && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n Short Data - Raw or Status/Precoded - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
//Remus! Uncomment this line
|
||||
// sprintf (state->dmr_lrrp_gps[slot], "SD-R/P SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
|
||||
}
|
||||
|
||||
if ( (state->data_header_format[slot] & 0xF ) == 0x1 && state->data_p_head[slot] == 0)
|
||||
{
|
||||
fprintf (stderr, "\n Response Packet - Source: ");
|
||||
fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
|
||||
fprintf (stderr, " Destination: ");
|
||||
fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
|
||||
|
||||
//Remus! Uncomment these lines
|
||||
// char rsp[90];
|
||||
// sprintf (rsp, " - RSP SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
|
||||
// strcat (state->dmr_lrrp_gps[slot], rsp);
|
||||
|
||||
}
|
||||
|
||||
//Removed Dup UDT Message
|
||||
|
||||
if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
|
||||
{
|
||||
fprintf (stderr, "\n Response Requested - ");
|
||||
fprintf (stderr, " Source:");
|
||||
fprintf (stderr, " [%d]", (dheader[2] <<16 ) + (dheader[3] << 8) + dheader[4] );
|
||||
fprintf (stderr, " Destination:");
|
||||
fprintf (stderr, " [%d]", (dheader[5] <<16 ) + (dheader[6] <<8 ) + dheader[7] );
|
||||
|
||||
//Remus! Uncomment these lines
|
||||
// char rsp[90];
|
||||
// sprintf (rsp, "- RSP REQ ");
|
||||
// strcat (state->dmr_lrrp_gps[slot], rsp);
|
||||
|
||||
}
|
||||
|
||||
//if proprietary header was flagged by the last data header, then process data differently
|
||||
if (state->data_p_head[slot] == 1)
|
||||
{
|
||||
fprintf (stderr, "\n Proprietary Data Header: SAP %01X - Format %01X - MFID %02X",
|
||||
(dheader[0] & 0xF0) >> 4, dheader[0] & 0xF, dheader[1] );
|
||||
|
||||
//state->data_p_head[slot] = 0; //disabling this, we can flag it off after processing pdu instead
|
||||
state->data_header_sap[slot] = 0; //reset this to zero so we don't trip the condition below
|
||||
state->data_block_counter[slot]++; //increment the counter since this counts against the data blocks
|
||||
|
||||
//set overarching manufacturer in use when non-standard feature id set is up
|
||||
//if (dheader[1] != 0) state->dmr_mfid = dheader[1]; //diable, will only set in link control or csbk for now (random manufacturers getting set, bad decode? or random feature?)
|
||||
|
||||
//assign prop header pdu to 'superframe'
|
||||
uint8_t blocks = state->data_header_blocks[slot] - 1;
|
||||
for(i = 0; i < 12; i++)
|
||||
|
||||
//Proprietary Data Header
|
||||
if (dpf == 15)
|
||||
{
|
||||
state->dmr_pdu_sf[slot][i+(blocks*12)] = dheader[i];
|
||||
fprintf (stderr, " - P_SAP %02d [%s] - MFID %02X [%s]", p_sap, sap_string, p_mfid, mfid_string);
|
||||
|
||||
//look for LRRP potential report 0x1F (may be others as well)
|
||||
//this could just be a sap == 1, which is 'reserved', unsure (or maybe no actual correlation?)
|
||||
if (p_sap != 1) state->data_header_blocks[slot]--; //decrement the blocks to follow count in order to pass CRC32 and properly assemble blocks
|
||||
else //add block to start of the dmr_pdu_sf since it probably contains vital LRRP data (0x1F report) -- won't pass CRC32 either way
|
||||
{
|
||||
int blocks = state->data_header_blocks[slot]-1;
|
||||
if (blocks < 1) blocks = 4; //safety value
|
||||
if (blocks > 9) blocks = 9;
|
||||
for(i = 0; i < 12; i++) state->dmr_pdu_sf[slot][i+(blocks*12)] = dheader[i];
|
||||
state->data_block_counter[slot]++;
|
||||
//no matter how you assemble this, with or without the p_head block(s), there is ALWAYS a CRC32 Failure
|
||||
//even when it continues to pass on other SAP values, SAP 1 must have a different checksum?
|
||||
//Users trying to get this will want to enable -F to bypass the CRC32 failure
|
||||
|
||||
//a recent discovery on a few systems and samples show the existence of multiple Prop Head Packets (how does that work)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//only set this flag after everything else is processed
|
||||
if (state->data_header_sap[slot] == 0x9 && state->data_p_head[slot] == 0)
|
||||
//block storage sanity
|
||||
if (state->data_header_blocks[slot] > 9) state->data_header_blocks[slot] = 9;
|
||||
//assuming we didn't receive the initial data header block on a p_head and then decremented it
|
||||
//3 or 4 seems to be the average safe value
|
||||
if (state->data_header_blocks[slot] < 1) state->data_header_blocks[slot] = 4;
|
||||
//set data header validity unless its a p_head (should be set prior, if received)
|
||||
if (dpf != 15) state->data_header_valid[slot] = 1;
|
||||
|
||||
//REMUS! Uncomment these lines if desired
|
||||
if (dpf != 15 && dpf != 1)
|
||||
{
|
||||
sprintf (state->dmr_lrrp_gps[slot], "Data Call - %s SRC [%d] DST [%d] ", sap_string, source, target);
|
||||
if (a == 1) strcat (state->dmr_lrrp_gps[slot], "- RSP REQ ");
|
||||
}
|
||||
|
||||
//REMUS! Uncomment these lines if desired -- if the data request data header is missing, though, this may keep accumulating
|
||||
// if (dpf == 1)
|
||||
// {
|
||||
// strcat (state->dmr_lrrp_gps[slot], "- RSP ");
|
||||
// if (r_class == 0) strcat (state->dmr_lrrp_gps[slot], "ACK - RX OK");
|
||||
// if (r_class == 1) strcat (state->dmr_lrrp_gps[slot], "NACK - RX ERR");
|
||||
// if (r_class == 2) strcat (state->dmr_lrrp_gps[slot], "SACK - RETRY");
|
||||
|
||||
// }
|
||||
//End REMUS Data string
|
||||
|
||||
//store SAP value
|
||||
state->data_header_sap[slot] = sap;
|
||||
|
||||
} //End Irrecoverable Errors
|
||||
|
||||
if (IrrecoverableErrors != 0)
|
||||
{
|
||||
fprintf (stderr, "\n Proprietary Packet Data Incoming ");
|
||||
state->data_p_head[slot] = 1; //flag that next data header will be a proprietary data header
|
||||
state->data_header_valid[slot] = 0;
|
||||
sprintf (state->dmr_lrrp_gps[slot], "%s", "");
|
||||
state->data_p_head[slot] = 0;
|
||||
state->data_conf_data[slot] = 0;
|
||||
state->data_block_counter[slot] = 1;
|
||||
state->data_header_blocks[slot] = 1;
|
||||
|
||||
}
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
|
||||
//let user know the data header may have errors
|
||||
// fprintf (stderr, "%s", KRED);
|
||||
// if (CRCCorrect == 1) ; //CRCCorrect 1 is good, else is bad CRC; no print on good
|
||||
// else if(IrrecoverableErrors == 0) fprintf(stderr, " (FEC OK)");
|
||||
// else fprintf(stderr, " (FEC/CRC ERR)");
|
||||
// fprintf (stderr, "%s", KNRM);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
}
|
||||
|
||||
//convert UDT to a CSBK friendly PDU format
|
||||
void dmr_udt_cspdu_converter (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
//rearrange UDT data to a CSBK message format
|
||||
uint8_t cs_byte[48]; //12 x 4, 2 bit AB should mean only 3 total appended blocks, so 4 all together (minus rearrangement)
|
||||
memset (cs_byte, 0, sizeof (cs_byte));
|
||||
uint8_t cs_bits[48*8];
|
||||
memset (cs_bits, 0, sizeof (cs_bits));
|
||||
|
||||
cs_byte[0] = (uint8_t)ConvertBitIntoBytes(&block_bits[73], 7); //lb, pf and opcode byte
|
||||
uint8_t udt_opcode = (uint8_t)ConvertBitIntoBytes(&block_bits[74], 6); //for observation testing
|
||||
cs_byte[1] = 0; //set mfid to zero for now (may use custom value if needed later)
|
||||
uint8_t udt_mfid = 0; //setting to zero
|
||||
|
||||
//should be 34 total (maximum) after removing tailing CRC16 (initial and last block)
|
||||
for (i = 0; i < 34; i++) cs_byte[2+i] = block_bytes[12+i];
|
||||
|
||||
//bytes to bits
|
||||
for(i = 0, j = 0; i < 36; i++, j+=8) //4 blocks max?
|
||||
{
|
||||
cs_bits[j + 0] = (cs_byte[i] >> 7) & 0x01;
|
||||
cs_bits[j + 1] = (cs_byte[i] >> 6) & 0x01;
|
||||
cs_bits[j + 2] = (cs_byte[i] >> 5) & 0x01;
|
||||
cs_bits[j + 3] = (cs_byte[i] >> 4) & 0x01;
|
||||
cs_bits[j + 4] = (cs_byte[i] >> 3) & 0x01;
|
||||
cs_bits[j + 5] = (cs_byte[i] >> 2) & 0x01;
|
||||
cs_bits[j + 6] = (cs_byte[i] >> 1) & 0x01;
|
||||
cs_bits[j + 7] = (cs_byte[i] >> 0) & 0x01;
|
||||
}
|
||||
|
||||
dmr_cspdu (opts, state, cs_bits, cs_byte, CRCCorrect, IrrecoverableErrors);
|
||||
|
||||
}
|
||||
|
||||
//assemble the blocks as they come in, shuffle them into the unified dmr_pdu_sf
|
||||
void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_len, uint8_t databurst, uint8_t type)
|
||||
{
|
||||
int i, j, k;
|
||||
uint8_t lb = 0; //mbc last block
|
||||
uint8_t pf = 0; //mbc protect flag
|
||||
// uint8_t is_conf_data = 0; //internal flag to see if type 1 blocks contain confirmed data crcs and serials
|
||||
|
||||
uint8_t slot = state->currentslot;
|
||||
int blocks;
|
||||
uint8_t blockcounter = state->data_block_counter[slot];
|
||||
uint8_t block_num = state->data_header_blocks[slot];
|
||||
|
||||
//crc specific variables
|
||||
// uint8_t len = 24;
|
||||
// uint8_t crclen = 32; //len of the crc32 (obviously)
|
||||
// uint8_t start = 12; //starting position (+12 offset loaded up data header)
|
||||
// uint8_t n = 12; //number of bytes per block
|
||||
|
||||
//TODO: CRC check on Header, Blocks and full frames as appropriate
|
||||
uint32_t CRCCorrect = 0;
|
||||
uint32_t CRCComputed = 0;
|
||||
uint32_t CRCExtracted = 0;
|
||||
@@ -302,20 +393,27 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
if (type == 1) blocks = state->data_header_blocks[slot] - 1;
|
||||
if (type == 2) blocks = state->data_block_counter[slot];
|
||||
|
||||
//UDT Header and Block Check
|
||||
uint8_t is_udt = 0;
|
||||
if (type == 3)
|
||||
{
|
||||
blocks = state->data_block_counter[slot];
|
||||
is_udt = 1;
|
||||
type = 2;
|
||||
}
|
||||
|
||||
//sanity check, setting block_len and block values to sane numbers in case of missing header, else could overload array (crash) or print out
|
||||
if (blocks < 1) blocks = 1; //changed blocks from uint8_t to int
|
||||
if (blocks > 8) blocks = 8;
|
||||
if (blocks > 9) blocks = 9;
|
||||
if (block_len == 0) block_len = 18;
|
||||
if (block_len > 24) block_len = 24;
|
||||
|
||||
//WIP: CRC32 on Completed Message Working! CRC9 on 3/4 Working! CRC9 or 1/2 and 1 still need testing - type 1
|
||||
//may/will still fail on p_head data and blocks
|
||||
if (type == 1)
|
||||
{
|
||||
//type 1 data block, shuffle method
|
||||
for (j = 0; j < blocks; j++) //6
|
||||
for (j = 0; j < blocks; j++)
|
||||
{
|
||||
for (i = 0; i < block_len; i++) //block_len
|
||||
for (i = 0; i < block_len; i++)
|
||||
{
|
||||
state->dmr_pdu_sf[slot][i+block_len*j] = state->dmr_pdu_sf[slot][i+block_len*(j+1)];
|
||||
}
|
||||
@@ -325,8 +423,9 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
{
|
||||
state->dmr_pdu_sf[slot][i+(blocks*block_len)] = block_bytes[i];
|
||||
}
|
||||
|
||||
//time to send the completed 'superframe' to the DMR PDU message handler
|
||||
if (state->data_block_counter[slot] == state->data_header_blocks[slot])
|
||||
if (state->data_block_counter[slot] == state->data_header_blocks[slot] && state->data_header_valid[slot] == 1)
|
||||
{
|
||||
//CRC32 on completed messages
|
||||
for(i = 0, j = 0; i < (block_num * block_len); i++, j+=8)
|
||||
@@ -388,28 +487,77 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
//individual CRC9s are correct on confirmed data blocks (but we can confirm now that they are all good)
|
||||
if (CRCComputed == CRCExtracted) CRCCorrect = 1;
|
||||
|
||||
//test only running on good CRC or CRC/RAS bypass (aggressive_framesync)
|
||||
if (CRCCorrect || opts->aggressive_framesync == 0) dmr_pdu (opts, state, block_len, state->dmr_pdu_sf[slot]);
|
||||
//only run on good CRC or CRC/RAS bypass (aggressive_framesync == 0)
|
||||
if (CRCCorrect || opts->aggressive_framesync == 0)
|
||||
dmr_pdu (opts, state, block_len, state->dmr_pdu_sf[slot]);
|
||||
|
||||
if (CRCCorrect) ; //print nothing
|
||||
else
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf (stderr, "\n Slot %d - Multi Block PDU Message CRC32 ERR", slot+1);
|
||||
|
||||
//debug print
|
||||
// fprintf (stderr, " %X - %X", CRCExtracted, CRCComputed);
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
state->data_conf_data[slot] = 0; //flag off conf data flag
|
||||
state->data_header_format[slot] = 0; //zero out so we don't keep ascii printing
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Full Super Frame Type 1 - Payload Output
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf (stderr, "\n Slot %d - Multi Block PDU Message\n ", slot+1);
|
||||
for (i = 0; i < ((blocks+1)*block_len); i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
|
||||
if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95)
|
||||
{
|
||||
fprintf (stderr, "\n ");
|
||||
}
|
||||
}
|
||||
|
||||
//debug print
|
||||
// fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
|
||||
|
||||
if (state->data_header_format[slot] == 13 || state->data_header_format[slot] == 14 || state->data_header_sap[slot] == 10)
|
||||
{
|
||||
fprintf (stderr, "%s", KCYN);
|
||||
fprintf (stderr, "\n Short Data: ASCII \n" );
|
||||
for (i = 0; i < ((blocks+1)*block_len); i++)
|
||||
{
|
||||
if (state->dmr_pdu_sf[slot][i] <= 0x7E && state->dmr_pdu_sf[slot][i] >=0x20)
|
||||
{
|
||||
fprintf (stderr, "%c", state->dmr_pdu_sf[slot][i]);
|
||||
}
|
||||
else fprintf (stderr, " ");
|
||||
|
||||
if (i == 47 || i == 95) fprintf (stderr, "\n ");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
|
||||
//reset data header format storage
|
||||
state->data_header_format[slot] = 7;
|
||||
//flag off data header validity
|
||||
state->data_header_valid[slot] = 0;
|
||||
//flag off conf data flag
|
||||
state->data_conf_data[slot] = 0;
|
||||
|
||||
} //end completed sf
|
||||
|
||||
} //end type 1 blocks
|
||||
|
||||
|
||||
//type 2 - MBC header and MBC continuation blocks
|
||||
//type 2 - MBC and UDT header, MBC and UDT continuation blocks
|
||||
if (type == 2)
|
||||
{
|
||||
//sanity check (marginal signal, bad decodes, etc)
|
||||
if (state->data_block_counter[slot] > 8) state->data_block_counter[slot] = 8;
|
||||
//sanity check (marginal signal, bad decodes, etc) -- may go a little lower (find out max number of MBC blocks supported)
|
||||
if (state->data_block_counter[slot] > 4) state->data_block_counter[slot] = 4;
|
||||
|
||||
//Type 2 data block, additive method
|
||||
for (i = 0; i < block_len; i++)
|
||||
@@ -422,9 +570,17 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
lb = block_bytes[0] >> 7; //last block flag
|
||||
pf = (block_bytes[0] >> 6) & 1;
|
||||
|
||||
if (lb == 1) //last block arrived, time to send to cspdu decoder
|
||||
if (is_udt)
|
||||
{
|
||||
for(i = 0, j = 0; i < 12*4; i++, j+=8) //
|
||||
blocks = state->data_header_blocks[slot];
|
||||
if (blocks == blockcounter) lb = 1; //double check
|
||||
pf = 0; //flag off is set from bit in error
|
||||
}
|
||||
|
||||
//last block arrived and we have a valid data header, time to send to cspdu decoder
|
||||
if (lb == 1 && state->data_header_valid[slot] == 1)
|
||||
{
|
||||
for(i = 0, j = 0; i < 12*4; i++, j+=8) //4 blocks max?
|
||||
{
|
||||
dmr_pdu_sf_bits[j + 0] = (state->dmr_pdu_sf[slot][i] >> 7) & 0x01;
|
||||
dmr_pdu_sf_bits[j + 1] = (state->dmr_pdu_sf[slot][i] >> 6) & 0x01;
|
||||
@@ -436,10 +592,13 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
dmr_pdu_sf_bits[j + 7] = (state->dmr_pdu_sf[slot][i] >> 0) & 0x01;
|
||||
}
|
||||
|
||||
//check UDT PF
|
||||
if (is_udt) pf = dmr_pdu_sf_bits[73];
|
||||
|
||||
//CRC check on Header and full frames as appropriate (header crc already stored)
|
||||
//The 16 bit CRC in the header shall include the data carried by the header.
|
||||
//The 16 bit CRC in the last block shall be performed on
|
||||
//all MBC blocks (conmbined) except the header block. <-- misleading statement, just like half the dmr manual
|
||||
//all MBC blocks (conmbined) except the header block.
|
||||
|
||||
mbc_crc_good[0] = state->data_block_crc_valid[slot][0];
|
||||
|
||||
@@ -454,15 +613,13 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
uint8_t mbc_block_bits[12*8*3];
|
||||
memset (mbc_block_bits, 0, sizeof(mbc_block_bits));
|
||||
//shift continuation blocks and last block into seperate array for crc check
|
||||
for (i = 0; i < 12*8*3; i++)
|
||||
for (i = 0; i < 12*8*3; i++) //only doing 3 blocks (4 minus the header)
|
||||
{
|
||||
mbc_block_bits[i] = dmr_pdu_sf_bits[i+96]; //skip mbc header
|
||||
}
|
||||
|
||||
CRCComputed = ComputeCrcCCITT16d (mbc_block_bits, ((blocks+0)*96)-16 );
|
||||
|
||||
// fprintf (stderr, " \n CRC EXT %X CRC CMP %X", CRCExtracted, CRCComputed);
|
||||
|
||||
if (CRCComputed == CRCExtracted) mbc_crc_good[1] = 1;
|
||||
|
||||
CRCCorrect = 0;
|
||||
@@ -477,60 +634,51 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
else
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf(stderr, " (CRC ERR)");
|
||||
fprintf (stderr, "\n Slot %d - Multi Block Control Message CRC16 ERR", slot+1);
|
||||
|
||||
//debug print
|
||||
fprintf (stderr, " %X - %X", CRCExtracted, CRCComputed);
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
//cspdu will only act on any fid/opcodes if good CRC to prevent falsing on control signalling
|
||||
dmr_cspdu (opts, state, dmr_pdu_sf_bits, state->dmr_pdu_sf[slot], CRCCorrect, IrrecoverableErrors);
|
||||
if (!is_udt && !pf) dmr_cspdu (opts, state, dmr_pdu_sf_bits, state->dmr_pdu_sf[slot], CRCCorrect, IrrecoverableErrors);
|
||||
|
||||
}
|
||||
}
|
||||
//will need to reassemble partially before sending to dmr_pdu or dmr_cspdu for handling -- needs testing
|
||||
if (is_udt && !pf) dmr_udt_cspdu_converter (opts, state, state->dmr_pdu_sf[slot], dmr_pdu_sf_bits, CRCCorrect, IrrecoverableErrors);
|
||||
|
||||
//Full Super Frame Type 1 - Debug Output
|
||||
if (opts->payload == 1 && type == 1 && state->data_block_counter[slot] == state->data_header_blocks[slot])
|
||||
{
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf (stderr, "\n Slot %d - Multi Block PDU Message\n ", slot+1);
|
||||
for (i = 0; i < ((blocks+1)*block_len); i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
|
||||
if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95)
|
||||
//Full Super Frame MBC/UDT - Debug Output
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "\n ");
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf (stderr, "\n Slot %d - Multi Block Control Message\n ", slot+1);
|
||||
for (i = 0; i < ((blocks+1)*block_len); i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
|
||||
if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95)
|
||||
{
|
||||
fprintf (stderr, "\n ");
|
||||
}
|
||||
}
|
||||
fprintf (stderr, "%s", KRED);
|
||||
if (mbc_crc_good[0] == 0) fprintf (stderr, "MBC/UDT Header CRC ERR ");
|
||||
if (mbc_crc_good[1] == 0) fprintf (stderr, "MBC/UDT Blocks CRC ERR ");
|
||||
if (pf) fprintf (stderr, "MBC/UDT Header/Blocks Protected ");
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
}
|
||||
|
||||
//debug print
|
||||
// fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
|
||||
} //end last block flag on MBC
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
} //end type 2 (MBC Header and Continuation)
|
||||
|
||||
//Full Super Frame MBC - Debug Output
|
||||
if (opts->payload == 1 && type == 2 && lb == 1)
|
||||
//leave this seperate so we can reset/zero stuff in case the data header isn't valid, etc
|
||||
//switched to an if-elseif-else so we could get the block counter increment on the end
|
||||
//without having it in an akward position
|
||||
|
||||
//if the end of normal data header and blocks
|
||||
if (type == 1 && state->data_block_counter[slot] == state->data_header_blocks[slot])
|
||||
{
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf (stderr, "\n Slot %d - Multi Block Control Message\n ", slot+1);
|
||||
for (i = 0; i < ((blocks+1)*block_len); i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
|
||||
if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95)
|
||||
{
|
||||
fprintf (stderr, "\n ");
|
||||
}
|
||||
}
|
||||
fprintf (stderr, "%s", KRED);
|
||||
if (mbc_crc_good[0] == 0) fprintf (stderr, "MBC Header CRC ERR ");
|
||||
if (mbc_crc_good[1] == 0) fprintf (stderr, "MBC Blocks CRC ERR ");
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
|
||||
state->data_block_counter[slot]++; //increment block counter
|
||||
|
||||
if (type == 2 && lb == 1)
|
||||
{
|
||||
state->data_block_counter[slot] = 0; //reset the block counter (MBCs)
|
||||
|
||||
//clear out unified pdu 'superframe' slot
|
||||
for (short int i = 0; i < 288; i++)
|
||||
@@ -538,23 +686,65 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
|
||||
state->dmr_pdu_sf[slot][i] = 0;
|
||||
}
|
||||
|
||||
state->data_block_crc_valid[slot][0] = 0; //Zero Out MBC Header Block CRC Valid
|
||||
//Zero Out MBC Header Block CRC Valid
|
||||
state->data_block_crc_valid[slot][0] = 0;
|
||||
//reset the block counter (data blocks)
|
||||
state->data_block_counter[slot] = 1;
|
||||
//reset data header format storage
|
||||
state->data_header_format[slot] = 7;
|
||||
//flag off data header validity
|
||||
state->data_header_valid[slot] = 0;
|
||||
//flag off conf data flag
|
||||
state->data_conf_data[slot] = 0;
|
||||
|
||||
}
|
||||
|
||||
//else if the end of MBC Header and Blocks
|
||||
else if (type == 2 && lb == 1)
|
||||
{
|
||||
|
||||
//clear out unified pdu 'superframe' slot
|
||||
for (short int i = 0; i < 288; i++)
|
||||
{
|
||||
state->dmr_pdu_sf[slot][i] = 0;
|
||||
}
|
||||
|
||||
//Zero Out MBC Header Block CRC Valid
|
||||
state->data_block_crc_valid[slot][0] = 0;
|
||||
//reset the block counter (data blocks)
|
||||
state->data_block_counter[slot] = 1;
|
||||
//reset data header format storage
|
||||
state->data_header_format[slot] = 7;
|
||||
//flag off data header validity
|
||||
state->data_header_valid[slot] = 0;
|
||||
//flag off conf data flag
|
||||
state->data_conf_data[slot] = 0;
|
||||
|
||||
}
|
||||
|
||||
//else increment block counter after sorting/shuffling blocks
|
||||
else state->data_block_counter[slot]++;
|
||||
|
||||
}
|
||||
|
||||
//failsafe to clear old data header, block info, cach, in case of tact/emb/slottype failures and we
|
||||
//can no longer verify accurate data block reporting
|
||||
//failsafe to clear old data header, block info, cach, in case of tact/emb/slottype failures
|
||||
//or tuning away and we can no longer verify accurate data block reporting
|
||||
void dmr_reset_blocks (dsd_opts * opts, dsd_state * state)
|
||||
{
|
||||
memset (state->data_p_head, 0, sizeof(state->data_p_head));
|
||||
memset (state->data_conf_data, 0, sizeof(state->data_conf_data));
|
||||
memset (state->dmr_pdu_sf, 0, sizeof(state->dmr_pdu_sf));
|
||||
memset (state->data_block_counter, 0, sizeof(state->data_block_counter));
|
||||
memset (state->data_header_blocks, 0, sizeof(state->data_header_blocks));
|
||||
memset (state->data_block_counter, 1, sizeof(state->data_block_counter));
|
||||
memset (state->data_header_blocks, 1, sizeof(state->data_header_blocks));
|
||||
memset (state->data_block_crc_valid, 0, sizeof(state->data_block_crc_valid));
|
||||
memset (state->dmr_lrrp_source, 0, sizeof(state->dmr_lrrp_source));
|
||||
memset (state->dmr_cach_fragment, 1, sizeof (state->dmr_cach_fragment));
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
memset (state->data_header_valid, 0, sizeof(state->data_header_valid));
|
||||
memset (state->data_header_format, 7, sizeof(state->data_header_format));
|
||||
//reset some strings
|
||||
sprintf (state->call_string[0], "%s", " "); //21 spaces
|
||||
sprintf (state->call_string[1], "%s", " "); //21 spaces
|
||||
sprintf (state->dmr_lrrp_gps[0], "%s", "");
|
||||
sprintf (state->dmr_lrrp_gps[1], "%s", "");
|
||||
}
|
||||
45
src/dmr_bs.c
45
src/dmr_bs.c
@@ -114,13 +114,8 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
|
||||
//disabled for dmr_cach testing
|
||||
tact_okay = 0;
|
||||
if ( Hamming_7_4_decode (tact_bits) ) tact_okay = 1;
|
||||
if (tact_okay != 1)
|
||||
{
|
||||
if (opts->aggressive_framesync == 1)
|
||||
{
|
||||
goto END;
|
||||
}
|
||||
}
|
||||
if (tact_okay != 1) goto END;
|
||||
|
||||
|
||||
internalslot = state->currentslot = tact_bits[1];
|
||||
|
||||
@@ -478,18 +473,16 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
|
||||
fprintf (stderr, "| VOICE CACH/EMB ERR");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
fprintf (stderr, "\n");
|
||||
//run LFSR if either slot had an active MI in it.
|
||||
//run refresh if either slot had an active MI in it.
|
||||
if (state->payload_algid >= 0x21)
|
||||
{
|
||||
state->currentslot = 0;
|
||||
LFSR(state);
|
||||
fprintf (stderr, "\n");
|
||||
state->currentslot = 0;
|
||||
dmr_alg_refresh (opts, state);
|
||||
}
|
||||
if (state->payload_algidR >= 0x21)
|
||||
{
|
||||
state->currentslot = 1;
|
||||
LFSR(state);
|
||||
fprintf (stderr, "\n");
|
||||
state->currentslot = 1;
|
||||
dmr_alg_refresh (opts, state);
|
||||
}
|
||||
|
||||
//failsafe to reset all data header and blocks when bad tact or emb
|
||||
@@ -572,13 +565,7 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
//decode and correct tact and compare
|
||||
if ( Hamming_7_4_decode (tact_bits) ) tact_okay = 1;
|
||||
if (tact_okay != 1)
|
||||
{
|
||||
if (opts->aggressive_framesync == 1)
|
||||
{
|
||||
goto END;
|
||||
}
|
||||
}
|
||||
if (tact_okay != 1) goto END;
|
||||
|
||||
internalslot = state->currentslot = tact_bits[1];
|
||||
|
||||
@@ -636,11 +623,8 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
if ( strcmp (sync, DMR_BS_VOICE_SYNC) != 0)
|
||||
{
|
||||
if (opts->aggressive_framesync == 1)
|
||||
{
|
||||
sync_okay = 0;
|
||||
goto END;
|
||||
}
|
||||
sync_okay = 0;
|
||||
goto END;
|
||||
}
|
||||
|
||||
//Continue Second AMBE Frame, 18 after Sync or EmbeddedSignalling
|
||||
@@ -755,18 +739,17 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf (stderr, "| VOICE CACH/SYNC ERR");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
//run LFSR if either slot had an active MI in it.
|
||||
fprintf (stderr, "\n");
|
||||
//run refresh if either slot had an active MI in it.
|
||||
if (state->payload_algid >= 0x21)
|
||||
{
|
||||
state->currentslot = 0;
|
||||
LFSR(state);
|
||||
fprintf (stderr, "\n");
|
||||
dmr_alg_refresh (opts, state);
|
||||
}
|
||||
if (state->payload_algidR >= 0x21)
|
||||
{
|
||||
state->currentslot = 1;
|
||||
LFSR(state);
|
||||
fprintf (stderr, "\n");
|
||||
dmr_alg_refresh (opts, state);
|
||||
}
|
||||
|
||||
//failsafe to reset all data header and blocks when bad tact or emb
|
||||
|
||||
480
src/dmr_csbk.c
480
src/dmr_csbk.c
@@ -22,31 +22,33 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
int csbk_pf = 0;
|
||||
int csbk_o = 0;
|
||||
int csbk_fid = 0;
|
||||
uint64_t csbk_data = 0;
|
||||
int csbk = 0;
|
||||
|
||||
long int ccfreq = 0;
|
||||
|
||||
if(IrrecoverableErrors == 0 && CRCCorrect == 1)
|
||||
csbk_lb = ( (cs_pdu[0] & 0x80) >> 7 );
|
||||
csbk_pf = ( (cs_pdu[0] & 0x40) >> 6 );
|
||||
csbk_o = cs_pdu[0] & 0x3F;
|
||||
csbk_fid = cs_pdu[1]; //feature set id
|
||||
|
||||
//check, regardless of CRC err
|
||||
if (IrrecoverableErrors == 0)
|
||||
{
|
||||
|
||||
csbk_lb = ( (cs_pdu[0] & 0x80) >> 7 );
|
||||
csbk_pf = ( (cs_pdu[0] & 0x40) >> 6 );
|
||||
csbk_o = cs_pdu[0] & 0x3F;
|
||||
csbk_fid = cs_pdu[1]; //feature set id
|
||||
csbk_pf = ( (cs_pdu[1] & 0x80) >> 7);
|
||||
csbk = ((cs_pdu[0] & 0x3F) << 8) | cs_pdu[1]; //opcode and fid combo set
|
||||
|
||||
//update time to prevent random 'Control Channel Signal Lost' hopping
|
||||
//in the middle of voice call on current Control Channel (con+ and t3)
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
|
||||
//Hytera XPT CSBK Check -- if bits 0 and 1 are used as lcss, gi, ts, then this bit may be set on
|
||||
if ( csbk_fid == 0x68 && (csbk_o == 0x0A || csbk_o == 0x0B) ) csbk_pf = 0;
|
||||
if (csbk_pf == 1) //check the protect flag, don't run if set
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf (stderr, "\n Protected Control Signalling Block(s)");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
}
|
||||
|
||||
if(IrrecoverableErrors == 0 && CRCCorrect == 1)
|
||||
{
|
||||
|
||||
//update time to prevent random 'Control Channel Signal Lost' hopping
|
||||
//in the middle of voice call on current Control Channel (con+ and t3)
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
|
||||
if (csbk_pf == 0) //okay to run
|
||||
{
|
||||
@@ -209,6 +211,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
SetFreq(opts->rigctl_sockfd, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
}
|
||||
|
||||
//rtl_udp
|
||||
@@ -217,6 +220,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
rtl_udp_tune (opts, state, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1;
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
}
|
||||
|
||||
}
|
||||
@@ -624,7 +628,56 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
//experimental, but seems to be working well
|
||||
if (csbk_fid == 0x10)
|
||||
{
|
||||
//Cap+ Channel Status PDU
|
||||
|
||||
//Cap+ Something
|
||||
if (csbk_o == 0x3A)
|
||||
{
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
|
||||
fprintf (stderr, " Capacity Plus CSBK 0x3A ");
|
||||
|
||||
// 01:15:08 Sync: +DMR slot1 [slot2] | Color Code=03 | CSBK
|
||||
// Capacity Plus Channel Status - FL: 3 TS: 1 RS: 0 - Rest Channel 1 - Single Block
|
||||
// Ch1: Rest Ch2: Idle Ch3: Idle Ch4: Idle
|
||||
// Ch5: Idle Ch6: Idle Ch7: Idle Ch8: Idle
|
||||
// DMR PDU Payload [BE][10][E1][00][00][00][00][00][00][00][4E][15]
|
||||
// 01:15:08 Sync: +DMR [slot1] slot2 | Color Code=03 | CSBK
|
||||
|
||||
//FL, TS, and Rest Channel seem to be in same location as the Channel Status CSBK
|
||||
//other values are currently unknown
|
||||
// DMR PDU Payload [BA][10][C1][3B][61][11][51][00][00][00][3D][D6]
|
||||
// 01:15:08 Sync: +DMR slot1 [slot2] | Color Code=03 | CSBK
|
||||
// DMR PDU Payload [BA][10][E1][3B][61][11][51][00][00][00][46][BE]
|
||||
|
||||
}
|
||||
|
||||
//Cap+ Neighbors
|
||||
if (csbk_o == 0x3B)
|
||||
{
|
||||
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
|
||||
fprintf (stderr, " Capacity Plus Neighbor List ");
|
||||
|
||||
uint8_t nl[6]; //neighbors numerical value
|
||||
uint8_t nr[6]; //neighbors current rest channel
|
||||
memset (nl, 0, sizeof (nl));
|
||||
memset (nr, 0, sizeof (nr));
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
nl[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[32+(i*8)], 4);
|
||||
nr[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[36+(i*8)], 4);
|
||||
if (nl[i]) fprintf (stderr, "S: %d R(%d) ", nl[i], nr[i]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//Cap+ Channel Status
|
||||
if (csbk_o == 0x3E)
|
||||
{
|
||||
|
||||
@@ -634,10 +687,19 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
|
||||
uint8_t fl = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[16], 2);
|
||||
uint8_t ts = cs_pdu_bits[18]; //timeslot this PDU occurs in
|
||||
uint8_t res = cs_pdu_bits[19]; //unknown, always seems to be 0
|
||||
uint8_t rest_channel = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[20], 4);
|
||||
uint8_t res = cs_pdu_bits[19]; //unknown, always seems to be 0 -- could be used in larger Cap+? like a bank switch?
|
||||
uint8_t rest_channel = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[20], 4);
|
||||
uint8_t group_tally = 0; //set this to the number of active group channels tallied
|
||||
|
||||
uint8_t block_num = state->cap_plus_block_num;
|
||||
|
||||
//sanity check
|
||||
if (block_num > 6)
|
||||
{
|
||||
state->cap_plus_block_num = 6;
|
||||
block_num = 6;
|
||||
}
|
||||
|
||||
uint8_t ch[8]; //one bit per channel
|
||||
uint8_t pch[8]; //private or data call channel bits
|
||||
uint8_t tg = 0;
|
||||
@@ -655,14 +717,17 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
}
|
||||
|
||||
//treating FL as a form of LCSS
|
||||
if (fl != 1) //initial or single block (fl2 or fl3)
|
||||
if (fl == 2 || fl == 3) //initial or single block (fl2 or fl3)
|
||||
{
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
for (i = 0; i < 10*8; i++) state->cap_plus_csbk_bits[i] = cs_pdu_bits[i];
|
||||
state->cap_plus_block_num = 0;
|
||||
}
|
||||
else //appended block (fl1)
|
||||
else //appended block (fl0) or final block (fl1)
|
||||
{
|
||||
for (i = 0; i < 7*8; i++) state->cap_plus_csbk_bits[i+80] = cs_pdu_bits[i+24];
|
||||
for (i = 0; i < 7*8; i++) state->cap_plus_csbk_bits[i+80+(7*8*block_num)] = cs_pdu_bits[i+24];
|
||||
block_num++;
|
||||
state->cap_plus_block_num++;
|
||||
}
|
||||
|
||||
if (rest_channel != state->dmr_rest_channel)
|
||||
@@ -679,9 +744,10 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
}
|
||||
|
||||
fprintf (stderr, " Capacity Plus Channel Status - FL: %d TS: %d RS: %d - Rest Channel %d", fl, ts, res, rest_channel);
|
||||
if (fl == 1) fprintf (stderr, " - Appended Block");
|
||||
if (fl == 0) fprintf (stderr, " - Appended Block"); //have not yet observed a system use this fl value
|
||||
if (fl == 1) fprintf (stderr, " - Final Block");
|
||||
if (fl == 2) fprintf (stderr, " - Initial Block");
|
||||
if (fl == 3) fprintf (stderr, " - Single Block");
|
||||
if (fl == 3) fprintf (stderr, " - Single Block"); //still considering a single, and not a final
|
||||
|
||||
//look at each group channel bit -- run this PRIOR to checking private or data calls
|
||||
//or else we will overwrite the ch bits we set below for private calls with zeroes
|
||||
@@ -692,16 +758,16 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
if (ch[i] == 1) group_tally++; //figure out where to start looking in the byte stream for the 0x80 flag
|
||||
}
|
||||
|
||||
//check for private/data calls
|
||||
//check for private/data calls -- user will neeed to enable 'data' call tuning in order to tune them
|
||||
uint8_t pdflag = (uint8_t)ConvertBitIntoBytes(&state->cap_plus_csbk_bits[40+(group_tally*8)], 8); //seems to be 0x80 (last block flag?) on samples I have
|
||||
uint16_t private_target = 0;
|
||||
|
||||
//first, check to see if we have a completed PDU
|
||||
if (fl != 2)
|
||||
if (fl == 1 || fl == 3)
|
||||
{
|
||||
//then check to see if this byte has a value, should be 0x80
|
||||
//this bytes location seems to shift depending on level of activity
|
||||
if (pdflag != 0) //now looking to see if any appended data was added
|
||||
if (pdflag == 0x80) //now looking to see if any appended data was added
|
||||
{
|
||||
k = 0; //= 0
|
||||
fprintf (stderr, "\n");
|
||||
@@ -714,7 +780,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
fprintf (stderr, " Ch%d:", i+1);
|
||||
private_target = (uint16_t)ConvertBitIntoBytes(&state->cap_plus_csbk_bits[56+(k*16)+(group_tally*8)], 16);
|
||||
fprintf (stderr, " TGT %d;", private_target);
|
||||
if (opts->trunk_tune_private_calls == 1) t_tg[i] = private_target; //set here for tuning allow/block
|
||||
if (opts->trunk_tune_data_calls == 1) t_tg[i] = private_target; //set here for tuning allow/block
|
||||
k++;
|
||||
}
|
||||
}
|
||||
@@ -722,7 +788,8 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
}
|
||||
//end private/data call check
|
||||
|
||||
if (fl != 2)
|
||||
// if (fl != 2)
|
||||
if (fl == 1 || fl == 3)
|
||||
{
|
||||
fprintf (stderr, "\n ");
|
||||
|
||||
@@ -744,7 +811,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
{
|
||||
fprintf (stderr, "P||D ");
|
||||
//flag as available for tuning if enabled
|
||||
if (opts->trunk_tune_private_calls == 1) ch[i] = 1;
|
||||
if (opts->trunk_tune_data_calls == 1) ch[i] = 1;
|
||||
}
|
||||
else if (i+1 == rest_channel) fprintf (stderr, "Rest ");
|
||||
else fprintf (stderr, "Idle ");
|
||||
@@ -796,6 +863,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
SetFreq(opts->rigctl_sockfd, state->trunk_chan_map[j+1]);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+1];
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
j = 11; //break loop
|
||||
}
|
||||
|
||||
@@ -805,6 +873,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
rtl_udp_tune (opts, state, state->trunk_chan_map[j+1]);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+1];
|
||||
opts->p25_is_tuned = 1;
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
j = 11; //break loop
|
||||
}
|
||||
|
||||
@@ -819,169 +888,37 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
if (fl == 1 && opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s\n", KYEL);
|
||||
fprintf (stderr, " CAP+ Multi Block PDU ");
|
||||
fprintf (stderr, " CAP+ Multi Block PDU \n ");
|
||||
uint8_t fl_bytes = 0;
|
||||
for (i = 0; i < 17; i++)
|
||||
for (i = 0; i < (10+(block_num*7)); i++)
|
||||
{
|
||||
fl_bytes = (uint8_t)ConvertBitIntoBytes(&state->cap_plus_csbk_bits[i*8], 8);
|
||||
fprintf (stderr, "[%02X]", fl_bytes);
|
||||
if (i == 17 || i == 35) fprintf (stderr, "\n ");
|
||||
}
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
state->cap_plus_block_num = 0;
|
||||
|
||||
} //fl != 2
|
||||
} //if (fl == 1 || fl == 3)
|
||||
} //opcode == 0x3E
|
||||
} //fid == 0x10
|
||||
|
||||
//Capacity+ Section -- fallback if issues arise
|
||||
// if (csbk_fid == 0x10)
|
||||
// {
|
||||
// //not quite sure how these tuning rules will go over
|
||||
// //if they don't work so well, may just fall back to
|
||||
// //a 'follow rest channel on no sync' only approach
|
||||
// if (csbk_o == 0x3E)
|
||||
// {
|
||||
|
||||
// //initial line break
|
||||
// fprintf (stderr, "\n");
|
||||
// fprintf (stderr, "%s", KYEL);
|
||||
|
||||
// uint8_t fl = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[16], 2);
|
||||
// uint8_t ts = cs_pdu_bits[18]; //accurate?
|
||||
// uint8_t res = cs_pdu_bits[19]; //unknown??
|
||||
// uint8_t rest_channel = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[20], 4);
|
||||
|
||||
// uint8_t ch[8]; //one bit per channel
|
||||
// uint8_t tg = 0;
|
||||
// uint32_t tghex = 0; //combined all tgs for debug
|
||||
// int i, j, k;
|
||||
|
||||
// //tg and channel info for trunking purposes
|
||||
// uint8_t t_tg[9];
|
||||
// memset (t_tg, 0, sizeof(t_tg));
|
||||
|
||||
// k = 0;
|
||||
// if (rest_channel != state->dmr_rest_channel)
|
||||
// {
|
||||
// state->dmr_rest_channel = rest_channel;
|
||||
// }
|
||||
// for (int i = 0; i < 8; i++)
|
||||
// {
|
||||
// ch[i] = cs_pdu_bits[i+24];
|
||||
// }
|
||||
|
||||
// //assign to cc freq to follow during no sync
|
||||
// if (state->trunk_chan_map[rest_channel] != 0)
|
||||
// {
|
||||
// state->p25_cc_freq = state->trunk_chan_map[rest_channel];
|
||||
// //set to always tuned
|
||||
// opts->p25_is_tuned = 1;
|
||||
// }
|
||||
|
||||
// fprintf (stderr, " Capacity Plus Channel Status - FL: %d TS: %d RS: %d - Rest Channel %d", fl, ts, res, rest_channel);
|
||||
|
||||
// fprintf (stderr, "\n ");
|
||||
// for (i = 0; i < 8; i++)
|
||||
// {
|
||||
// fprintf (stderr, "Ch%d: ", i+1);
|
||||
// if (ch[i] != 0)
|
||||
// {
|
||||
// tg = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[k*8+32], 8);
|
||||
// if (tg != 0) fprintf (stderr, " %03d ", tg);
|
||||
// else fprintf (stderr, "Priv "); //observed 000s for TG value seem to appear during a Cap+ Private TXI call
|
||||
// //add values to trunking tg/channel potentials
|
||||
// t_tg[i] = tg;
|
||||
// k++;
|
||||
|
||||
// }
|
||||
// else if (i+1 == rest_channel) fprintf (stderr, "Rest ");
|
||||
// else fprintf (stderr, "Idle ");
|
||||
|
||||
// if (i == 3) fprintf (stderr, "\n ");
|
||||
// }
|
||||
// tghex = (uint32_t)ConvertBitIntoBytes(&cs_pdu_bits[32], 24);
|
||||
// //fprintf (stderr, "\n TG Hex = 0x%06X", tghex);
|
||||
// state->dmr_mfid = 0x10;
|
||||
// sprintf (state->dmr_branding, "%s", "Motorola");
|
||||
// sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
|
||||
|
||||
// //nullify any previous TIII data (bugfix for bad assignments or system type switching)
|
||||
// sprintf(state->dmr_site_parms, "%s", "");
|
||||
|
||||
// fprintf (stderr, "%s", KNRM);
|
||||
|
||||
// //Skip tuning group calls if group calls are disabled
|
||||
// if (opts->trunk_tune_group_calls == 0) goto SKIPCAP;
|
||||
|
||||
// //don't tune if currently a vc on the current channel
|
||||
// if ( (time(NULL) - state->last_vc_sync_time > 2) )
|
||||
// {
|
||||
// for (j = 0; j < 8; j++) //go through the channels stored looking for active ones to tune to
|
||||
// {
|
||||
// char mode[8]; //allow, block, digital, enc, etc
|
||||
|
||||
// //if we are using allow/whitelist mode, then write 'B' to mode for block
|
||||
// //comparison below will look for an 'A' to write to mode if it is allowed
|
||||
// if (opts->trunk_use_allow_list == 1) sprintf (mode, "%s", "B");
|
||||
|
||||
// for (int i = 0; i < state->group_tally; i++)
|
||||
// {
|
||||
// if (state->group_array[i].groupNumber == t_tg[j])
|
||||
// {
|
||||
// fprintf (stderr, " [%s]", state->group_array[i].groupName);
|
||||
// strcpy (mode, state->group_array[i].groupMode);
|
||||
// }
|
||||
// }
|
||||
|
||||
// //no more 0 reporting, that was some bad code that caused that issue
|
||||
// //without priority, this will tune the first one it finds (if group isn't blocked)
|
||||
// if (t_tg[j] != 0 && state->p25_cc_freq != 0 && opts->p25_trunk == 1 && (strcmp(mode, "B") != 0) && (strcmp(mode, "DE") != 0))
|
||||
// {
|
||||
// if (state->trunk_chan_map[j+1] != 0) //if we have a valid frequency
|
||||
// {
|
||||
// //RIGCTL
|
||||
// if (opts->use_rigctl == 1)
|
||||
// {
|
||||
// if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
// SetFreq(opts->rigctl_sockfd, state->trunk_chan_map[j+1]);
|
||||
// state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+1];
|
||||
// opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
// j = 11; //break loop
|
||||
// }
|
||||
|
||||
// //rtl_udp
|
||||
// else if (opts->audio_in_type == 3)
|
||||
// {
|
||||
// rtl_udp_tune (opts, state, state->trunk_chan_map[j+1]);
|
||||
// state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+1];
|
||||
// opts->p25_is_tuned = 1;
|
||||
// j = 11; //break loop
|
||||
// }
|
||||
|
||||
// }
|
||||
// }
|
||||
|
||||
// }
|
||||
// }
|
||||
|
||||
// }
|
||||
// SKIPCAP: ; //do nothing
|
||||
// }
|
||||
|
||||
//Connect+ Section
|
||||
if (csbk_fid == 0x06)
|
||||
{
|
||||
|
||||
if (csbk_o == 0x01)
|
||||
{
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
uint8_t nb1 = cs_pdu[2] & 0x3F;
|
||||
uint8_t nb2 = cs_pdu[3] & 0x3F;
|
||||
uint8_t nb3 = cs_pdu[4] & 0x3F;
|
||||
uint8_t nb4 = cs_pdu[5] & 0x3F;
|
||||
uint8_t nb5 = cs_pdu[6] & 0x3F;
|
||||
uint8_t nb5 = cs_pdu[6] & 0x3F;
|
||||
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Connect Plus Neighbors\n");
|
||||
fprintf (stderr, " NB1(%02d), NB2(%02d), NB3(%02d), NB4(%02d), NB5(%02d)", nb1, nb2, nb3, nb4, nb5);
|
||||
@@ -1065,6 +1002,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
state->is_con_plus = 1; //flag on
|
||||
state->last_vc_sync_time = time(NULL); //bugfix: set sync here so we don't immediately tune back to CC constantly.
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
}
|
||||
|
||||
//rtl_udp
|
||||
@@ -1075,6 +1013,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
opts->p25_is_tuned = 1;
|
||||
state->is_con_plus = 1; //flag on
|
||||
state->last_vc_sync_time = time(NULL); //bugfix: set sync here so we don't immediately tune back to CC constantly.
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1087,7 +1026,206 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
}
|
||||
} //end Connect+
|
||||
|
||||
//Hytera XPT
|
||||
if (csbk_fid == 0x68)
|
||||
{
|
||||
//XPT Site Status -- Very Very Experimental, WIP, Don't be surprised by bad decodes or broken trunking
|
||||
if (csbk_o == 0x0A)
|
||||
{
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
|
||||
uint8_t xpt_ch[6]; //one tg/call per timeslot
|
||||
uint16_t tg = 0; //8-bit TG value or hash
|
||||
int i, j;
|
||||
|
||||
//tg and channel info for trunking purposes
|
||||
uint8_t t_tg[24];
|
||||
memset (t_tg, 0, sizeof(t_tg));
|
||||
|
||||
uint8_t xpt_seq = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[0], 2); //this replaces the CSBK lb and pf
|
||||
uint8_t xpt_free = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[16], 4); //free repeater channel
|
||||
uint8_t xpt_bank = 0;
|
||||
|
||||
if (xpt_seq) xpt_bank = xpt_seq*6;
|
||||
|
||||
//get 2-bit status values for each 6 channels (timeslots)
|
||||
for (i = 0; i < 6; i++) xpt_ch[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[20+(i*2)], 2);
|
||||
|
||||
fprintf (stderr, " Hytera XPT Site Status - Free RPT: %d SN: %d\n ", xpt_free+1, xpt_seq);
|
||||
|
||||
//Print List of Channels and Activity
|
||||
for (i = 0; i < 6; i++)
|
||||
{
|
||||
fprintf (stderr, "Ch%02d: ", i+xpt_bank+1); //(xpt_seq*6)
|
||||
tg = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[i*8+32], 8);
|
||||
fprintf (stderr, "ST-%X", xpt_ch[i]); //status bits value 0,1,2, or 3
|
||||
if (tg != 0) fprintf (stderr, " %03d ", tg);
|
||||
else
|
||||
{
|
||||
if (xpt_ch[i] == 3) fprintf (stderr, " Null "); //offline?, free? but also group call if the TG value is populated? Wut? Null should cover both cases...maybe
|
||||
else if (xpt_ch[i] == 2) fprintf (stderr, " Priv "); //This seems to be used on both private data and private calls, but one or the other has a 0 TG value?
|
||||
else if (xpt_ch[i] == 1) fprintf (stderr, " Unk "); //the 01 value has not been observed as of yet, group data?
|
||||
else if (xpt_ch[i] == 0) fprintf (stderr, " Idle "); //Idle appears to always be a 0, or could indicate Group Data (including status CSBK and VLC/TLC)
|
||||
}
|
||||
|
||||
if (i == 2) fprintf (stderr, "\n ");
|
||||
|
||||
|
||||
//add values to trunking tg/channel potentials
|
||||
if (tg != 0) t_tg[i+(xpt_seq*6)] = tg;
|
||||
|
||||
}
|
||||
|
||||
//add string for ncurses terminal display
|
||||
sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
|
||||
|
||||
//assign to cc freq to follow during no sync
|
||||
//current theory is that user should set channel 0 as the 'home repeater' frequency
|
||||
//this can change if this is ever tested by anybody properly
|
||||
if (state->trunk_chan_map[0] != 0)
|
||||
{
|
||||
state->p25_cc_freq = state->trunk_chan_map[0];
|
||||
//set to always tuned
|
||||
opts->p25_is_tuned = 1;
|
||||
}
|
||||
|
||||
//Skip tuning calls if group calls are disabled
|
||||
if (opts->trunk_tune_group_calls == 0) goto SKIPXPT;
|
||||
|
||||
//don't tune if vc on the current channel
|
||||
if ( (time(NULL) - state->last_vc_sync_time > 2) )
|
||||
{
|
||||
for (j = 0; j < 6; j++) //go through the channels stored looking for active ones to tune to
|
||||
{
|
||||
char mode[8]; //allow, block, digital, enc, etc
|
||||
|
||||
//if we are using allow/whitelist mode, then write 'B' to mode for block
|
||||
//comparison below will look for an 'A' to write to mode if it is allowed
|
||||
if (opts->trunk_use_allow_list == 1) sprintf (mode, "%s", "B");
|
||||
|
||||
//this won't work properly on hashed TGT values
|
||||
//unless users load a TGT hash in a csv file
|
||||
//and hope it doesn't clash with other normal TG values
|
||||
for (int i = 0; i < state->group_tally; i++)
|
||||
{
|
||||
if (state->group_array[i].groupNumber == t_tg[j+(xpt_seq*6)])
|
||||
{
|
||||
fprintf (stderr, " [%s]", state->group_array[i].groupName);
|
||||
strcpy (mode, state->group_array[i].groupMode);
|
||||
}
|
||||
}
|
||||
|
||||
//without priority, this will tune the first one it finds (if group isn't blocked)
|
||||
if (t_tg[j+(xpt_seq*6)+1] != 0 && state->p25_cc_freq != 0 && opts->p25_trunk == 1 && (strcmp(mode, "B") != 0) && (strcmp(mode, "DE") != 0))
|
||||
{
|
||||
if (state->trunk_chan_map[j+(xpt_seq*6)+1] != 0) //if we have a valid frequency
|
||||
{
|
||||
//RIGCTL
|
||||
if (opts->use_rigctl == 1)
|
||||
{
|
||||
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
SetFreq(opts->rigctl_sockfd, state->trunk_chan_map[j+(xpt_seq*6)+1]);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+(xpt_seq*6)+1];
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
j = 11; //break loop
|
||||
}
|
||||
|
||||
//rtl_udp
|
||||
else if (opts->audio_in_type == 3)
|
||||
{
|
||||
rtl_udp_tune (opts, state, state->trunk_chan_map[j+(xpt_seq*6)+1]);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = state->trunk_chan_map[j+(xpt_seq*6)+1];
|
||||
opts->p25_is_tuned = 1;
|
||||
dmr_reset_blocks (opts, state); //reset all block gathering since we are tuning away
|
||||
j = 11; //break loop
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
} //end tuning
|
||||
|
||||
SKIPXPT: ;
|
||||
|
||||
sprintf (state->dmr_branding_sub, "XPT ");
|
||||
|
||||
//Trunking Note: My understanding is that XPT calls always start on the 'home' repeater, and then expand
|
||||
//outward to the free repeaters, so its probably easiest for a user to load the frequencies in a csv file
|
||||
//and let FME scan through them as opposed to actively trunking, it will spend most of the time on the home repeater
|
||||
//and if calls occur on the home repeater, it'll be too busy with those to go to the free repeater
|
||||
//DSD-FME doesn't have any sort of TG priority, so its first come first served, just block or allow
|
||||
|
||||
} //end 0x0A
|
||||
|
||||
//XPT Site Information - Adj Site Info??
|
||||
if (csbk_o == 0x0B)
|
||||
{
|
||||
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
|
||||
fprintf (stderr, " Hytera XPT CSBK 0x0B ");
|
||||
|
||||
//wraithe's theory -- seems pretty good to me
|
||||
//still only a theory though until can be verified
|
||||
//by having a system with precisely known variables
|
||||
|
||||
//new samples show this doesn't always quite work, there seems to be
|
||||
//more than one data set transmitted in this CSBK
|
||||
//one set works, the other doesn't fit the pattern
|
||||
|
||||
// Site ID [5 bits]
|
||||
// Unknown_3 [3 bits]
|
||||
// Free Repeater on site [4 bits]
|
||||
// Unknown_4 [4 bits]
|
||||
|
||||
// 11:44:58 Sync: +DMR slot1 [slot2] | Color Code=01 | CSBK
|
||||
// Hytera XPT CSBK 0x0B
|
||||
// DMR PDU Payload [0B][68][10][20][18][10][20][10][28][20][EF][DA]
|
||||
|
||||
// repeat x3 (for total of 4 sites)
|
||||
|
||||
// int i;
|
||||
// uint8_t xpt_site_id[4];
|
||||
// uint8_t xpt_site_rp[4];
|
||||
// uint8_t xpt_site_u1[4];
|
||||
// uint8_t xpt_site_u2[4];
|
||||
|
||||
// for (i = 0; i < 4; i++)
|
||||
// {
|
||||
// xpt_site_id[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[16+(i*16)], 5);
|
||||
// xpt_site_u1[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[21+(i*16)], 3);
|
||||
// xpt_site_rp[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[24+(i*16)], 4);
|
||||
// xpt_site_u2[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[28+(i*16)], 4);
|
||||
// }
|
||||
|
||||
// fprintf (stderr, " Hytera XPT Site Id: %d - Free RPT: %d", xpt_site_id[0], xpt_site_rp[0]);
|
||||
// // fprintf (stderr, " RS1: %d RS2: %d", xpt_site_u1[0], xpt_site_u2[1]); //debug
|
||||
|
||||
// fprintf (stderr, "\n");
|
||||
// fprintf (stderr, " XPT Adj Site(s): ");
|
||||
// for (i = 1; i < 4; i++)
|
||||
// {
|
||||
// if (xpt_site_id[i] != 0)
|
||||
// {
|
||||
// fprintf (stderr, "%d (%d) ", xpt_site_id[i], xpt_site_rp[i]);
|
||||
// // fprintf (stderr, "RS1: %d RS2: %d - ", xpt_site_u1[i], xpt_site_u2[i]); //debug
|
||||
// }
|
||||
// }
|
||||
|
||||
sprintf (state->dmr_branding_sub, "XPT ");
|
||||
|
||||
|
||||
} //end 0x0B
|
||||
|
||||
} //end Hytera XPT section
|
||||
|
||||
}
|
||||
END:
|
||||
|
||||
@@ -76,11 +76,8 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
|
||||
else
|
||||
{
|
||||
cach_okay = -1;
|
||||
if (opts->aggressive_framesync == 1)
|
||||
{
|
||||
SlotTypeOk = 0;
|
||||
goto END;
|
||||
}
|
||||
SlotTypeOk = 0;
|
||||
goto END;
|
||||
}
|
||||
|
||||
state->currentslot = tact_bits[1];
|
||||
@@ -262,11 +259,8 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
|
||||
else
|
||||
{
|
||||
SlotTypeOk = -1;
|
||||
if (opts->aggressive_framesync == 1)
|
||||
{
|
||||
SlotTypeOk = 0;
|
||||
goto END;
|
||||
}
|
||||
SlotTypeOk = 0;
|
||||
goto END;
|
||||
}
|
||||
|
||||
state->color_code = (SlotType[0] << 3) + (SlotType[1] << 2) +(SlotType[2] << 1) + (SlotType[3] << 0);
|
||||
|
||||
112
src/dmr_dburst.c
112
src/dmr_dburst.c
@@ -9,9 +9,11 @@
|
||||
* 2022-12 DSD-FME Florida Man Edition
|
||||
*-----------------------------------------------------------------------------*/
|
||||
|
||||
//WIP: CRC9 on confirmed data blocks; CRC32 on completed data sf;
|
||||
//WIP: Reverse Channel Signalling - RC single burst BPTC/7-bit CRC
|
||||
//WIP: Single Burst Embedded LC - Non-RC single burst LC - Look for Late Entry Alg/Key
|
||||
//WIP: Unified Single Block Data - USBD -- TODO: USBD LIP Protocol Handling
|
||||
//WIP: UDT Header and Blocks (coded - need samples)
|
||||
//WIP: CRC9/CRC32 on Rate 1 Data (need samples)
|
||||
//WIP: Reverse Channel Signalling - RC single burst BPTC/7-bit CRC (rc interleave) and when to run RC and not SB
|
||||
//WIP: Single Burst Embedded LC - Non-RC single burst LC - Look for Late Entry Alg/Key
|
||||
|
||||
#include "dsd.h"
|
||||
|
||||
@@ -43,9 +45,9 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
uint8_t LC_DataBytes[10];
|
||||
int Burst = -1;
|
||||
|
||||
//Unified PDU (is this the best nomenclature) Bytes
|
||||
uint8_t DMR_PDU[25]; //using 25 bytes as the max for now
|
||||
uint8_t DMR_PDU_bits[196]; //bitwise version of unified payload, will probably be a lot easier to use this w/ manual
|
||||
//PDU Bytes and Bits
|
||||
uint8_t DMR_PDU[25];
|
||||
uint8_t DMR_PDU_bits[196];
|
||||
memset (DMR_PDU, 0, sizeof (DMR_PDU));
|
||||
memset (DMR_PDU_bits, 0, sizeof (DMR_PDU_bits));
|
||||
|
||||
@@ -61,9 +63,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
uint8_t is_trellis = 0;
|
||||
uint8_t is_emb = 0;
|
||||
uint8_t is_lc = 0;
|
||||
uint8_t is_full = 0;
|
||||
uint8_t is_full = 0;
|
||||
uint8_t is_udt = 0;
|
||||
uint8_t pdu_len = 0;
|
||||
uint8_t pdu_start = 0; //starting value of pdu (0 normal, 2 for confirmed)
|
||||
uint8_t pdu_start = 0; //starting value of pdu (0 normal, 2 for confirmed)
|
||||
|
||||
uint8_t usbd_st = 0; //usbd service type
|
||||
|
||||
switch(databurst){
|
||||
case 0x00: //PI
|
||||
@@ -127,7 +132,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
pdu_len = 10;
|
||||
pdu_start = 2; //start at plus two when assembling
|
||||
sprintf(state->fsubtype, " R12C ");
|
||||
}
|
||||
}
|
||||
if (state->data_header_format[slot] == 0) //UDT 1/2 Encoded Blocks
|
||||
{
|
||||
is_udt = 1;
|
||||
sprintf(state->fsubtype, " UDTC ");
|
||||
}
|
||||
break;
|
||||
case 0x08: //3/4 Rate Data
|
||||
is_trellis = 1;
|
||||
@@ -159,12 +169,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
sprintf(state->fsubtype, " R_1C ");
|
||||
}
|
||||
break;
|
||||
case 0x0B: //Unified Data
|
||||
case 0x0B: //Unified Single Block Data USBD
|
||||
is_bptc = 1;
|
||||
crclen = 16;
|
||||
crcmask = 0x3333;
|
||||
pdu_len = 12; //12 bytes
|
||||
sprintf(state->fsubtype, " UDAT ");
|
||||
sprintf(state->fsubtype, " USBD ");
|
||||
break;
|
||||
|
||||
//special types (not real data 'sync' bursts)
|
||||
@@ -185,6 +195,9 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
|
||||
}
|
||||
|
||||
//flag off prop head when not looking at data blocks
|
||||
if (databurst != 0x6 && databurst != 0x7 && databurst != 0x8 && databurst != 0xA && databurst != 0xB) state->data_p_head[slot] = 0;
|
||||
|
||||
if (databurst != 0xEB)
|
||||
{
|
||||
if (state->dmr_ms_mode == 0) fprintf(stderr, "| Color Code=%02d ", state->dmr_color_code);
|
||||
@@ -199,7 +212,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
for (i = 0; i < 6; i++) //3 byte CACH
|
||||
{
|
||||
int cach_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
|
||||
fprintf (pFile, "%X", cach_byte);
|
||||
fprintf (pFile, "%X", cach_byte); //nibble, not a byte, next time I look at this and wonder why its not %02X
|
||||
}
|
||||
fprintf (pFile, "\n%d %02X ", slot+1, databurst); //use hex value of current data burst type
|
||||
for (i = 6; i < 72; i++) //33 bytes, no CACH
|
||||
@@ -230,7 +243,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
//debug print
|
||||
//fprintf (stderr, " RAS? %X - %d %d %d", BPTCReservedBits, R[0], R[1], R[2]);
|
||||
|
||||
|
||||
/* Convert the 96 bits BPTC data into 12 bytes */
|
||||
k = 0;
|
||||
for(i = 0; i < 12; i++)
|
||||
@@ -266,10 +278,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
CRCCorrect = 1;
|
||||
}
|
||||
|
||||
//set CRC to correct on proprietary data header blocks (unsure if p_head data has valid crcs,
|
||||
//may be ras enabled, manufacturer specific, or none, currently unknown, but possibly RAS on samples I have)
|
||||
// else if (state->data_p_head[slot] == 1 && databurst == 0x06) CRCCorrect = 1;
|
||||
|
||||
//run CRC9 on intermediate and last 1/2 confirmed data blocks
|
||||
else if (state->data_conf_data[slot] == 1 && databurst == 0x7)
|
||||
{
|
||||
@@ -294,7 +302,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
}
|
||||
|
||||
//run CCITT on other data forms
|
||||
else //will still run on unconfirmed data (shouldn't matter other than a possible bogus warning message)
|
||||
else
|
||||
{
|
||||
CRCComputed = ComputeCrcCCITT(BPTCDmrDataBit);
|
||||
if (CRCComputed == CRCExtracted) CRCCorrect = 1;
|
||||
@@ -302,12 +310,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
}
|
||||
|
||||
//set the 'RAS Flag', if no irrecoverable errors but bad crc, only when enabled by user (to prevent a lot of bad data CSBKs)
|
||||
if (opts->aggressive_framesync == 0 && CRCCorrect == 0 && IrrecoverableErrors == 0 && BPTCReservedBits == 4) is_ras = 1; //!=0, or == 0x4, or just R[2] == 1
|
||||
if (opts->aggressive_framesync == 0 && CRCCorrect == 0 && IrrecoverableErrors == 0 && BPTCReservedBits == 4) is_ras = 1;
|
||||
|
||||
//make sure the system type isn't Hytera, but could just be bad decodes on bad sample
|
||||
if (BPTCDmrDataByte[1] == 0x68) is_ras = 0;
|
||||
|
||||
//if this is a RAS system, set the CRC to okay if irrecoverable errors is okay
|
||||
//if this is a RAS system, set the CRC to okay if irrecoverable errors are okay
|
||||
//if we don't do this, then we can't view some data (CSBKs on RAS enabled systems)
|
||||
if (is_ras == 1)
|
||||
{
|
||||
@@ -337,7 +345,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
BPTCDmrDataBit[j + 7] = (BPTCDmrDataByte[i+pdu_start] >> 0) & 0x01;
|
||||
}
|
||||
|
||||
//convert to unified DMR_PDU and DMR_PDU_bits
|
||||
//convert to DMR_PDU and DMR_PDU_bits
|
||||
for (i = 0; i < pdu_len; i++)
|
||||
{
|
||||
DMR_PDU[i] = BPTCDmrDataByte[i+pdu_start];
|
||||
@@ -468,7 +476,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
}
|
||||
else
|
||||
{
|
||||
IrrecoverableErrors = 9; //set as a shim since the trellis decoder is a pain to fix
|
||||
// IrrecoverableErrors = 9; //set as a shim since the trellis decoder is a pain to fix
|
||||
state->data_block_crc_valid[slot][blockcounter] = 0;
|
||||
}
|
||||
|
||||
@@ -545,14 +553,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
if (databurst == 0x02) dmr_flco (opts, state, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors, 2); //TLC
|
||||
if (databurst == 0xEB) dmr_flco (opts, state, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors, 3); //EMB
|
||||
|
||||
//dmr data header and multi block types (header, 1/2, 3/4, 1, Unified) - type 1
|
||||
if (databurst == 0x06) dmr_dheader (opts, state, DMR_PDU, CRCCorrect, IrrecoverableErrors);
|
||||
if (databurst == 0x07) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //1/2 Rate Data
|
||||
//dmr data header and multi block types (header, 1/2, 3/4, 1, UDT) - type 1
|
||||
if (databurst == 0x06) dmr_dheader (opts, state, DMR_PDU, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors);
|
||||
if (databurst == 0x08) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //3/4 Rate Data
|
||||
if (databurst == 0x0A) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Full Rate Data
|
||||
|
||||
//my best understanding is that unified data carries supplimentary MS data on TIII systems, not control signalling
|
||||
if (databurst == 0x0B) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Unified Data
|
||||
if (databurst == 0x07 && is_udt == 0) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //1/2 Rate Data
|
||||
if (databurst == 0x07 && is_udt == 1) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 3); //UDT with 1/2 Rate Encoding
|
||||
|
||||
//control signalling types (CSBK, MBC)
|
||||
if (databurst == 0x03) dmr_cspdu (opts, state, DMR_PDU_bits, DMR_PDU, CRCCorrect, IrrecoverableErrors);
|
||||
@@ -561,25 +567,38 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
if (databurst == 0x04)
|
||||
{
|
||||
state->data_block_counter[slot] = 0; //zero block counter before running header
|
||||
state->data_header_valid[slot] = 1; //set valid header since we received one
|
||||
dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 2);
|
||||
}
|
||||
if (databurst == 0x05) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 2);
|
||||
|
||||
//Unified Single Data Block (USBD) -- Not to be confused with Unified Data Transport (UDT)
|
||||
if (databurst == 0x0B)
|
||||
{
|
||||
//TODO: provide more robust handling at a later date -- ETSI TS 102 361-4 V1.11.1 (2021-01) 6.6.11.3
|
||||
usbd_st = (uint8_t)ConvertBitIntoBytes(&DMR_PDU_bits[0], 4);
|
||||
fprintf (stderr, "%s\n", KYEL);
|
||||
fprintf (stderr, " Unified Single Block Data - ");
|
||||
if (usbd_st == 0) fprintf (stderr, "Location Information Protocol");
|
||||
else if (usbd_st > 8) fprintf (stderr, "Manufacturer Specific Service %d ", usbd_st);
|
||||
else fprintf (stderr, "Reserved %d ", usbd_st);
|
||||
}
|
||||
|
||||
//set the original CRCCorrect back to its original value if the RAS flag was tripped
|
||||
if (is_ras == 1) CRCCorrect = crc_original_validity;
|
||||
|
||||
//start printing relevant fec/crc/ras messages, don't print on idle or MBC continuation blocks (handled in dmr_block.c)
|
||||
if (CRCCorrect == 1 && databurst != 0x09 && databurst != 0x05) ; //fprintf(stderr, "(CRC OK)");
|
||||
if (IrrecoverableErrors == 0 && CRCCorrect == 1 && databurst != 0x09 && databurst != 0x05) ; //fprintf(stderr, "(CRC OK)");
|
||||
|
||||
if (IrrecoverableErrors == 0 && CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf(stderr, " (FEC OK)");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
// if (IrrecoverableErrors == 0 && CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
|
||||
// {
|
||||
// fprintf (stderr, "%s", KYEL);
|
||||
// fprintf(stderr, " (FEC OK)");
|
||||
// fprintf (stderr, "%s", KNRM);
|
||||
|
||||
}
|
||||
// }
|
||||
|
||||
if (IrrecoverableErrors != 0 && databurst != 0x09 && databurst != 0x05)
|
||||
if (IrrecoverableErrors != 0 && databurst != 0x09) //&& databurst != 0x05
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf(stderr, " (FEC ERR)");
|
||||
@@ -596,7 +615,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
if (CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
|
||||
if (IrrecoverableErrors == 0 && CRCCorrect == 0 && is_ras == 0 && databurst != 0x09 && databurst != 0x05)
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf (stderr, " (CRC ERR) ");
|
||||
@@ -619,25 +638,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
|
||||
// fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
//short data - DD_HEAD, SP_HEAD or R_HEAD (Might do on TMS as well)
|
||||
if ( (state->data_header_format[slot] & 0xF) == 0xD )
|
||||
{
|
||||
fprintf (stderr, "%s", KCYN);
|
||||
fprintf (stderr, "\n Hex to Ascii - ");
|
||||
for (i = 0; i < pdu_len; i++)
|
||||
{
|
||||
if (DMR_PDU[i] <= 0x7E && DMR_PDU[i] >=0x20)
|
||||
{
|
||||
fprintf (stderr, "%c", DMR_PDU[i]);
|
||||
}
|
||||
else fprintf (stderr, ".");
|
||||
}
|
||||
|
||||
fprintf (stderr,"%s", KNRM);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
364
src/dmr_flco.c
364
src/dmr_flco.c
@@ -30,18 +30,43 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
int is_cap_plus = 0;
|
||||
int is_alias = 0;
|
||||
int is_gps = 0;
|
||||
|
||||
//XPT 'Things'
|
||||
int is_xpt = 0;
|
||||
uint8_t xpt_hand = 0; //handshake
|
||||
uint8_t xpt_free = 0; //free repeater
|
||||
uint8_t xpt_int = 0; //xpt channel to interrupt (channel/repeater call should occur on?)
|
||||
uint8_t xpt_res_a = 0; //unknown values of other bits of the XPT LC
|
||||
uint8_t xpt_res_b = 0; //unknown values of other bits of the XPT LC
|
||||
uint8_t xpt_res_c = 0; //unknown values of other bits of the XPT LC
|
||||
uint8_t target_hash[24]; //for XPT (and others if desired, get the hash and compare against SLC or XPT Status CSBKs)
|
||||
uint8_t tg_hash = 0; //value of the hashed TG
|
||||
|
||||
uint8_t slot = state->currentslot;
|
||||
uint8_t unk = 0; //flag for unknown FLCO + FID combo
|
||||
|
||||
|
||||
pf = (uint8_t)(lc_bits[0]); //Protect Flag
|
||||
reserved = (uint8_t)(lc_bits[1]); //Reserved
|
||||
pf = (uint8_t)(lc_bits[0]); //Protect Flag -- Hytera XPT uses this to signify which TS the PDU is on
|
||||
reserved = (uint8_t)(lc_bits[1]); //Reserved -- Hytera XPT G/I bit; 0 - Individual; 1 - Group;
|
||||
flco = (uint8_t)ConvertBitIntoBytes(&lc_bits[2], 6); //Full Link Control Opcode
|
||||
fid = (uint8_t)ConvertBitIntoBytes(&lc_bits[8], 8); //Feature set ID (FID)
|
||||
so = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 8); //Service Options
|
||||
target = (uint32_t)ConvertBitIntoBytes(&lc_bits[24], 24); //Target or Talk Group
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[48], 24);
|
||||
|
||||
//read ahead a little to get this for the xpt flag
|
||||
if (IrrecoverableErrors == 0 && flco == 0x09 && fid == 0x68)
|
||||
{
|
||||
sprintf (state->dmr_branding, "%s", " Hytera");
|
||||
sprintf (state->dmr_branding_sub, "XPT ");
|
||||
}
|
||||
|
||||
//look at the dmr_branding_sub for the XPT string
|
||||
//branding sub is set at CSBK(68-3A and 3B), SLCO 8, and here on 0x09
|
||||
if (strcmp (state->dmr_branding_sub, "XPT ") == 0) is_xpt = 1;
|
||||
|
||||
//hytera XPT -- disable the pf flag, is used for TS value in some Hytera XPT PDUs
|
||||
if (is_xpt) pf = 0;
|
||||
|
||||
//check protect flag
|
||||
if (pf == 1)
|
||||
{
|
||||
@@ -53,46 +78,43 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
goto END_FLCO;
|
||||
}
|
||||
|
||||
//look for Cap+ on VLC header, then set source and/or rest channel appropriately
|
||||
if (IrrecoverableErrors == 0 && type == 1 && fid == 0x10 && (flco == 0x04 || flco == 0x07) ) //0x07 appears to be a cap+ txi private call
|
||||
{
|
||||
is_cap_plus = 1;
|
||||
capsite = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 4); //can't verify, just speculating
|
||||
restchannel = (int)ConvertBitIntoBytes(&lc_bits[52], 4); //was 48,8
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
|
||||
// sprintf (state->dmr_branding, "%s", "Motorola");
|
||||
// sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
|
||||
}
|
||||
|
||||
|
||||
if (IrrecoverableErrors == 0)
|
||||
{
|
||||
|
||||
|
||||
if (slot == 0) state->dmr_flco = flco;
|
||||
else state->dmr_flcoR = flco;
|
||||
|
||||
|
||||
//Embedded Talker Alias Header Only (format and len storage)
|
||||
if (fid == 0 && type == 3 && flco == 0x04)
|
||||
if ( (fid == 0 || fid == 0x68) && type == 3 && flco == 0x04)
|
||||
{
|
||||
dmr_embedded_alias_header(opts, state, lc_bits);
|
||||
}
|
||||
|
||||
//Embedded Talker Alias Header (continuation) and Blocks
|
||||
if (fid == 0 && type == 3 && flco > 0x3 && flco < 0x08)
|
||||
if ( (fid == 0 || fid == 0x68) && type == 3 && flco > 0x03 && flco < 0x08)
|
||||
{
|
||||
is_alias = 1;
|
||||
dmr_embedded_alias_blocks(opts, state, lc_bits);
|
||||
}
|
||||
|
||||
//Embedded GPS
|
||||
if (fid == 0 && type == 3 && flco == 0x08)
|
||||
if ( (fid == 0 || fid == 0x68) && fid == 0 && type == 3 && flco == 0x08)
|
||||
{
|
||||
is_gps = 1;
|
||||
dmr_embedded_gps(opts, state, lc_bits);
|
||||
}
|
||||
|
||||
//Unknown CapMax/Moto Things
|
||||
if (fid == 0x10 && (flco == 0x08 || flco == 0x28))
|
||||
//look for Cap+ on VLC header, then set source and/or rest channel appropriately
|
||||
if (type == 1 && fid == 0x10 && (flco == 0x04 || flco == 0x07) ) //0x07 appears to be a cap+ txi private call
|
||||
{
|
||||
is_cap_plus = 1;
|
||||
capsite = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 4); //don't believe so
|
||||
restchannel = (int)ConvertBitIntoBytes(&lc_bits[52], 4); //
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
|
||||
}
|
||||
|
||||
//Unknown CapMax/Moto Things -- 0x14, 0x15, 0x16 are new ones on emb
|
||||
if (fid == 0x10 && (flco == 0x08 || flco == 0x28 || flco == 0x14 || flco == 0x15 || flco == 0x16))
|
||||
{
|
||||
//NOTE: fid 0x10 and flco 0x08 (emb) produces a lot of 'zero' bytes
|
||||
//this has been observed to happen often on CapMax systems, so I believe it could be some CapMax 'thing'
|
||||
@@ -113,8 +135,16 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
{
|
||||
fprintf (stderr, "%s \n", KRED);
|
||||
fprintf (stderr, " SLOT %d", state->currentslot+1);
|
||||
fprintf (stderr, " Data Terminator (TD_LC)");
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
fprintf (stderr, " Data Terminator (TD_LC) ");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
//reset data header format storage
|
||||
state->data_header_format[slot] = 7;
|
||||
//flag off data header validity
|
||||
state->data_header_valid[slot] = 0;
|
||||
//flag off conf data flag
|
||||
state->data_conf_data[slot] = 0;
|
||||
|
||||
goto END_FLCO;
|
||||
}
|
||||
|
||||
@@ -132,8 +162,127 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
goto END_FLCO;
|
||||
}
|
||||
|
||||
//look for any Hytera XPT system, adjust TG to 16-bit allocation
|
||||
//Groups use only 8 out of 16, but 16 always seems to be allocated
|
||||
//private calls use 16-bit target values hased to 8-bit in the site status csbk
|
||||
//the TLC preceeds the VLC for a 'handshake' call setup in XPT
|
||||
|
||||
//truncate if XPT is set
|
||||
if (is_xpt == 1)
|
||||
{
|
||||
target = (uint32_t)ConvertBitIntoBytes(&lc_bits[32], 16); //16-bit allocation
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16); //16-bit allocation
|
||||
|
||||
//the crc8 hash is the value represented in the CSBK when dealing with private calls
|
||||
for (int i = 0; i < 16; i++) target_hash[i] = lc_bits[32+i];
|
||||
tg_hash = crc8 (target_hash, 16);
|
||||
}
|
||||
|
||||
//XPT Call 'Grant' Setup Occurs in TLC (TermLC Handshake) with a flco 0x09
|
||||
if (fid == 0x68 && flco == 0x09)
|
||||
{
|
||||
//The CSBK always uses an 8-bit TG; The White Papers (user manuals) say 8-bit TG and 16-bit SRC addressing
|
||||
//It seems that private calls and indiv data calls use a hash of their 8 bit tgt values in the CSBK
|
||||
xpt_free = (uint8_t)ConvertBitIntoBytes(&lc_bits[24], 4); //24 and 4 on 0x09
|
||||
xpt_hand = (uint8_t)ConvertBitIntoBytes(&lc_bits[28], 4); //handshake kind: 0 - ordinary; 1-2 Interrupts; 3-15 reserved;
|
||||
|
||||
target = (uint32_t)ConvertBitIntoBytes(&lc_bits[32], 16); //16-bit allocation
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16); //16-bit allocation
|
||||
|
||||
//the bits that are left behind
|
||||
xpt_res_a = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 8); //Where the SVC bits would usually be
|
||||
xpt_res_b = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 8); //where the first 8 bits of the SRC would be
|
||||
xpt_res_c = (uint8_t)ConvertBitIntoBytes(&lc_bits[72], 8); //some unknown 8 bit value after the SRC
|
||||
|
||||
//speculation: 16,4 may be the current repeater channel this call will occur on? or the channel to interrupt?, could also be 8 bits?
|
||||
xpt_int = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 4);
|
||||
|
||||
//the crc8 hash is the value represented in the CSBK when dealing with private calls
|
||||
for (int i = 0; i < 16; i++) target_hash[i] = lc_bits[32+i];
|
||||
tg_hash = crc8 (target_hash, 16); //This is a different poly, but using as placeholder
|
||||
|
||||
fprintf (stderr, "%s \n", KGRN);
|
||||
fprintf (stderr, " SLOT %d ", state->currentslot+1);
|
||||
fprintf(stderr, "TGT=%u SRC=%u ", target, source);
|
||||
|
||||
// Here are some of the RIDs with hash address seen in that sample:
|
||||
// 930 = 88
|
||||
// 9317 = 198
|
||||
// 10002 = 187
|
||||
|
||||
if (opts->payload == 1) fprintf(stderr, "HASH=%d ", tg_hash);
|
||||
// if (opts->payload == 1) fprintf(stderr, "HSK [%X] ", xpt_hand);
|
||||
|
||||
if (opts->payload == 1) fprintf(stderr, "CH=%X ", xpt_int+1); //repeater channel to 'interrupt' with this call?
|
||||
if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X ", flco, fid);
|
||||
|
||||
// if (opts->payload == 1) fprintf(stderr, "RS [%02X][%02X][%02X] ", xpt_res_a, xpt_res_b, xpt_res_c);
|
||||
|
||||
fprintf (stderr, "Hytera XPT ");
|
||||
if (reserved == 1) fprintf (stderr, "Group "); //according to observation
|
||||
else fprintf (stderr, "Private "); //according to observation
|
||||
fprintf (stderr, "Call Protect ");
|
||||
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, "F-Rpt %d", xpt_free+1);
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
|
||||
//add string for ncurses terminal display
|
||||
sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
|
||||
|
||||
is_xpt = 1;
|
||||
goto END_FLCO;
|
||||
}
|
||||
|
||||
//XPT 'Handshake' -- not observed as of yet on any samples
|
||||
if ( fid == 0x68 && (flco == 0x2E || flco == 0x2F) )
|
||||
{
|
||||
|
||||
//all below is according to the patent, but never observed on any samples I have
|
||||
target = (uint32_t)ConvertBitIntoBytes(&lc_bits[24], 24); //24-bit values according to patent
|
||||
source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 24); //24-bit values according to patent
|
||||
|
||||
xpt_free = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 4); //16 and 4 on 2E and 2F
|
||||
xpt_hand = (uint8_t)ConvertBitIntoBytes(&lc_bits[20], 4); //handshake kind: 0 - ordinary; 1-2 Interrupts; 3-15 reserved;
|
||||
xpt_int = (uint8_t)ConvertBitIntoBytes(&lc_bits[24], 8); //Interrupt Designated Channel (No idea?)
|
||||
|
||||
fprintf (stderr, "%s \n", KGRN);
|
||||
fprintf (stderr, " SLOT %d ", state->currentslot+1);
|
||||
fprintf(stderr, "TGT=%u SRC=%u ", target, source);
|
||||
|
||||
if (opts->payload == 1) fprintf(stderr, "HASH=%d ", tg_hash);
|
||||
// if (opts->payload == 1) fprintf(stderr, "HSK=[%X] ", xpt_hand);
|
||||
|
||||
if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X ", flco, fid);
|
||||
fprintf (stderr, "Hytera XPT ");
|
||||
if (reserved == 1) fprintf (stderr, "Group ");
|
||||
else fprintf (stderr, "Private ");
|
||||
|
||||
fprintf (stderr, "Call ");
|
||||
if (flco == 0x2E) fprintf (stderr, "Request ");
|
||||
if (flco == 0x2F) fprintf (stderr, "Response ");
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
is_xpt = 1;
|
||||
goto END_FLCO;
|
||||
|
||||
}
|
||||
|
||||
//Hytera XPT "something" -- seen on Embedded
|
||||
if (fid == 0x68 && flco == 0x13)
|
||||
{
|
||||
if (type == 1) fprintf (stderr, "%s \n", KCYN);
|
||||
if (type == 2) fprintf (stderr, "%s \n", KCYN);
|
||||
if (type == 3) fprintf (stderr, "%s", KCYN);
|
||||
fprintf (stderr, " SLOT %d", state->currentslot+1);
|
||||
fprintf (stderr, " Hytera ");
|
||||
unk = 1;
|
||||
goto END_FLCO;
|
||||
}
|
||||
|
||||
//unknown other manufacturer or OTA ENC, etc.
|
||||
if (fid != 0 && fid != 0x68 && fid != 0x10) //removed tait from the list
|
||||
//removed tait from the list, added hytera 0x08
|
||||
if (fid != 0 && fid != 0x68 && fid != 0x10 && fid != 0x08)
|
||||
{
|
||||
if (type == 1) fprintf (stderr, "%s \n", KYEL);
|
||||
if (type == 2) fprintf (stderr, "%s \n", KYEL);
|
||||
@@ -147,11 +296,9 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
}
|
||||
|
||||
//will want to continue to observe for different flco and fid combinations to find out their meaning
|
||||
//Standard Addressing/Cap+ Addressing (trying to avoid embedded alias and gps, etc)
|
||||
if(IrrecoverableErrors == 0 && is_alias == 0 && is_gps == 0)
|
||||
{
|
||||
//set overarching manufacturer in use when non-standard feature id set is up
|
||||
//may not want to set moto 0x10 here either, lots of radios use that set as well
|
||||
if (fid != 0) state->dmr_mfid = fid;
|
||||
|
||||
if (type != 2) //VLC and EMB, set our target, source, so, and fid per channel
|
||||
@@ -222,12 +369,18 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
|
||||
fprintf (stderr, " SLOT %d ", state->currentslot+1);
|
||||
fprintf(stderr, "TGT=%u SRC=%u ", target, source);
|
||||
if (opts->payload == 1 && is_xpt == 1) fprintf(stderr, "HASH=%d ", tg_hash);
|
||||
if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X SVC=0x%02X ", flco, fid, so);
|
||||
|
||||
//0x04 and 0x05 on a TLC seem to indicate a Cap + Private Call Terminator (perhaps one for each MS)
|
||||
//0x07 on a VLC seems to indicate a Cap+ Private Call Header
|
||||
//0x23 on the Embedded Voice Burst Sync seems to indicate a Cap+ Private Call in progress
|
||||
if (flco == 0x4 || flco == 0x5 || flco == 0x7 || flco == 0x23) //Cap+ Things
|
||||
//0x23 on the Embedded Voice Burst Sync seems to indicate a Cap+ or Cap+ TXI Private Call in progress
|
||||
//0x20 on the Embedded Voice Burst Sync seems to indicate a Moto (non-specific) Group Call in progress
|
||||
//its possible that both EMB FID 0x10 FLCO 0x20 and 0x23 are just Moto but non-specific (observed 0x20 on Tier 2)
|
||||
|
||||
if (fid == 0x68) sprintf (state->call_string[slot], " Hytera ");
|
||||
|
||||
else if (flco == 0x4 || flco == 0x5 || flco == 0x7 || flco == 0x23) //Cap+ Things
|
||||
{
|
||||
sprintf (state->call_string[slot], " Cap+");
|
||||
fprintf (stderr, "Cap+ ");
|
||||
@@ -242,12 +395,12 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
fprintf (stderr, "Private ");
|
||||
}
|
||||
}
|
||||
else if (flco == 0x3) //UU_V_Ch_Usr
|
||||
else if (flco == 0x3) //UU_V_Ch_Usr -- still valid on hytera VLC
|
||||
{
|
||||
sprintf (state->call_string[slot], " Private ");
|
||||
fprintf (stderr, "Private ");
|
||||
}
|
||||
else //Grp_V_Ch_Usr
|
||||
else //Grp_V_Ch_Usr -- still valid on hytera VLC
|
||||
{
|
||||
sprintf (state->call_string[slot], " Group ");
|
||||
fprintf (stderr, "Group ");
|
||||
@@ -271,64 +424,74 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// else strcat (state->call_string[slot], " ");
|
||||
|
||||
/* Check the "Service Option" bits */
|
||||
if(so & 0x30)
|
||||
//Motorola FID 0x10 Only
|
||||
if (fid == 0x10)
|
||||
{
|
||||
/* Experimentally determined with DSD+,
|
||||
* is equal to 0x2, this is a TXI call */
|
||||
if((so & 0x30) == 0x20)
|
||||
/* Check the "Service Option" bits */
|
||||
if(so & 0x30)
|
||||
{
|
||||
/* Experimentally determined with DSD+,
|
||||
* is equal to 0x2, this is a TXI call */
|
||||
if((so & 0x30) == 0x20)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " TXI");
|
||||
fprintf(stderr, "TXI ");
|
||||
}
|
||||
else
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " RES");
|
||||
fprintf(stderr, "RS%d ", (so & 0x30) >> 4);
|
||||
}
|
||||
}
|
||||
if(so & 0x08)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " TXI");
|
||||
fprintf(stderr, "TXI ");
|
||||
// strcat (state->call_string[slot], "-BC ");
|
||||
fprintf(stderr, "Broadcast ");
|
||||
}
|
||||
else
|
||||
if(so & 0x04)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " RES");
|
||||
fprintf(stderr, "RS%d ", (so & 0x30) >> 4);
|
||||
// strcat (state->call_string[slot], "-OVCM ");
|
||||
fprintf(stderr, "OVCM ");
|
||||
}
|
||||
}
|
||||
if(so & 0x08)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-BC ");
|
||||
fprintf(stderr, "Broadcast ");
|
||||
}
|
||||
if(so & 0x04)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-OVCM ");
|
||||
fprintf(stderr, "OVCM ");
|
||||
}
|
||||
if(so & 0x03)
|
||||
{
|
||||
if((so & 0x03) == 0x01)
|
||||
if(so & 0x03)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P1");
|
||||
fprintf(stderr, "Priority 1 ");
|
||||
}
|
||||
else if((so & 0x03) == 0x02)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P2");
|
||||
fprintf(stderr, "Priority 2 ");
|
||||
}
|
||||
else if((so & 0x03) == 0x03)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P3");
|
||||
fprintf(stderr, "Priority 3 ");
|
||||
}
|
||||
else /* We should never go here */
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " ");
|
||||
fprintf(stderr, "No Priority ");
|
||||
}
|
||||
if((so & 0x03) == 0x01)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P1");
|
||||
fprintf(stderr, "Priority 1 ");
|
||||
}
|
||||
else if((so & 0x03) == 0x02)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P2");
|
||||
fprintf(stderr, "Priority 2 ");
|
||||
}
|
||||
else if((so & 0x03) == 0x03)
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], "-P3");
|
||||
fprintf(stderr, "Priority 3 ");
|
||||
}
|
||||
else /* We should never go here */
|
||||
{
|
||||
//REMUS! Uncomment Line Below if desired
|
||||
// strcat (state->call_string[slot], " ");
|
||||
fprintf(stderr, "No Priority ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//should rework this back into the upper portion
|
||||
if (fid == 0x68) fprintf (stderr, "Hytera ");
|
||||
if (is_xpt) fprintf (stderr, "XPT ");
|
||||
if (fid == 0x68 && flco == 0x00) fprintf (stderr, "Group ");
|
||||
if (fid == 0x68 && flco == 0x03) fprintf (stderr, "Private ");
|
||||
|
||||
fprintf(stderr, "Call ");
|
||||
|
||||
|
||||
@@ -378,8 +541,7 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
|
||||
END_FLCO:
|
||||
if (unk == 1 || pf == 1)
|
||||
{
|
||||
// fprintf(stderr, " FLCO=0x%02X FID=0x%02X SVC=0x%02X ", flco, fid, so);
|
||||
fprintf(stderr, " FLCO=0x%02X FID=0x%02X ", flco, fid); //not all LC PDUs contain SVC bits (see TD_LC)
|
||||
fprintf(stderr, " FLCO=0x%02X FID=0x%02X SVC=0x%02X ", flco, fid, so);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
@@ -646,10 +808,17 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
|
||||
//Con+
|
||||
uint8_t con_netid = (uint8_t)ConvertBitIntoBytes(&slco_bits[8], 8);
|
||||
uint8_t con_siteid = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 8);
|
||||
|
||||
//Cap+
|
||||
uint8_t capsite = (uint8_t)ConvertBitIntoBytes(&slco_bits[12], 4); //can't verify, just speculating
|
||||
uint8_t restchannel = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4); //was 12,8
|
||||
uint8_t cap_reserved = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 8); //unknown if any significant value?
|
||||
uint8_t capsite = (uint8_t)ConvertBitIntoBytes(&slco_bits[22], 3); //Seems more consistent
|
||||
uint8_t restchannel = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4);
|
||||
uint8_t cap_reserved = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 2); //significant value?
|
||||
|
||||
//Hytera XPT
|
||||
uint8_t xpt_free = (uint8_t)ConvertBitIntoBytes(&slco_bits[12], 4); //free repeater
|
||||
//the next two per SDRTrunk, but only 0 values ever observed here
|
||||
uint8_t xpt_pri = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4); //priority repeater
|
||||
uint8_t xpt_hash = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 8); //priority TG hash
|
||||
|
||||
//initial line break
|
||||
fprintf (stderr, "\n");
|
||||
@@ -698,20 +867,12 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
|
||||
fprintf (stderr, " SLCO Activity Update TS1: %X Hash: %02X TS2: %X Hash: %02X", ts1_act, ts1_hash, ts2_act, ts2_hash); //102 361-2 7.1.3.2
|
||||
else if (slco == 0x9)
|
||||
{
|
||||
//remove all setting of branding/sub from SLCO, can cause false positives even with seeming good CRC
|
||||
|
||||
// state->dmr_mfid = 0x10;
|
||||
// sprintf (state->dmr_branding, "%s", "Motorola");
|
||||
// sprintf (state->dmr_branding_sub, "%s", "Con+ ");
|
||||
fprintf (stderr, " SLCO Connect Plus Voice Channel - Net ID: %d Site ID: %d", con_netid, con_siteid);
|
||||
sprintf (state->dmr_site_parms, "%d-%d ", con_netid, con_siteid);
|
||||
}
|
||||
|
||||
else if (slco == 0xA)
|
||||
{
|
||||
// state->dmr_mfid = 0x10;
|
||||
// sprintf (state->dmr_branding, "%s", "Motorola");
|
||||
// sprintf (state->dmr_branding_sub, "%s", "Con+ ");
|
||||
fprintf (stderr, " SLCO Connect Plus Control Channel - Net ID: %d Site ID: %d", con_netid, con_siteid);
|
||||
sprintf (state->dmr_site_parms, "%d-%d ", con_netid, con_siteid);
|
||||
|
||||
@@ -725,19 +886,24 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
|
||||
|
||||
else if (slco == 0xF)
|
||||
{
|
||||
// state->dmr_mfid = 0x10;
|
||||
// sprintf (state->dmr_branding, "%s", "Motorola");
|
||||
// sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
|
||||
fprintf (stderr, " SLCO Capacity Plus Site: %d - Rest Channel %d - RS: %02X", capsite+1, restchannel, cap_reserved);
|
||||
// state->dmr_rest_channel = restchannel; //test without, may work better
|
||||
fprintf (stderr, " SLCO Capacity Plus Site: %d - Rest Channel %d - RS: %02X", capsite, restchannel, cap_reserved);
|
||||
//assign to cc freq if available
|
||||
if (state->trunk_chan_map[restchannel] != 0)
|
||||
{
|
||||
state->p25_cc_freq = state->trunk_chan_map[restchannel];
|
||||
}
|
||||
|
||||
//nullify any previous TIII data (bugfix for bad assignments or system type switching)
|
||||
// sprintf(state->dmr_site_parms, "%s", "");
|
||||
}
|
||||
else if (slco == 0x08)
|
||||
{
|
||||
//The Priority Repeater and Priority Hash values stem from SDRTrunk, but I've never seen these values not be zeroes
|
||||
// fprintf (stderr, " SLCO Hytera XPT - Free RPT %d - PRI RPT %d - PRI HASH: %02X", xpt_free, xpt_pri, xpt_hash);
|
||||
//NOTE: on really busy systems, this free repeater assignment can lag due to the 4 TS requirment to get SLC
|
||||
fprintf (stderr, " SLCO Hytera XPT - Free RPT %d ", xpt_free+1);
|
||||
sprintf (state->dmr_branding_sub, "XPT ");
|
||||
|
||||
//add string for ncurses terminal display
|
||||
sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
|
||||
}
|
||||
|
||||
else fprintf (stderr, " SLCO Unknown - %d ", slco);
|
||||
|
||||
149
src/dmr_le.c
149
src/dmr_le.c
@@ -76,6 +76,12 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
|
||||
fprintf (stderr, " Slot 1 PI/LFSR and Late Entry MI Mismatch - %08X : %08X \n", state->payload_mi, mi_final);
|
||||
state->payload_mi = mi_final;
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
//run afterwards, or le verification won't match up properly
|
||||
if (state->payload_algid != 0x21)
|
||||
{
|
||||
LFSR64 (state);
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
}
|
||||
if (slot == 1 && state->payload_algidR != 0)
|
||||
@@ -86,6 +92,12 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
|
||||
fprintf (stderr, " Slot 2 PI/LFSR and Late Entry MI Mismatch - %08X : %08X \n", state->payload_miR, mi_final);
|
||||
state->payload_miR = mi_final;
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
//run afterwards, or le verification won't match up properly
|
||||
if (state->payload_algidR != 0x21)
|
||||
{
|
||||
LFSR64 (state);
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -104,11 +116,13 @@ void dmr_alg_refresh (dsd_opts * opts, dsd_state * state)
|
||||
state->DMRvcL = 0;
|
||||
}
|
||||
|
||||
if (state->payload_algid >= 0x21)
|
||||
if (state->payload_algid == 0x21)
|
||||
{
|
||||
LFSR (state);
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
//LFSR64 carried out after LE verification in order to keep it from constantly resetting the MI to the previous value
|
||||
|
||||
}
|
||||
if (state->currentslot == 1)
|
||||
{
|
||||
@@ -119,11 +133,13 @@ void dmr_alg_refresh (dsd_opts * opts, dsd_state * state)
|
||||
state->DMRvcR = 0;
|
||||
}
|
||||
|
||||
if (state->payload_algidR >= 0x21)
|
||||
if (state->payload_algidR == 0x21)
|
||||
{
|
||||
LFSR (state);
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
//LFSR64 carried out after LE verification in order to keep it from constantly resetting the MI to the previous value
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -134,12 +150,11 @@ void dmr_alg_reset (dsd_opts * opts, dsd_state * state)
|
||||
state->dropR = 256;
|
||||
state->DMRvcL = 0;
|
||||
state->DMRvcR = 0;
|
||||
state->payload_miP = 0;
|
||||
state->payload_miP = 0;
|
||||
state->payload_miN = 0;
|
||||
}
|
||||
|
||||
//handle Single Burst (Voice Burst F) or Reverse Channel Signalling
|
||||
//(Embedded or Dedicated Outbound, not Stand Alone (MS sourced) or Direct Mode)
|
||||
//MS Sourced or Direct Mode probably would be handled poorly by the demodulator
|
||||
void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
|
||||
{
|
||||
int i;
|
||||
@@ -164,11 +179,11 @@ void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
|
||||
//power == 1 should be reverse channel -- still need to check the interleave inside of BPTC
|
||||
if (power == 1) irr_err = BPTC_16x2_Extract_Data(sbrc_interleaved, sbrc_return, 1);
|
||||
//bad emb burst, never set a valid power indicator value (probably 9)
|
||||
if (power > 1) goto SBRC_END;
|
||||
if (power > 1) goto SBRC_END;
|
||||
|
||||
//RC Channel CRC 7 Mask = 0x7A; CRC bits are used as privacy indicators on
|
||||
//Single Voice Burst F (see below), other moto values seem to exist there as well
|
||||
//unknown what the other values are (see Cap+ 0x313)
|
||||
//unknown what the other values are (see Cap+ 0x313 and 0x643)
|
||||
if (power == 1) //RC
|
||||
{
|
||||
crc_extracted = 0;
|
||||
@@ -206,70 +221,78 @@ void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
|
||||
}
|
||||
}
|
||||
|
||||
//Disabling the lower portion until this can be completely ironed out
|
||||
|
||||
//sbrc_hex value of 0x313 seems to be some Cap+ Thing,
|
||||
//also observed 0x643 on another cap+ system (site id, status? something?)
|
||||
//I've observed it in the Private Cap+ TXI calls as well
|
||||
//there also seems to be a correlation between the SVC bits for TXI (reserved=3) and these extra cap+ values
|
||||
uint8_t sbrc_opcode = sbrc_hex;
|
||||
uint8_t alg = sbrc_hex & 3;
|
||||
uint16_t key = (sbrc_hex >> 3) & 0xFF;
|
||||
// uint8_t sbrc_opcode = sbrc_hex;
|
||||
// uint8_t alg = sbrc_hex & 0x7;
|
||||
// uint8_t key = (sbrc_hex >> 3) & 0xFF;
|
||||
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
if (irr_err != 0) fprintf (stderr, "%s (FEC ERR) %d %s", KRED, irr_err, KNRM);
|
||||
if (irr_err == 0)
|
||||
{
|
||||
if (sbrc_hex == 0) ; //NULL
|
||||
else if (sbrc_hex == 0x313)
|
||||
{
|
||||
//Cap+ Thing? Observed On Cap+ Systems
|
||||
// fprintf (stderr, " Cap+ Thing?");
|
||||
}
|
||||
else
|
||||
{
|
||||
//this pattern seems to fit the multiple cap+ systems I've observed
|
||||
//test on site '7' to make sure (works on 1 and 4)
|
||||
// uint8_t cap_site = (sbrc_hex >> 4) & 0x7;
|
||||
|
||||
if (slot == 0)
|
||||
{
|
||||
//key and alg only present SOME times, not all,
|
||||
//also, intermixed with other signalling
|
||||
//needs more study first!
|
||||
if (state->dmr_so & 0x40 && key != 0 && state->payload_keyid == 0)
|
||||
{
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s ", KYEL);
|
||||
fprintf (stderr, "\n Slot 1");
|
||||
fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
// if (opts->payload == 1)
|
||||
// {
|
||||
// if (irr_err != 0) fprintf (stderr, "%s (FEC ERR) %d %s", KRED, irr_err, KNRM);
|
||||
// if (irr_err == 0)
|
||||
// {
|
||||
// if (sbrc_hex == 0) ; //NULL
|
||||
// else if (sbrc_hex == 0x313) //sbrc_hex == 0x313 and 0x643 (cap+ things)
|
||||
// {
|
||||
// //Cap+ Site ID seems to fit here on samples I've seen with the alternate SB signalling
|
||||
// fprintf (stderr, "%s ", KYEL);
|
||||
// fprintf (stderr, "\n ");
|
||||
// fprintf (stderr, " Capacity Plus Site %d", cap_site);
|
||||
// fprintf (stderr, "%s ", KNRM);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
|
||||
// if (slot == 0)
|
||||
// {
|
||||
// //key and alg only present SOME times, not all,
|
||||
// //also, intermixed with other signalling
|
||||
// //needs more study first!
|
||||
// if (state->dmr_so & 0x40 && key != 0 && state->payload_keyid == 0)
|
||||
// {
|
||||
// if (opts->payload == 1)
|
||||
// {
|
||||
// fprintf (stderr, "%s ", KYEL);
|
||||
// fprintf (stderr, "\n Slot 1");
|
||||
// fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
|
||||
// fprintf (stderr, "%s ", KNRM);
|
||||
// }
|
||||
|
||||
//needs more study before assignment
|
||||
//state->payload_keyid = key;
|
||||
//state->payload_algid = alg + 0x20; //assuming DMRA approved alg values (moto patent)
|
||||
}
|
||||
}
|
||||
if (slot == 1)
|
||||
{
|
||||
if (state->dmr_soR & 0x40 && key != 0 && state->payload_keyidR == 0)
|
||||
{
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s ", KYEL);
|
||||
fprintf (stderr, "\n Slot 2");
|
||||
fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
// //needs more study before assignment
|
||||
// // state->payload_keyid = key;
|
||||
// // state->payload_algid = alg + 0x20; //assuming DMRA approved alg values (moto patent)
|
||||
// }
|
||||
// }
|
||||
|
||||
// if (slot == 1)
|
||||
// {
|
||||
// if (state->dmr_soR & 0x40 && key != 0 && state->payload_keyidR == 0)
|
||||
// {
|
||||
// if (opts->payload == 1)
|
||||
// {
|
||||
// fprintf (stderr, "%s ", KYEL);
|
||||
// fprintf (stderr, "\n Slot 2");
|
||||
// fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
|
||||
// fprintf (stderr, "%s ", KNRM);
|
||||
// }
|
||||
|
||||
//needs more study before assignment
|
||||
//state->payload_keyidR = key;
|
||||
//state->payload_algidR = alg + 0x20; //assuming DMRA approved alg values (moto patent)
|
||||
}
|
||||
}
|
||||
// //needs more study before assignment
|
||||
// // state->payload_keyidR = key;
|
||||
// // state->payload_algidR = alg + 0x20; //assuming DMRA approved alg values (moto patent)
|
||||
// }
|
||||
// }
|
||||
|
||||
}
|
||||
// }
|
||||
|
||||
}
|
||||
}
|
||||
// }
|
||||
// }
|
||||
|
||||
SBRC_END:
|
||||
|
||||
|
||||
245
src/dmr_pdu.c
245
src/dmr_pdu.c
@@ -44,21 +44,20 @@ void dmr_pdu (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR
|
||||
uint8_t padding = state->data_header_padding[slot];
|
||||
uint8_t lrrp_conf = 0;
|
||||
|
||||
//consider disabling on prop_head data blocks if bad/false decodes
|
||||
//if (state->data_p_head[slot] == 0)
|
||||
lrrp_conf = dmr_lrrp (opts, state, block_len, DMR_PDU);
|
||||
//check for more available flag info, etc on these prior to running
|
||||
if (DMR_PDU[0] == 0x01) dmr_locn (opts, state, block_len, DMR_PDU);
|
||||
else dmr_lrrp (opts, state, block_len, DMR_PDU);
|
||||
|
||||
//maybe one day we will have more things to do here
|
||||
state->data_conf_data[slot] = 0; //flag off confirmed data after processing it
|
||||
state->data_p_head[slot] = 0; //flag off prop_head data after processing it
|
||||
state->data_header_format[slot] = 0; //zero out so we don't keep ascii printing
|
||||
|
||||
}
|
||||
|
||||
//The contents of this function are mostly my reversed engineered efforts by observing DSDPlus output and matching data bytes
|
||||
//combined with a few external sources such as OK-DMR for some token values and extra data values (rad and alt)
|
||||
//this is by no means an extensive LRRP list and is prone to error (unless somebody has the manual or something)
|
||||
uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
|
||||
void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
|
||||
{
|
||||
int i, j;
|
||||
uint16_t message_len = 0;
|
||||
@@ -83,12 +82,15 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
|
||||
//lat-long-radius-alt
|
||||
uint32_t lat = 0;
|
||||
uint8_t lat_sign = 0;
|
||||
uint32_t lon = 0;
|
||||
uint16_t rad = 0;
|
||||
uint16_t rad = 0; //or Azimuth in Circle 3D?
|
||||
uint8_t alt = 0;
|
||||
double lat_unit = (double)180/(double)4294967295;
|
||||
double lon_unit = (double)360/(double)4294967295;
|
||||
double lat_fin = 0.0; //calculated values
|
||||
double lon_fin = 0.0; //calculated values
|
||||
int lat_sign = 1; //positive 1, or negative 1
|
||||
int lon_sign = 1; //positive 1, or negative 1
|
||||
|
||||
//speed/velocity
|
||||
uint16_t vel = 0;
|
||||
@@ -97,28 +99,19 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
|
||||
//track, direction, degrees
|
||||
uint8_t degrees = 0;
|
||||
uint8_t deg_set = 0;
|
||||
uint8_t deg_set = 0;
|
||||
|
||||
char deg_glyph[4];
|
||||
sprintf (deg_glyph, "%s", "°");
|
||||
// sprintf (deg_glyph, "%s", "d");
|
||||
|
||||
//triggered information report
|
||||
uint8_t report = 0;
|
||||
uint8_t pot_report = 0; //potential report by finding 0x0D and backtracking a few bytes
|
||||
|
||||
uint8_t is_p_head = 0;
|
||||
|
||||
//shim for getting LRRP out of some prop head data blocks
|
||||
if (state->data_p_head[slot] == 1)
|
||||
{
|
||||
if (DMR_PDU[1] != 0x10) goto LRRP_END; //check to see if FID is 0x10
|
||||
i = 0;
|
||||
message_len = blocks * block_len;
|
||||
source = state->dmr_lrrp_source[state->currentslot];
|
||||
is_p_head = 1;
|
||||
}
|
||||
else i = 12;
|
||||
|
||||
|
||||
//start looking for tokens (using my best understanding of the ok-dmr library xml and python files)
|
||||
for (i; i < ( (blocks*block_len) - (padding+4) ); i++)
|
||||
for (i = 0; i < ( (blocks*block_len) - (padding+4) ); i++)
|
||||
{
|
||||
|
||||
switch(DMR_PDU[i]){
|
||||
@@ -175,20 +168,22 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
}
|
||||
break;
|
||||
//RESULT TOKEN or Request ID!
|
||||
case 0x22: //same comment as below, observed followed the message len
|
||||
case 0x23: //this value has been seen after the 0x0D message len, appears to be a 2-byte value, was tripping a false on time stamp
|
||||
i += 2;
|
||||
break;
|
||||
//answer and report tokens
|
||||
case 0x51: //circle-2d
|
||||
case 0x54: //circle-3d
|
||||
case 0x55: //circle-3d <- false positives on one sample, so either an earlier token occurred (that we don't have) or just random data?
|
||||
case 0x55: //circle-3d
|
||||
if (message_len > 0 && lat == 0)
|
||||
{
|
||||
if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
|
||||
lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lon = ( ( ((DMR_PDU[i+5] & 0x7F ) << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
lat = ( ( (DMR_PDU[i+1] << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
lon = ( ( (DMR_PDU[i+5] << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
rad = (DMR_PDU[i+9] << 8) + DMR_PDU[i+10];
|
||||
i += 10; //double check
|
||||
i += 10;
|
||||
if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
|
||||
else lat = 0;
|
||||
}
|
||||
@@ -211,13 +206,14 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x66: //point-2d
|
||||
case 0x66: //point-2d
|
||||
if (message_len > 0 && lat == 0)
|
||||
{
|
||||
if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
|
||||
lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lon = ( ( ((DMR_PDU[i+5] & 0x7F ) << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
lat = ( ( (DMR_PDU[i+1] << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
lon = ( ( (DMR_PDU[i+5] << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
i += 8; //check
|
||||
i += 8;
|
||||
lrrp_confidence++;
|
||||
}
|
||||
break;
|
||||
@@ -225,12 +221,13 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
case 0x6A: //point-3d
|
||||
if (message_len > 0 && lat == 0)
|
||||
{
|
||||
if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
|
||||
lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lat = ( ( ((DMR_PDU[i+1] & 0x7F ) << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
// lon = ( ( ((DMR_PDU[i+5] & 0x7F ) << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
lat = ( ( (DMR_PDU[i+1] << 24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
|
||||
lon = ( ( (DMR_PDU[i+5] << 24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
|
||||
alt = DMR_PDU[i+9];
|
||||
i += 9; //check
|
||||
if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
|
||||
i += 9;
|
||||
if (lat > 0 && lon > 0) lrrp_confidence++;
|
||||
else lat = 0;
|
||||
}
|
||||
break;
|
||||
@@ -274,7 +271,7 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, "\n LRRP Confidence: %d - Message Len: %d Octets", lrrp_confidence, message_len);
|
||||
if (lrrp_confidence >= 4) //find the sweet magical number
|
||||
if (lrrp_confidence >= 3) //find the sweet magical number
|
||||
{
|
||||
//now we can open our lrrp file and write to it as well
|
||||
FILE * pFile; //file pointer
|
||||
@@ -286,9 +283,10 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
if (!year) fprintf (pFile, "%s\t", getDateL() ); //current date, only add this IF no included timestamp in LRRP data?
|
||||
if (!year) fprintf (pFile, "%s\t", getTimeL() ); //current timestamp, only add this IF no included timestamp in LRRP data?
|
||||
if (year) fprintf (pFile, "%04d/%02d/%02d\t%02d:%02d:%02d\t", year, month, day, hour, minute, second); //add timestamp from decoded audio if available
|
||||
//write data header source (or destination?) if not available in lrrp data
|
||||
//write data header source if not available in lrrp data
|
||||
if (!source) fprintf (pFile, "%08lld\t", state->dmr_lrrp_source[state->currentslot]); //source address from data header
|
||||
if (source) fprintf (pFile, "%08d\t", source); //add source form decoded audio if available, else its from the header
|
||||
|
||||
}
|
||||
|
||||
if (pot_report)
|
||||
@@ -328,31 +326,45 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
if (lat)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
if (lat_sign) //print a '-' in front of the value
|
||||
fprintf (stderr, " LRRP - Lat: -%.5lf", (double)lat * lat_unit);
|
||||
else fprintf (stderr, " LRRP - Lat: %.5lf", (double)lat * lat_unit);
|
||||
fprintf (stderr, " Lon: %.5lf", (double)lon * lon_unit);
|
||||
if (lat_sign)
|
||||
fprintf (stderr, " (-%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
|
||||
else fprintf (stderr, " (%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
|
||||
//need to check these new calcs for accuracy accross the globe, both lat and lon
|
||||
|
||||
//two's compliment-ish testing on these bytes
|
||||
if (lat & 0x80000000) //8
|
||||
{
|
||||
lat = lat & 0x7FFFFFFF;
|
||||
lat_sign = -1;
|
||||
// lat = 0x80000000 - lat; //not sure why this doesn't work here like it does on lon, extra bit?
|
||||
}
|
||||
if (lon & 0x80000000)
|
||||
{
|
||||
lon = lon & 0x7FFFFFFF;
|
||||
lon_sign = -1;
|
||||
lon = 0x80000000 - lon;
|
||||
}
|
||||
|
||||
lat_fin = (double)lat * lat_unit * lat_sign;
|
||||
lon_fin = (double)lon * lon_unit * lon_sign;
|
||||
|
||||
fprintf (stderr, " LRRP - Lat: %.5lf", lat_fin);
|
||||
fprintf (stderr, " Lon: %.5lf", lon_fin);
|
||||
fprintf (stderr, " (%.5lf, %.5lf)", lat_fin , lon_fin);
|
||||
|
||||
if (opts->lrrp_file_output == 1)
|
||||
{
|
||||
if (lat_sign) fprintf (pFile, "-");
|
||||
fprintf (pFile, "%.5lf\t", (double)lat * lat_unit);
|
||||
fprintf (pFile, "%.5lf\t", (double)lon * lon_unit);
|
||||
fprintf (pFile, "%.5lf\t", lat_fin);
|
||||
fprintf (pFile, "%.5lf\t", lon_fin);
|
||||
}
|
||||
|
||||
}
|
||||
if (rad)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, " LRRP - Radius: %d", rad); //unsure of 'units' or calculation for radius (meters?)
|
||||
fprintf (stderr, " LRRP - Radius: %dm", rad); //unsure of 'units' or calculation for radius (meters?)
|
||||
}
|
||||
if (alt)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, " LRRP - Altitude: %d", alt); //unsure of 'units' or calculation for alt (meters?)
|
||||
fprintf (stderr, " LRRP - Altitude: %dm", alt); //unsure of 'units' or calculation for alt (meters?)
|
||||
}
|
||||
if (vel_set)
|
||||
{
|
||||
@@ -363,7 +375,7 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
if (deg_set)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, " LRRP - Track: %d Degrees", degrees);
|
||||
fprintf (stderr, " LRRP - Track: %d%s", degrees, deg_glyph);
|
||||
if (opts->lrrp_file_output == 1) fprintf (pFile, "%d\t",degrees);
|
||||
}
|
||||
|
||||
@@ -374,20 +386,17 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
fclose (pFile);
|
||||
}
|
||||
|
||||
//save to array for ncurses
|
||||
//save to string for ncurses
|
||||
if (!source) source = state->dmr_lrrp_source[state->currentslot];
|
||||
char sign[8];
|
||||
char velstr[20];
|
||||
char degstr[20];
|
||||
char lrrpstr[100];
|
||||
sprintf (lrrpstr, "%s", "");
|
||||
sprintf (velstr, "%s", "");
|
||||
sprintf (degstr, "%s", "");
|
||||
if (lat_sign) sprintf (sign, "%s", "-");
|
||||
else sprintf (sign, "%s", "");
|
||||
if (lat) sprintf (lrrpstr, "LRRP %0d (%s%lf, %lf)", source, sign, (double)lat * lat_unit, (double)lon * lon_unit);
|
||||
if (lat) sprintf (lrrpstr, "LRRP %0d (%lf, %lf)", source, lat_fin, lon_fin);
|
||||
if (vel_set) sprintf (velstr, " %.4lf km/h", velocity * 3.6);
|
||||
if (deg_set) sprintf (degstr, " %d deg", degrees);
|
||||
if (deg_set) sprintf (degstr, " %d%s ", degrees, deg_glyph);
|
||||
sprintf (state->dmr_lrrp_gps[slot], "%s%s%s", lrrpstr, velstr, degstr);
|
||||
|
||||
}
|
||||
@@ -400,16 +409,126 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
|
||||
fprintf (stderr, " Potential ARRP/LRRP Report (Debug): 0x%02X", report);
|
||||
}
|
||||
|
||||
// else //debug only, disabled
|
||||
// {
|
||||
// fprintf (stderr, "\n");
|
||||
// fprintf (stderr, "\n LRRP Confidence: %d - Message Len: %d Octets", lrrp_confidence, message_len);
|
||||
// }
|
||||
|
||||
LRRP_END:
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
|
||||
return (lrrp_confidence);
|
||||
}
|
||||
|
||||
void dmr_locn (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
|
||||
{
|
||||
int i, j;
|
||||
uint8_t slot = state->currentslot;
|
||||
uint8_t blocks = state->data_header_blocks[slot];
|
||||
uint8_t padding = state->data_header_padding[slot];
|
||||
uint8_t source = state->dmr_lrrp_source[slot];
|
||||
|
||||
//flags if certain data type is present
|
||||
uint8_t time = 0;
|
||||
uint8_t lat = 0;
|
||||
uint8_t lon = 0;
|
||||
|
||||
//date-time variables
|
||||
uint8_t hour = 0;
|
||||
uint8_t minute = 0;
|
||||
uint8_t second = 0;
|
||||
uint8_t year = 0;
|
||||
uint8_t month = 0;
|
||||
uint8_t day = 0;
|
||||
|
||||
//need to experiment best way to do this portion
|
||||
uint8_t lat_deg = 0;
|
||||
uint8_t lat_min = 0;
|
||||
uint16_t lat_sec = 0;
|
||||
|
||||
uint8_t lon_deg = 0;
|
||||
uint8_t lon_min = 0;
|
||||
uint16_t lon_sec = 0;
|
||||
|
||||
char lat_ord[2];
|
||||
char lon_ord[2];
|
||||
sprintf (lat_ord, "%s", "N");
|
||||
sprintf (lon_ord, "%s", "E");
|
||||
|
||||
char deg_glyph[4];
|
||||
sprintf (deg_glyph, "%s", "°");
|
||||
// sprintf (deg_glyph, "%s", "d");
|
||||
|
||||
//more strings...
|
||||
char locnstr[50];
|
||||
char latstr[75];
|
||||
char lonstr[75];
|
||||
sprintf (locnstr, "%s", " ");
|
||||
sprintf (latstr, "%s", " ");
|
||||
sprintf (lonstr, "%s", " ");
|
||||
|
||||
//TODO: conversion to decimal format
|
||||
//DD = d + (min/60) + (sec/3600)
|
||||
//N is positive, E is positive?? Assuming its like a 2D plane
|
||||
int lat_sign = 1; //positive 1 or negative 1
|
||||
int lon_sign = 1; //positive 1 or negative 1
|
||||
double lat_fin = 0;
|
||||
double lon_fin = 0;
|
||||
|
||||
//start looking for specific bytes corresponding to 'letters' A (time), NSEW (ordinal directions), etc
|
||||
for (i = 0; i < ( (blocks*block_len) - (padding+4) ); i++)
|
||||
{
|
||||
switch(DMR_PDU[i]){
|
||||
case 0x41: //A -- time and date
|
||||
time = 1;
|
||||
hour = ((DMR_PDU[i+1] - 0x30) << 4) | (DMR_PDU[i+2] - 0x30);
|
||||
minute = ((DMR_PDU[i+3] - 0x30) << 4) | (DMR_PDU[i+4] - 0x30);
|
||||
second = ((DMR_PDU[i+5] - 0x30) << 4) | (DMR_PDU[i+6] - 0x30);
|
||||
//think this is in day, mon, year format
|
||||
day = ((DMR_PDU[i+7] - 0x30) << 4) | (DMR_PDU[i+8] - 0x30);
|
||||
month = ((DMR_PDU[i+9] - 0x30) << 4) | (DMR_PDU[i+10] - 0x30);
|
||||
year = ((DMR_PDU[i+11] - 0x30) << 4) | (DMR_PDU[i+12] - 0x30);
|
||||
i += 12;
|
||||
break;
|
||||
|
||||
case 0x53: //S -- South
|
||||
sprintf (lat_ord, "%s", "S");
|
||||
lat_sign = -1;
|
||||
case 0x4E: //N -- North
|
||||
lat = 1;
|
||||
lat_deg = ((DMR_PDU[i+1] - 0x30) << 4) | (DMR_PDU[i+2] - 0x30);
|
||||
lat_min = ((DMR_PDU[i+3] - 0x30) << 4) | (DMR_PDU[i+4] - 0x30);
|
||||
lat_sec = ((DMR_PDU[i+6] - 0x30) << 12) | ((DMR_PDU[i+7] - 0x30) << 8) | ((DMR_PDU[i+8] - 0x30) << 4) | ((DMR_PDU[i+9] - 0x30) << 0);
|
||||
i += 8;
|
||||
break;
|
||||
|
||||
case 0x57: //W -- West
|
||||
sprintf (lon_ord, "%s", "W");
|
||||
lon_sign = -1;
|
||||
case 0x45: //E -- East
|
||||
lon = 1;
|
||||
lon_deg = ((DMR_PDU[i+1] - 0x30) << 8) | ((DMR_PDU[i+2] - 0x30) << 4) | ((DMR_PDU[i+3] - 0x30) << 0);
|
||||
lon_min = ((DMR_PDU[i+4] - 0x30) << 4) | (DMR_PDU[i+5] - 0x30);
|
||||
lon_sec = ((DMR_PDU[i+7] - 0x30) << 12) | ((DMR_PDU[i+8] - 0x30) << 8) | ((DMR_PDU[i+9] - 0x30) << 4) | ((DMR_PDU[i+10] - 0x30) << 0);
|
||||
i += 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
//do nothing
|
||||
break;
|
||||
|
||||
} //end switch
|
||||
|
||||
} //for i
|
||||
|
||||
if (lat && lon)
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, "\n LOCN Report - Source: [%d]\n", source);
|
||||
if (time) fprintf (stderr, " 20%02X/%02X/%02X %02X:%02X:%02X ", year, month, day, hour, minute, second);
|
||||
fprintf (stderr, "Lat: %s %02X%s%02X\"%04X' Lon: %s %02X%s%02X\"%04X' ", lat_ord, lat_deg, deg_glyph, lat_min, lat_sec, lon_ord, lon_deg, deg_glyph, lon_min, lon_sec);
|
||||
|
||||
//string manip for ncurses terminal display
|
||||
sprintf (locnstr, "LOCN %d ", source);
|
||||
sprintf (latstr, "%s %02X%s%02X\"%04X' ", lat_ord, lat_deg, deg_glyph, lat_min, lat_sec);
|
||||
sprintf (lonstr, "%s %02X%s%02X\"%04X' ", lon_ord, lon_deg, deg_glyph, lon_min, lon_sec);
|
||||
sprintf (state->dmr_lrrp_gps[slot], "%s%s%s", locnstr, latstr, lonstr);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
114
src/dmr_pi.c
114
src/dmr_pi.c
@@ -15,15 +15,11 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
|
||||
|
||||
if((IrrecoverableErrors == 0))
|
||||
{
|
||||
|
||||
if (state->currentslot == 0)
|
||||
{
|
||||
|
||||
if (0 == 0)
|
||||
{
|
||||
state->payload_algid = PI_BYTE[0];
|
||||
state->payload_keyid = PI_BYTE[2];
|
||||
}
|
||||
|
||||
state->payload_algid = PI_BYTE[0];
|
||||
state->payload_keyid = PI_BYTE[2];
|
||||
state->payload_mi = ( ((PI_BYTE[3]) << 24) + ((PI_BYTE[4]) << 16) + ((PI_BYTE[5]) << 8) + (PI_BYTE[6]) );
|
||||
if (state->payload_algid < 0x26)
|
||||
{
|
||||
@@ -31,27 +27,26 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
|
||||
fprintf (stderr, "\n Slot 1");
|
||||
fprintf (stderr, " DMR PI H- ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08X", state->payload_algid, state->payload_keyid, state->payload_mi);
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
if (state->payload_algid != 0x21)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
LFSR64 (state);
|
||||
}
|
||||
}
|
||||
|
||||
if (state->payload_algid >= 0x26)
|
||||
{
|
||||
if (0 == 0)
|
||||
{
|
||||
state->payload_algid = 0;
|
||||
state->payload_keyid = 0;
|
||||
state->payload_mi = 0;
|
||||
}
|
||||
state->payload_algid = 0;
|
||||
state->payload_keyid = 0;
|
||||
state->payload_mi = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (state->currentslot == 1)
|
||||
{
|
||||
if (0 == 0)
|
||||
{
|
||||
state->payload_algidR = PI_BYTE[0];
|
||||
state->payload_keyidR = PI_BYTE[2];
|
||||
}
|
||||
|
||||
state->payload_algidR = PI_BYTE[0];
|
||||
state->payload_keyidR = PI_BYTE[2];
|
||||
state->payload_miR = ( ((PI_BYTE[3]) << 24) + ((PI_BYTE[4]) << 16) + ((PI_BYTE[5]) << 8) + (PI_BYTE[6]) );
|
||||
if (state->payload_algidR < 0x26)
|
||||
{
|
||||
@@ -59,20 +54,23 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
|
||||
fprintf (stderr, "\n Slot 2");
|
||||
fprintf (stderr, " DMR PI H- ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08X", state->payload_algidR, state->payload_keyidR, state->payload_miR);
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
if (state->payload_algidR != 0x21)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
LFSR64 (state);
|
||||
}
|
||||
}
|
||||
|
||||
if (state->payload_algidR >= 0x26)
|
||||
{
|
||||
if (0== 0)
|
||||
{
|
||||
state->payload_algidR = 0;
|
||||
state->payload_keyidR = 0;
|
||||
state->payload_miR = 0;
|
||||
}
|
||||
state->payload_algidR = 0;
|
||||
state->payload_keyidR = 0;
|
||||
state->payload_miR = 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void LFSR(dsd_state * state)
|
||||
@@ -95,27 +93,67 @@ void LFSR(dsd_state * state)
|
||||
|
||||
if (state->currentslot == 0)
|
||||
{
|
||||
if (1 == 1)
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Slot 1");
|
||||
fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
|
||||
fprintf(stderr, " Next MI: 0x%08X", lfsr);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Slot 1");
|
||||
fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
|
||||
fprintf(stderr, " MI: 0x%08X", lfsr);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
state->payload_mi = lfsr;
|
||||
}
|
||||
|
||||
if (state->currentslot == 1)
|
||||
{
|
||||
if (1 == 1)
|
||||
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Slot 2");
|
||||
fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
|
||||
fprintf(stderr, " MI: 0x%08X", lfsr);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
state->payload_miR = lfsr;
|
||||
}
|
||||
}
|
||||
|
||||
void LFSR64(dsd_state * state)
|
||||
{
|
||||
{
|
||||
uint64_t lfsr = 0;
|
||||
|
||||
if (state->currentslot == 0)
|
||||
{
|
||||
lfsr = (uint64_t) state->payload_mi;
|
||||
}
|
||||
else lfsr = (uint64_t) state->payload_miR;
|
||||
|
||||
uint8_t cnt = 0;
|
||||
|
||||
for(cnt=0;cnt<32;cnt++)
|
||||
{
|
||||
uint64_t bit = ( (lfsr >> 31) ^ (lfsr >> 21) ^ (lfsr >> 1) ^ (lfsr >> 0) ) & 0x1;
|
||||
lfsr = (lfsr << 1) | bit;
|
||||
}
|
||||
|
||||
// if (state->currentslot == 0) state->payload_miP = lfsr;
|
||||
// else state->payload_miN = lfsr;
|
||||
|
||||
if (state->currentslot == 0)
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Slot 1");
|
||||
fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
|
||||
fprintf (stderr, " MI: 0x%016lX", lfsr);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
state->payload_mi = lfsr & 0xFFFFFFFF; //truncate for next repitition and le verification
|
||||
}
|
||||
|
||||
if (state->currentslot == 1)
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf (stderr, " Slot 2");
|
||||
fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
|
||||
fprintf(stderr, " Next MI: 0x%08X", lfsr);
|
||||
fprintf (stderr, " MI: 0x%016lX", lfsr);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
state->payload_miR = lfsr;
|
||||
}
|
||||
state->payload_miR = lfsr & 0xFFFFFFFF; //truncate for next repitition and le verification
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -283,12 +283,11 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
|
||||
|
||||
valid = 0;
|
||||
|
||||
//only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
|
||||
//honestly can't say I've seen any improvement when using heuristics, but is detrimental to playing back multiple p25 samples
|
||||
if (state->synctype == 1 && opts->p25_trunk == 0)
|
||||
//disabling again, causing issues with trunking P25
|
||||
if (state->synctype == 1 && opts->p25_trunk == 1)
|
||||
{
|
||||
// Use the P25 heuristics if available
|
||||
//valid = estimate_symbol(state->rf_mod, &(state->inv_p25_heuristics), state->last_dibit, symbol, &dibit);
|
||||
// valid = estimate_symbol(state->rf_mod, &(state->inv_p25_heuristics), state->last_dibit, symbol, &dibit);
|
||||
}
|
||||
|
||||
if (valid == 0)
|
||||
@@ -348,12 +347,11 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
|
||||
|
||||
valid = 0;
|
||||
|
||||
//only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
|
||||
//honestly can't say I've seen any improvement when using heuristics, but is detrimental to playing back multiple p25 samples
|
||||
if (state->synctype == 0 && opts->p25_trunk == 0)
|
||||
//disabling again, causing issues with trunking P25
|
||||
if (state->synctype == 0 && opts->p25_trunk == 1)
|
||||
{
|
||||
// Use the P25 heuristics if available
|
||||
//valid = estimate_symbol(state->rf_mod, &(state->p25_heuristics), state->last_dibit, symbol, &dibit);
|
||||
// valid = estimate_symbol(state->rf_mod, &(state->p25_heuristics), state->last_dibit, symbol, &dibit);
|
||||
}
|
||||
|
||||
if (valid == 0)
|
||||
|
||||
@@ -146,7 +146,7 @@ int csvChanImport(dsd_opts * opts, dsd_state * state) //channel map import
|
||||
return 0;
|
||||
}
|
||||
|
||||
int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXDN
|
||||
int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support
|
||||
{
|
||||
char filename[1024] = "filename.csv";
|
||||
sprintf (filename, "%s", opts->key_in_file);
|
||||
@@ -160,7 +160,13 @@ int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXD
|
||||
}
|
||||
int row_count = 0;
|
||||
int field_count = 0;
|
||||
unsigned long long int keynumber;
|
||||
|
||||
unsigned long long int keynumber = 0;
|
||||
unsigned long long int keyvalue = 0;
|
||||
|
||||
uint16_t hash = 0;
|
||||
uint8_t hash_bits[24];
|
||||
memset (hash_bits, 0, sizeof(hash_bits));
|
||||
|
||||
while (fgets(buffer, BSIZE, fp)) {
|
||||
field_count = 0;
|
||||
@@ -173,11 +179,24 @@ int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXD
|
||||
if (field_count == 0)
|
||||
{
|
||||
sscanf (field, "%lld", &keynumber);
|
||||
if (keynumber > 0xFFFF) //if larger than 16-bits, get its hash instead
|
||||
{
|
||||
keynumber = keynumber & 0xFFFFFF; //truncate to 24-bits (max allowed)
|
||||
for (int i = 0; i < 24; i++)
|
||||
{
|
||||
hash_bits[i] = ((keynumber << i) & 0x800000) >> 23; //load into array for CRC16
|
||||
}
|
||||
hash = ComputeCrcCCITT16d (hash_bits, 24);
|
||||
keynumber = hash & 0xFFFF; //make sure its no larger than 16-bits
|
||||
fprintf (stderr, "Hashed ");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (field_count == 1)
|
||||
{
|
||||
sscanf (field, "%lld", &state->rkey_array[keynumber]);
|
||||
sscanf (field, "%lld", &keyvalue);
|
||||
state->rkey_array[keynumber] = keyvalue & 0xFFFFFFFFFF; //doesn't exceed 40-bit value
|
||||
}
|
||||
|
||||
field = strtok(NULL, ",");
|
||||
@@ -185,6 +204,7 @@ int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXD
|
||||
}
|
||||
fprintf (stderr, "Key [%03lld] [%05lld]", keynumber, state->rkey_array[keynumber]);
|
||||
fprintf (stderr, "\n");
|
||||
hash = 0;
|
||||
|
||||
}
|
||||
fclose(fp);
|
||||
|
||||
225
src/dsd_main.c
225
src/dsd_main.c
@@ -52,11 +52,10 @@ char * FM_banner[9] = {
|
||||
" ██║ ██║ ╚═══██╗██║ ██║ ██╔══╝ ██║╚██╔╝██║██╔══╝ ",
|
||||
" ██████╔╝██████╔╝██████╔╝ ██║ ██║ ╚═╝ ██║███████╗",
|
||||
" ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚══════╝",
|
||||
" 'Lite' Edition v2.0.0-28-ga02f992 Windows 32-bit RC3 "
|
||||
" 'Lite' Edition v2.0.0-40-gc999c97 Windows 32-bit RC4 "
|
||||
};
|
||||
|
||||
int
|
||||
comp (const void *a, const void *b)
|
||||
int comp (const void *a, const void *b)
|
||||
{
|
||||
if (*((const int *) a) == *((const int *) b))
|
||||
return 0;
|
||||
@@ -255,12 +254,12 @@ noCarrier (dsd_opts * opts, dsd_state * state)
|
||||
state->data_header_blocks[1] = 1; //when trying to fill the superframe and 0-1 blocks give us an overflow
|
||||
state->data_header_padding[0] = 0;
|
||||
state->data_header_padding[1] = 0;
|
||||
state->data_header_format[0] = 0;
|
||||
state->data_header_format[1] = 0;
|
||||
state->data_header_format[0] = 7;
|
||||
state->data_header_format[1] = 7;
|
||||
state->data_header_sap[0] = 0;
|
||||
state->data_header_sap[1] = 0;
|
||||
state->data_block_counter[0] = 0;
|
||||
state->data_block_counter[1] = 0;
|
||||
state->data_block_counter[0] = 1;
|
||||
state->data_block_counter[1] = 1;
|
||||
state->data_p_head[0] = 0;
|
||||
state->data_p_head[1] = 0;
|
||||
|
||||
@@ -289,7 +288,7 @@ noCarrier (dsd_opts * opts, dsd_state * state)
|
||||
state->nxdn_sf = 0;
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc)); //init on 1, bad CRC all
|
||||
state->nxdn_sacch_non_superframe = TRUE;
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
state->nxdn_alias_block_number = 0;
|
||||
memset (state->nxdn_alias_block_segment, 0, sizeof(state->nxdn_alias_block_segment));
|
||||
sprintf (state->nxdn_call_type, "%s", "");
|
||||
@@ -303,7 +302,11 @@ noCarrier (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
//initialize unified dmr pdu 'superframe'
|
||||
memset (state->dmr_pdu_sf, 0, sizeof (state->dmr_pdu_sf));
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
memset (state->data_header_valid, 0, sizeof(state->data_header_valid));
|
||||
|
||||
//initialize cap+ bits and block num storage
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
state->cap_plus_block_num = 0;
|
||||
|
||||
//init confirmed data individual block crc as invalid
|
||||
memset (state->data_block_crc_valid, 0, sizeof(state->data_block_crc_valid));
|
||||
@@ -736,12 +739,12 @@ initState (dsd_state * state)
|
||||
state->data_header_blocks[1] = 1; //when trying to fill the superframe and 0-1 blocks give us an overflow
|
||||
state->data_header_padding[0] = 0;
|
||||
state->data_header_padding[1] = 0;
|
||||
state->data_header_format[0] = 0;
|
||||
state->data_header_format[1] = 0;
|
||||
state->data_header_format[0] = 7;
|
||||
state->data_header_format[1] = 7;
|
||||
state->data_header_sap[0] = 0;
|
||||
state->data_header_sap[1] = 0;
|
||||
state->data_block_counter[0] = 0;
|
||||
state->data_block_counter[1] = 0;
|
||||
state->data_block_counter[0] = 1;
|
||||
state->data_block_counter[1] = 1;
|
||||
state->data_p_head[0] = 0;
|
||||
state->data_p_head[1] = 0;
|
||||
|
||||
@@ -812,7 +815,7 @@ initState (dsd_state * state)
|
||||
state->nxdn_sf = 0;
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc)); //init on 1, bad CRC all
|
||||
state->nxdn_sacch_non_superframe = TRUE;
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
state->nxdn_alias_block_number = 0;
|
||||
memset (state->nxdn_alias_block_segment, 0, sizeof(state->nxdn_alias_block_segment));
|
||||
//site/srv/cch info
|
||||
@@ -833,7 +836,11 @@ initState (dsd_state * state)
|
||||
|
||||
//initialize unified dmr pdu 'superframe'
|
||||
memset (state->dmr_pdu_sf, 0, sizeof (state->dmr_pdu_sf));
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
memset (state->data_header_valid, 0, sizeof(state->data_header_valid));
|
||||
|
||||
//initialize cap+ bits and block num storage
|
||||
memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
|
||||
state->cap_plus_block_num = 0;
|
||||
|
||||
//init confirmed data individual block crc as invalid
|
||||
memset (state->data_block_crc_valid, 0, sizeof(state->data_block_crc_valid));
|
||||
@@ -970,7 +977,7 @@ usage ()
|
||||
//printf (" (4 Level, not 8 Level LSM) (this is honestly unknown since I can't verify what local systems are using)\n");
|
||||
printf (" -F Relax P25 Phase 2 MAC_SIGNAL CRC Checksum Pass/Fail\n");
|
||||
printf (" Use this feature to allow MAC_SIGNAL even if CRC errors.\n");
|
||||
printf (" -F Relax DMR CACH/Burst FEC or RAS/CRC CSBK Pass/Fail\n");
|
||||
printf (" -F Relax DMR RAS/CRC CSBK/DATA Pass/Fail\n");
|
||||
printf (" Enabling on some systems could lead to bad voice/data decoding if bad or marginal signal\n");
|
||||
printf ("\n");
|
||||
printf (" -K <dec> Manually Enter Basic Privacy Key (Decimal Value of Key Number)\n");
|
||||
@@ -982,7 +989,10 @@ usage ()
|
||||
printf (" -H '20029736A5D91042 C923EB0697484433 005EFC58A1905195 E28E9C7836AA2DB8' \n");
|
||||
printf ("\n");
|
||||
printf (" -R <dec> Manually Enter dPMR or NXDN EHR Scrambler Key Value (Decimal Value)\n");
|
||||
printf (" -k <file> Import NXDN Scrambler Key List from csv file.\n");
|
||||
printf (" \n");
|
||||
printf (" -k <file> Import Key List from csv file.\n");
|
||||
printf (" Only supports NXDN, DMR Basic Privacy and **tera 10-Char (decimal value) only. \n");
|
||||
printf (" (dPMR and **tera 32/64 char not supported, DMR uses TG value as key id -- EXPERIMENTAL!!). \n");
|
||||
printf (" \n");
|
||||
printf (" -4 Force Privacy Key over FID and SVC bits \n");
|
||||
printf ("\n");
|
||||
@@ -1147,22 +1157,6 @@ cleanupAndExit (dsd_opts * opts, dsd_state * state)
|
||||
exit (0);
|
||||
}
|
||||
|
||||
// void
|
||||
// sigfun (int sig) //not convinced this is truly required, maybe some environments require it?
|
||||
// {
|
||||
// exitflag = 1;
|
||||
// #ifdef USE_RTLSDR
|
||||
// // if (opts->audio_in_type == 3)
|
||||
// //rtlsdr_sighandler();
|
||||
// #endif
|
||||
// signal (SIGINT, SIG_DFL);
|
||||
// ncursesClose ();
|
||||
|
||||
// // #ifdef USE_RTLSDR
|
||||
// // if (opts->audio_in_type == 3) rtlsdr_sighandler();
|
||||
// // #endif
|
||||
// }
|
||||
|
||||
double atofs(char *s)
|
||||
{
|
||||
char last;
|
||||
@@ -1217,7 +1211,6 @@ main (int argc, char **argv)
|
||||
InitAllFecFunction();
|
||||
|
||||
exitflag = 0;
|
||||
// signal (SIGINT, sigfun);
|
||||
|
||||
while ((c = getopt (argc, argv, "haepPqs:t:v:z:i:o:d:c:g:nw:B:C:R:f:m:u:x:A:S:M:G:D:L:VU:Y:K:H:X:NQ:WrlZTF01:2:345:6:7:89:Ek:")) != -1)
|
||||
{
|
||||
@@ -1235,7 +1228,6 @@ main (int argc, char **argv)
|
||||
//make sure to put a colon : after each if they need an argument
|
||||
//or remove colon if no argument required
|
||||
|
||||
//Disabled the Serial Port Dev and Baud Rate, etc, If somebody uses that function, sorry...
|
||||
|
||||
case 'k': //NXDN multi-key loader
|
||||
strncpy(opts.key_in_file, optarg, 1023);
|
||||
@@ -1348,41 +1340,6 @@ main (int argc, char **argv)
|
||||
if (opts.setmod_bw > 25000) opts.setmod_bw = 25000; //not too high
|
||||
break;
|
||||
|
||||
// case 'e':
|
||||
// opts.errorbars = 1;
|
||||
// opts.datascope = 0;
|
||||
// break;
|
||||
// case 'p':
|
||||
// if (optarg[0] == 'e')
|
||||
// {
|
||||
// opts.p25enc = 1;
|
||||
// }
|
||||
// else if (optarg[0] == 'l')
|
||||
// {
|
||||
// opts.p25lc = 1;
|
||||
// }
|
||||
// else if (optarg[0] == 's')
|
||||
// {
|
||||
// opts.p25status = 1;
|
||||
// }
|
||||
// else if (optarg[0] == 't')
|
||||
// {
|
||||
// opts.p25tg = 1;
|
||||
// }
|
||||
// else if (optarg[0] == 'u')
|
||||
// {
|
||||
// opts.unmute_encrypted_p25 = 1;
|
||||
// fprintf(stderr, "P25 Encrypted Audio Unmuted\n");
|
||||
// }
|
||||
// break;
|
||||
// case 'P':
|
||||
// sscanf (optarg, "%d", &opts.rtlsdr_ppm_error);
|
||||
// break;
|
||||
// case 'q':
|
||||
// opts.errorbars = 0;
|
||||
// opts.verbose = 0;
|
||||
// break;
|
||||
|
||||
case 's':
|
||||
sscanf (optarg, "%d", &opts.wav_sample_rate);
|
||||
opts.wav_interpolator = opts.wav_sample_rate / opts.wav_decimator;
|
||||
@@ -1390,12 +1347,6 @@ main (int argc, char **argv)
|
||||
state.symbolCenter = state.symbolCenter * opts.wav_interpolator;
|
||||
break;
|
||||
|
||||
// case 't':
|
||||
// opts.symboltiming = 1;
|
||||
// opts.errorbars = 1;
|
||||
// opts.datascope = 0;
|
||||
// break;
|
||||
|
||||
case 'v':
|
||||
sscanf (optarg, "%d", &opts.verbose);
|
||||
break;
|
||||
@@ -1474,30 +1425,6 @@ main (int argc, char **argv)
|
||||
}
|
||||
break;
|
||||
|
||||
// case 'G': //Set rtl device gain
|
||||
// sscanf (optarg, "%d", &opts.rtl_gain_value); //multiple value by ten to make it consitent with the way rtl_fm really works
|
||||
// break;
|
||||
|
||||
// case 'L': //Set rtl squelch level
|
||||
// sscanf (optarg, "%d", &opts.rtl_squelch_level); //set squelch by user to prevent false positives on NXDN and others
|
||||
// break;
|
||||
|
||||
// case 'V': //Set rtl voltage level
|
||||
// sscanf (optarg, "%d", &opts.rtl_volume_multiplier); //set 'volume' multiplier for rtl-sdr samples
|
||||
// break;
|
||||
|
||||
// case 'U': //Set rtl udp remote port
|
||||
// sscanf (optarg, "%d", &opts.rtl_udp_port); //set udp port number for RTL remote
|
||||
// break;
|
||||
|
||||
// case 'D': //Set rtl device index number
|
||||
// sscanf (optarg, "%d", &opts.rtl_dev_index);
|
||||
// break;
|
||||
|
||||
// case 'Y': //Set rtl VFO bandwidth --recommend 6, 12, 24, 36, 48, default 48? or 12?
|
||||
// sscanf (optarg, "%d", &opts.rtl_bandwidth);
|
||||
// break;
|
||||
|
||||
case 'N':
|
||||
opts.use_ncurses_terminal = 1;
|
||||
fprintf (stderr,"Enabling NCurses Terminal.\n");
|
||||
@@ -1537,22 +1464,10 @@ main (int argc, char **argv)
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
//fprintf (stderr,"DMR Stereo Aggressive Resync Disabled!\n");
|
||||
fprintf (stderr, "Relax P25 Phase 2 MAC_SIGNAL CRC Checksum Pass/Fail\n");
|
||||
fprintf (stderr, "Relax DMR CACH/Burst FEC or RAS/CRC CSBK Pass/Fail\n");
|
||||
fprintf (stderr, "Relax DMR RAS/CRC CSBK/DATA Pass/Fail\n");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
break;
|
||||
|
||||
// case 'z':
|
||||
// sscanf (optarg, "%d", &opts.scoperate);
|
||||
// opts.errorbars = 0;
|
||||
// opts.p25enc = 0;
|
||||
// opts.p25lc = 0;
|
||||
// opts.p25status = 0;
|
||||
// opts.p25tg = 0;
|
||||
// opts.datascope = 1;
|
||||
// opts.symboltiming = 0;
|
||||
// fprintf (stderr,"Setting datascope frame rate to %i frame per second.\n", opts.scoperate);
|
||||
// break;
|
||||
|
||||
case 'i':
|
||||
strncpy(opts.audio_in_dev, optarg, 2047);
|
||||
opts.audio_in_dev[2047] = '\0';
|
||||
@@ -1574,11 +1489,6 @@ main (int argc, char **argv)
|
||||
// fprintf (stderr,"Writing mbe data temporarily disabled!\n");
|
||||
break;
|
||||
|
||||
// case 'c':
|
||||
// opts.rtlsdr_center_freq = (uint32_t)atofs(optarg);
|
||||
// fprintf (stderr,"Tuning to frequency: %i Hz\n", opts.rtlsdr_center_freq);
|
||||
// break;
|
||||
|
||||
case 'c': //now is symbol capture bin output like FME Lite
|
||||
strncpy(opts.symbol_out_file, optarg, 1023);
|
||||
opts.symbol_out_file[1023] = '\0';
|
||||
@@ -1617,15 +1527,6 @@ main (int argc, char **argv)
|
||||
openWavOutFile (&opts, &state);
|
||||
break;
|
||||
|
||||
// case 'B':
|
||||
// sscanf (optarg, "%d", &opts.serial_baud);
|
||||
// break;
|
||||
|
||||
// case 'C':
|
||||
// strncpy(opts.serial_dev, optarg, 1023);
|
||||
// opts.serial_dev[1023] = '\0';
|
||||
// break;
|
||||
|
||||
case 'f':
|
||||
if (optarg[0] == 'a')
|
||||
{
|
||||
@@ -1644,7 +1545,7 @@ main (int argc, char **argv)
|
||||
opts.dmr_stereo = 1; //switching in 'stereo' for 'mono'
|
||||
opts.dmr_mono = 0;
|
||||
state.dmr_stereo = 0;
|
||||
opts.setmod_bw = 7000;
|
||||
//opts.setmod_bw = 7000;
|
||||
sprintf (opts.output_name, "Legacy Auto");
|
||||
}
|
||||
else if (optarg[0] == 'd')
|
||||
@@ -1738,7 +1639,7 @@ main (int argc, char **argv)
|
||||
opts.dmr_mono = 0;
|
||||
opts.pulse_digi_rate_out = 48000;
|
||||
opts.pulse_digi_out_channels = 1;
|
||||
opts.setmod_bw = 7000;
|
||||
opts.setmod_bw = 12000;
|
||||
sprintf (opts.output_name, "P25P1");
|
||||
fprintf (stderr,"Decoding only P25 Phase 1 frames.\n");
|
||||
}
|
||||
@@ -1765,7 +1666,7 @@ main (int argc, char **argv)
|
||||
opts.dmr_stereo = 0;
|
||||
state.dmr_stereo = 0;
|
||||
opts.dmr_mono = 0;
|
||||
opts.setmod_bw = 4000;
|
||||
// opts.setmod_bw = 4000; //causing issues
|
||||
sprintf (opts.output_name, "NXDN48");
|
||||
fprintf (stderr,"Setting symbol rate to 2400 / second\n");
|
||||
fprintf (stderr,"Decoding only NXDN 4800 baud frames.\n");
|
||||
@@ -1819,7 +1720,7 @@ main (int argc, char **argv)
|
||||
opts.dmr_stereo = 1;
|
||||
state.dmr_stereo = 0;
|
||||
opts.dmr_mono = 0;
|
||||
opts.setmod_bw = 7000;
|
||||
opts.setmod_bw = 12000;
|
||||
sprintf (opts.output_name, "P25P2");
|
||||
fprintf (stderr,"Decoding P25-P2 frames C4FM or OP25 Symbol Captures!\n");
|
||||
}
|
||||
@@ -1870,7 +1771,7 @@ main (int argc, char **argv)
|
||||
state.rf_mod = 0;
|
||||
opts.dmr_stereo = 1;
|
||||
opts.dmr_mono = 0;
|
||||
opts.setmod_bw = 7000;
|
||||
opts.setmod_bw = 12000; //safe default on both DMR and P25
|
||||
opts.pulse_digi_rate_out = 24000;
|
||||
opts.pulse_digi_out_channels = 2;
|
||||
sprintf (opts.output_name, "XDMA");
|
||||
@@ -1897,7 +1798,7 @@ main (int argc, char **argv)
|
||||
opts.dmr_stereo = 0;
|
||||
opts.dmr_mono = 0;
|
||||
state.dmr_stereo = 0;
|
||||
opts.setmod_bw = 7000;
|
||||
// opts.setmod_bw = 7000; //causing issues
|
||||
sprintf (opts.output_name, "NXDN96");
|
||||
fprintf (stderr,"Decoding only NXDN 9600 baud frames.\n");
|
||||
}
|
||||
@@ -1924,30 +1825,9 @@ main (int argc, char **argv)
|
||||
state.dmr_stereo = 0; //0
|
||||
opts.setmod_bw = 7000;
|
||||
sprintf (opts.output_name, "DMR Mono");
|
||||
//fprintf(stderr, "Notice: DMR cannot autodetect polarity. \n Use -xr option if Inverted Signal expected.\n");
|
||||
fprintf(stderr, "Notice: DMR cannot autodetect polarity. \n Use -xr option if Inverted Signal expected.\n");
|
||||
fprintf (stderr,"Decoding only DMR Mono. \nUsing DMR Stereo '-fs' or XDMA '-ft' is highly encouraged.\n");
|
||||
//dmr stereo below
|
||||
// opts.frame_dstar = 0;
|
||||
// opts.frame_x2tdma = 0;
|
||||
// opts.frame_p25p1 = 0;
|
||||
// opts.frame_p25p2 = 0;
|
||||
// opts.inverted_p2 = 0;
|
||||
// opts.frame_nxdn48 = 0;
|
||||
// opts.frame_nxdn96 = 0;
|
||||
// opts.frame_dmr = 1;
|
||||
// opts.frame_dpmr = 0;
|
||||
// opts.frame_provoice = 0;
|
||||
// opts.frame_ysf = 0;
|
||||
// opts.mod_c4fm = 1;
|
||||
// opts.mod_qpsk = 0;
|
||||
// opts.mod_gfsk = 0;
|
||||
// state.rf_mod = 0;
|
||||
// opts.dmr_stereo = 1;
|
||||
// state.dmr_stereo = 0;
|
||||
// opts.pulse_digi_rate_out = 24000;
|
||||
// opts.pulse_digi_out_channels = 2;
|
||||
// sprintf (opts.output_name, "DMR Stereo");
|
||||
// fprintf (stderr,"Decoding DMR Stereo BS/MS Simplex\n");
|
||||
|
||||
}
|
||||
else if (optarg[0] == 'm')
|
||||
{
|
||||
@@ -1977,14 +1857,14 @@ main (int argc, char **argv)
|
||||
fprintf(stderr, "Decoding only dPMR frames.\n");
|
||||
}
|
||||
break;
|
||||
//don't mess with the modulations, doesn't really do anything meaningful anyways
|
||||
//don't mess with the modulations unless you really need to
|
||||
case 'm':
|
||||
if (optarg[0] == 'a')
|
||||
{
|
||||
// opts.mod_c4fm = 1;
|
||||
// opts.mod_qpsk = 1;
|
||||
// opts.mod_gfsk = 1;
|
||||
// state.rf_mod = 0;
|
||||
opts.mod_c4fm = 1;
|
||||
opts.mod_qpsk = 1;
|
||||
opts.mod_gfsk = 1;
|
||||
state.rf_mod = 0;
|
||||
fprintf (stderr,"Don't use the -ma switch.\n");
|
||||
}
|
||||
else if (optarg[0] == 'c')
|
||||
@@ -2023,6 +1903,29 @@ main (int argc, char **argv)
|
||||
opts.setmod_bw = 12000;
|
||||
fprintf (stderr,"Enabling 6000 sps P25p2 CQPSK.\n");
|
||||
}
|
||||
//test
|
||||
else if (optarg[0] == '3')
|
||||
{
|
||||
opts.mod_c4fm = 1;
|
||||
opts.mod_qpsk = 0;
|
||||
opts.mod_gfsk = 0;
|
||||
state.rf_mod = 0;
|
||||
state.samplesPerSymbol = 10;
|
||||
state.symbolCenter = 4;
|
||||
opts.setmod_bw = 12000;
|
||||
fprintf (stderr,"Enabling 6000 sps P25p2 C4FM.\n");
|
||||
}
|
||||
else if (optarg[0] == '4')
|
||||
{
|
||||
opts.mod_c4fm = 1;
|
||||
opts.mod_qpsk = 1;
|
||||
opts.mod_gfsk = 1;
|
||||
state.rf_mod = 0;
|
||||
state.samplesPerSymbol = 8;
|
||||
state.symbolCenter = 3;
|
||||
opts.setmod_bw = 12000;
|
||||
fprintf (stderr,"Enabling 6000 sps P25p2 all optimizations.\n");
|
||||
}
|
||||
break;
|
||||
case 'u':
|
||||
sscanf (optarg, "%i", &opts.uvquality);
|
||||
|
||||
@@ -140,6 +140,11 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
|
||||
unsigned long long int k;
|
||||
int x;
|
||||
|
||||
//24-bit TG to 16-bit hash
|
||||
uint16_t hash = 0;
|
||||
uint8_t hash_bits[24];
|
||||
memset (hash_bits, 0, sizeof(hash_bits));
|
||||
|
||||
int preempt = 0; //TDMA dual voice slot preemption(when using OSS output)
|
||||
|
||||
|
||||
@@ -293,6 +298,31 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
|
||||
mbe_demodulateAmbe3600x2450Data (ambe_fr);
|
||||
state->errs2 = mbe_eccAmbe3600x2450Data (ambe_fr, ambe_d);
|
||||
|
||||
//EXPERIMENTAL!!
|
||||
//load basic privacy key number from array by the tg value (if not forced)
|
||||
//currently only Moto BP and Hytera 10 Char BP (converted to decimal)
|
||||
if (state->M == 0)
|
||||
{
|
||||
//see if we need to hash a value larger than 16-bits
|
||||
hash = state->lasttg & 0xFFFFFF;
|
||||
if (hash > 0xFFFF) //if greater than 16-bits
|
||||
{
|
||||
for (int i = 0; i < 24; i++)
|
||||
{
|
||||
hash_bits[i] = ((hash << i) & 0x800000) >> 23; //load into array for CRC16
|
||||
}
|
||||
hash = ComputeCrcCCITT16d (hash_bits, 24);
|
||||
hash = hash & 0xFFFF; //make sure its no larger than 16-bits
|
||||
}
|
||||
if (state->rkey_array[hash] != 0)
|
||||
{
|
||||
state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
|
||||
state->K1 = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
|
||||
opts->dmr_mute_encL = 0;
|
||||
}
|
||||
// else opts->dmr_mute_encL = 1; //may cause issues for manual key entry (non-csv)
|
||||
}
|
||||
|
||||
if ( (state->K > 0 && state->dmr_so & 0x40 && state->payload_keyid == 0 && state->dmr_fid == 0x10) ||
|
||||
(state->K > 0 && state->M == 1) )
|
||||
{
|
||||
@@ -395,6 +425,31 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
|
||||
mbe_demodulateAmbe3600x2450Data (ambe_fr);
|
||||
state->errs2R = mbe_eccAmbe3600x2450Data (ambe_fr, ambe_d);
|
||||
|
||||
//EXPERIMENTAL!!
|
||||
//load basic privacy key number from array by the tg value (if not forced)
|
||||
//currently only Moto BP and Hytera 10 Char BP (converted to decimal)
|
||||
if (state->M == 0)
|
||||
{
|
||||
//see if we need to hash a value larger than 16-bits
|
||||
hash = state->lasttgR & 0xFFFFFF;
|
||||
if (hash > 0xFFFF) //if greater than 16-bits
|
||||
{
|
||||
for (int i = 0; i < 24; i++)
|
||||
{
|
||||
hash_bits[i] = ((hash << i) & 0x800000) >> 23; //load into array for CRC16
|
||||
}
|
||||
hash = ComputeCrcCCITT16d (hash_bits, 24);
|
||||
hash = hash & 0xFFFF; //make sure its no larger than 16-bits
|
||||
}
|
||||
if (state->rkey_array[hash] != 0)
|
||||
{
|
||||
state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
|
||||
state->K1 = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
|
||||
opts->dmr_mute_encR = 0;
|
||||
}
|
||||
// else opts->dmr_mute_encR = 1; //may cause issues for manual key entry (non-csv)
|
||||
}
|
||||
|
||||
if ( (state->K > 0 && state->dmr_soR & 0x40 && state->payload_keyidR == 0 && state->dmr_fidR == 0x10) ||
|
||||
(state->K > 0 && state->M == 1) )
|
||||
{
|
||||
|
||||
@@ -2061,7 +2061,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
if (opts->ncurses_compact == 1)
|
||||
{
|
||||
printw ("------------------------------------------------------------------------------\n");
|
||||
printw ("| Digital Speech Decoder: Florida Man Edition - Win32 %s \n", "v2.0.0-28-ga02f992 RC3");
|
||||
printw ("| Digital Speech Decoder: Florida Man Edition - Win32 %s \n", "v2.0.0-40-gc999c97 RC4");
|
||||
}
|
||||
if (opts->ncurses_compact == 0)
|
||||
{
|
||||
@@ -2072,8 +2072,8 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
if (i == 1) printw (" ESC to Menu");
|
||||
if (i == 2) printw (" 'q' to Quit ");
|
||||
if (i == 4) printw (" MBElib %s", versionstr);
|
||||
if (i == 5) printw (" %s ", "Win32 RC3"); //printw (" %s \n", GIT_TAG);
|
||||
if (i == 6) printw (" %s \n", "v2.0.0-28-ga02f992"); //printw (" %s \n", GIT_TAG);
|
||||
if (i == 5) printw (" %s ", "Win32 RC4"); //printw (" %s \n", GIT_TAG);
|
||||
if (i == 6) printw (" %s \n", "v2.0.0-40-gc999c97"); //printw (" %s \n", GIT_TAG);
|
||||
else printw ("\n");
|
||||
}
|
||||
attroff(COLOR_PAIR(6)); //6
|
||||
@@ -2178,6 +2178,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
{
|
||||
printw ("| Reverse Mute - Muting Unencrypted Voice\n");
|
||||
}
|
||||
if (opts->aggressive_framesync == 0) printw ("| Selective CRC ERR Bypass Enabled (RAS) \n");
|
||||
|
||||
printw ("------------------------------------------------------------------------------\n");
|
||||
attroff(COLOR_PAIR(4));
|
||||
@@ -2372,8 +2373,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
}
|
||||
else if (lls == 0 || lls == 1) //P1
|
||||
{
|
||||
// printw ("P25 P1 - WACN: [%05llX] SYS: [%03llX] NAC: [%03llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc);
|
||||
printw ("P25 P1 - [%05llX][%03llX][%03llX] RFSS: [%llX] SITE: [%llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc, state->p2_rfssid, state->p2_siteid);
|
||||
printw ("P25 P1 - [%05llX][%03llX][%03llX] RFSS: [%lld] SITE: [%lld] ", state->p2_wacn, state->p2_sysid, state->p2_cc, state->p2_rfssid, state->p2_siteid);
|
||||
if (state->p25_cc_freq != 0)
|
||||
{
|
||||
printw ("Freq: [%.06lf] MHz", (double)state->p25_cc_freq/1000000);
|
||||
@@ -2381,8 +2381,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
}
|
||||
else if (lls == 35 || lls == 36) //P2
|
||||
{
|
||||
// printw ("P25 P2 - WACN: [%05llX] SYS: [%03llX] NAC: [%03llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc);
|
||||
printw ("P25 P2 - [%05llX][%03llX][%03llX] RFSS: [%llX] SITE: [%llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc, state->p2_rfssid, state->p2_siteid);
|
||||
printw ("P25 P2 - [%05llX][%03llX][%03llX] RFSS: [%lld] SITE: [%lld] ", state->p2_wacn, state->p2_sysid, state->p2_cc, state->p2_rfssid, state->p2_siteid);
|
||||
if (state->p2_wacn == 0 || state->p2_sysid == 0 || state->p2_cc == 0)
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
@@ -2494,7 +2493,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
printw("AES-128");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algid == 0x84 || state->payload_algid == 0x25)
|
||||
if (state->payload_algid == 0x84 || state->payload_algid == 0x25 || state->payload_algid == 0x05)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("AES-256");
|
||||
@@ -2535,17 +2534,6 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
attron(COLOR_PAIR(4));
|
||||
|
||||
//Frequency Display
|
||||
if (state->p25_vc_freq[0] != 0)
|
||||
{
|
||||
attron(COLOR_PAIR(5));
|
||||
printw ("Frequency: [%.06lf] MHz ", (double)state->p25_vc_freq[0]/1000000);
|
||||
if (state->carrier == 1)
|
||||
{
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
}
|
||||
|
||||
if(state->dmrburstL == 16) //only during call
|
||||
{
|
||||
|
||||
@@ -2571,7 +2559,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
}
|
||||
|
||||
//LRRP
|
||||
if(state->dmrburstL != 16 && opts->p25_trunk == 0) //only during data and no trunking
|
||||
if(state->dmrburstL != 16) //only during data and no trunking //&& opts->p25_trunk == 0
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("%s", state->dmr_lrrp_gps[0]);
|
||||
@@ -2600,198 +2588,204 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
printw ("\n");
|
||||
|
||||
//Slot 2 [1]
|
||||
if (lls < 30 || lls == 35 || lls == 36){ //Don't print on MS mode
|
||||
printw ("| SLOT 2 - ");
|
||||
if (state->dmrburstR < 16 && state->carrier == 1 && state->lasttgR > 0 && state->lastsrcR > 0)
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
}
|
||||
printw ("TGT: [%8i] SRC: [%8i] ", state->lasttgR, state->lastsrcR);
|
||||
if (state->dmrburstR != 16 && state->carrier == 1 && state->lasttgR > 0 && state->lastsrcR > 0)
|
||||
{
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
|
||||
//REMUS! THIS IS THE OLD ONE
|
||||
// printw ("FID: [%02X] SVC: [%02X] ", state->dmr_fidR, state->dmr_soR);
|
||||
//THIS IS THE NEW ONE
|
||||
printw ("%s | ", state->call_string[1]);
|
||||
printw ("%s ", DMRBusrtTypes[state->dmrburstR]);
|
||||
if (opts->slot_preference == 0 && opts->audio_out_type == 5 && opts->audio_out == 1 && state->dmrburstR == 16 && state->dmrburstL == 16) printw ("*M*");
|
||||
printw ("\n");
|
||||
|
||||
printw ("| V XTRA | "); //10 spaces
|
||||
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && (state->dmr_soR & 0xCF) == 0x40) //4F or CF mask?
|
||||
{
|
||||
attron(COLOR_PAIR(5));
|
||||
printw (" **Pr** ");
|
||||
attroff(COLOR_PAIR(5));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && state->K > 0 && ((state->dmr_soR & 0xCF) == 0x40) && state->dmr_fidR == 0x10)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("Pr Key [%3lld] ", state->K);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && state->H > 0 && ((state->dmr_soR & 0xCF) == 0x40) && state->dmr_fidR == 0x68)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("**tera Pr Key [%010llX] ", state->H);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//ALG, KeyID, MI 2 //was keyidR
|
||||
if(state->dmrburstR == 16 && state->payload_algidR > 0 && (state->dmr_soR & 0xCF) == 0x40)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("ALG: [0x%02X] KEY: [0x%02X] MI: [0x%08X] ", state->payload_algidR, state->payload_keyidR, state->payload_miR);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//P25-P1 and P2
|
||||
if(state->dmrburstR > 19 && state->payload_algidR > 0 && state->payload_algidR != 0x80)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("ALG: [0x%02X] KEY: [0x%04X] MI: [0x%016llX] ", state->payload_algidR, state->payload_keyidR, state->payload_miN);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0xAA || state->payload_algidR == 0x21)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("ADP-RC4");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x81 || state->payload_algidR == 0x22)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("DES-OFB");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x83 || state->payload_algidR == 0x23)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("Triple DES");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x85 || state->payload_algidR == 0x24)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("AES-128");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x84 || state->payload_algidR == 0x25)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("AES-256");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x02)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("Hytera Full Encrypt");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//Call Types, may switch to the more robust version later?
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x40 && state->R == 0) //0100 0000
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **ENC** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x80)
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **Emergency** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x30) //0010 0000
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **Private Call** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
printw ("\n");
|
||||
|
||||
//printw ("| | ");
|
||||
printw ("| D XTRA | ");
|
||||
|
||||
attron(COLOR_PAIR(4));
|
||||
|
||||
//Frequency Display
|
||||
if (state->p25_vc_freq[1] != 0)
|
||||
{
|
||||
attron(COLOR_PAIR(5));
|
||||
printw ("Frequency: [%.06lf] MHz ", (double)state->p25_vc_freq[1]/1000000);
|
||||
if (state->carrier == 1)
|
||||
//Slot 2 [1] //Don't print on MS mode
|
||||
if (lls < 30 || lls == 35 || lls == 36)
|
||||
{
|
||||
printw ("| SLOT 2 - ");
|
||||
if (state->dmrburstR < 16 && state->carrier == 1 && state->lasttgR > 0 && state->lastsrcR > 0)
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
}
|
||||
printw ("TGT: [%8i] SRC: [%8i] ", state->lasttgR, state->lastsrcR);
|
||||
if (state->dmrburstR != 16 && state->carrier == 1 && state->lasttgR > 0 && state->lastsrcR > 0)
|
||||
{
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
}
|
||||
|
||||
if(state->dmrburstR == 16) //only during call
|
||||
{
|
||||
//REMUS! THIS IS THE OLD ONE
|
||||
// printw ("FID: [%02X] SVC: [%02X] ", state->dmr_fidR, state->dmr_soR);
|
||||
//THIS IS THE NEW ONE
|
||||
printw ("%s | ", state->call_string[1]);
|
||||
printw ("%s ", DMRBusrtTypes[state->dmrburstR]);
|
||||
if (opts->slot_preference == 0 && opts->audio_out_type == 5 && opts->audio_out == 1 && state->dmrburstR == 16 && state->dmrburstL == 16) printw ("*M*");
|
||||
printw ("\n");
|
||||
|
||||
//Embedded GPS (not LRRP)
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("%s ", state->dmr_embedded_gps[1]);
|
||||
printw ("| V XTRA | "); //10 spaces
|
||||
|
||||
//Embedded Talker Alias Blocks
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int j = 0; j < 7; j++)
|
||||
{
|
||||
printw ("%s", state->dmr_alias_block_segment[1][i][j]);
|
||||
}
|
||||
}
|
||||
|
||||
attroff(COLOR_PAIR(5));
|
||||
if (state->carrier == 1)
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && (state->dmr_soR & 0xCF) == 0x40) //4F or CF mask?
|
||||
{
|
||||
attron(COLOR_PAIR(5));
|
||||
printw (" **Pr** ");
|
||||
attroff(COLOR_PAIR(5));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//LRRP
|
||||
if(state->dmrburstR != 16 && opts->p25_trunk == 0) //only during data and no trunking
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("%s", state->dmr_lrrp_gps[1]);
|
||||
}
|
||||
|
||||
//Group Name Labels from CSV import
|
||||
if (state->dmrburstR == 16 || state->dmrburstR > 19)
|
||||
{
|
||||
for (int k = 0; k < state->group_tally; k++)
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && state->K > 0 && ((state->dmr_soR & 0xCF) == 0x40) && state->dmr_fidR == 0x10)
|
||||
{
|
||||
if (state->group_array[k].groupNumber == state->lasttgR)
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("Pr Key [%3lld] ", state->K);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->payload_algidR == 0 && state->H > 0 && ((state->dmr_soR & 0xCF) == 0x40) && state->dmr_fidR == 0x68)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("**tera Pr Key [%010llX] ", state->H);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//ALG, KeyID, MI 2 //was keyidR
|
||||
if(state->dmrburstR == 16 && state->payload_algidR > 0 && (state->dmr_soR & 0xCF) == 0x40)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("ALG: [0x%02X] KEY: [0x%02X] MI: [0x%08X] ", state->payload_algidR, state->payload_keyidR, state->payload_miR);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//P25-P1 and P2
|
||||
if(state->dmrburstR > 19 && state->payload_algidR > 0 && state->payload_algidR != 0x80)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw ("ALG: [0x%02X] KEY: [0x%04X] MI: [0x%016llX] ", state->payload_algidR, state->payload_keyidR, state->payload_miN);
|
||||
attroff(COLOR_PAIR(1));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0xAA || state->payload_algidR == 0x21)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("ADP-RC4");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x81 || state->payload_algidR == 0x22)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("DES-OFB");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x83 || state->payload_algidR == 0x23)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("Triple DES");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x85 || state->payload_algidR == 0x24)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("AES-128");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x84 || state->payload_algidR == 0x25 || state->payload_algidR == 0x05)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("AES-256");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if (state->payload_algidR == 0x02)
|
||||
{
|
||||
attron(COLOR_PAIR(1));
|
||||
printw("Hytera Full Encrypt");
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
//Call Types, may switch to the more robust version later?
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x40 && state->R == 0) //0100 0000
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **ENC** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x80)
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **Emergency** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
if(state->dmrburstR == 16 && state->dmr_soR == 0x30) //0010 0000
|
||||
{
|
||||
attron(COLOR_PAIR(2));
|
||||
printw (" **Private Call** ");
|
||||
attroff(COLOR_PAIR(2));
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
printw ("\n");
|
||||
|
||||
//printw ("| | ");
|
||||
printw ("| D XTRA | ");
|
||||
|
||||
attron(COLOR_PAIR(4));
|
||||
|
||||
if(state->dmrburstR == 16) //only during call
|
||||
{
|
||||
|
||||
//Embedded GPS (not LRRP)
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("%s ", state->dmr_embedded_gps[1]);
|
||||
|
||||
//Embedded Talker Alias Blocks
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw (" [%s]", state->group_array[k].groupName);
|
||||
printw ("[%s] ", state->group_array[k].groupMode);
|
||||
for (int j = 0; j < 7; j++)
|
||||
{
|
||||
printw ("%s", state->dmr_alias_block_segment[1][i][j]);
|
||||
}
|
||||
}
|
||||
|
||||
attroff(COLOR_PAIR(5));
|
||||
if (state->carrier == 1)
|
||||
{
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if (state->carrier == 1) attron(COLOR_PAIR(3));
|
||||
else attroff(COLOR_PAIR(4));
|
||||
//LRRP
|
||||
if(state->dmrburstR != 16) //only during data and no trunking //&& opts->p25_trunk == 0
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("%s", state->dmr_lrrp_gps[1]);
|
||||
}
|
||||
|
||||
//Group Name Labels from CSV import
|
||||
if (state->dmrburstR == 16 || state->dmrburstR > 19)
|
||||
{
|
||||
for (int k = 0; k < state->group_tally; k++)
|
||||
{
|
||||
if (state->group_array[k].groupNumber == state->lasttgR)
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw (" [%s]", state->group_array[k].groupName);
|
||||
printw ("[%s] ", state->group_array[k].groupMode);
|
||||
}
|
||||
if (state->carrier == 1)
|
||||
{
|
||||
attron(COLOR_PAIR(3));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printw ("\n");
|
||||
} // end if not MS
|
||||
if (state->carrier == 1) attron(COLOR_PAIR(3));
|
||||
else attroff(COLOR_PAIR(4));
|
||||
|
||||
printw ("\n");
|
||||
|
||||
if (1 == 1) //opts->p25_trunk == 1
|
||||
{
|
||||
printw ("| T INFO | ");
|
||||
|
||||
// Tuned Frequency Display
|
||||
if (state->p25_vc_freq[0] != 0)
|
||||
{
|
||||
attron(COLOR_PAIR(4));
|
||||
printw ("Frequency: [%.06lf] MHz ", (double)state->p25_vc_freq[0]/1000000);
|
||||
}
|
||||
if (state->carrier == 1) attron(COLOR_PAIR(3));
|
||||
else attroff(COLOR_PAIR(4));
|
||||
printw ("\n");
|
||||
}
|
||||
|
||||
} // end if not MS
|
||||
} //end DMR BS Types
|
||||
|
||||
//dPMR
|
||||
@@ -2989,140 +2983,140 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
refresh();
|
||||
|
||||
//keyboard shortcuts - codes same as ascii codes
|
||||
//keyboard shortcuts - codes same as ascii codes
|
||||
if (c == 27) //esc key, open menu
|
||||
{
|
||||
ncursesMenu (opts, state); //just a quick test
|
||||
}
|
||||
|
||||
if (c == 122) //'z' key, toggle payload to console
|
||||
{
|
||||
if (opts->payload == 1) opts->payload = 0;
|
||||
else opts->payload = 1;
|
||||
}
|
||||
|
||||
if (c == 99) //'c' key, toggle compact mode
|
||||
{
|
||||
if (opts->ncurses_compact == 1) opts->ncurses_compact = 0;
|
||||
else opts->ncurses_compact = 1;
|
||||
}
|
||||
|
||||
if (c == 116) //'t' key, toggle trunking
|
||||
{
|
||||
if (opts->p25_trunk == 1) opts->p25_trunk = 0;
|
||||
else opts->p25_trunk = 1;
|
||||
}
|
||||
|
||||
if (c == 97) //'a' key, toggle call alert beep
|
||||
{
|
||||
if (opts->call_alert == 1) opts->call_alert = 0;
|
||||
else opts->call_alert = 1;
|
||||
}
|
||||
|
||||
if (c == 104) //'h' key, toggle history
|
||||
{
|
||||
if (opts->ncurses_history == 1) opts->ncurses_history = 0;
|
||||
else opts->ncurses_history = 1;
|
||||
}
|
||||
|
||||
if (c == 113) //'q' key, quit
|
||||
{
|
||||
ncursesClose();
|
||||
cleanupAndExit (opts, state);
|
||||
}
|
||||
|
||||
if (c == 52) // '4' key, toggle force privacy key over fid and svc (dmr)
|
||||
{
|
||||
if (state->M == 1) state->M = 0;
|
||||
else state->M = 1;
|
||||
}
|
||||
|
||||
if (c == 105) //'i' key, toggle signal inversion on inverted types
|
||||
{
|
||||
//Set all signal for inversion or uninversion
|
||||
if (opts->inverted_dmr == 0)
|
||||
{
|
||||
opts->inverted_dmr = 1;
|
||||
opts->inverted_dpmr = 1;
|
||||
opts->inverted_x2tdma = 1;
|
||||
opts->inverted_ysf = 1;
|
||||
ncursesMenu (opts, state); //just a quick test
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->inverted_dmr = 0;
|
||||
opts->inverted_dpmr = 0;
|
||||
opts->inverted_x2tdma = 0;
|
||||
opts->inverted_ysf = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 109) //'m' key, toggle qpsk/c4fm - everything but phase 2
|
||||
{
|
||||
if (state->rf_mod == 0)
|
||||
if (c == 122) //'z' key, toggle payload to console
|
||||
{
|
||||
opts->mod_c4fm = 0;
|
||||
opts->mod_qpsk = 1;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 1;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
if (opts->payload == 1) opts->payload = 0;
|
||||
else opts->payload = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->mod_c4fm = 1;
|
||||
opts->mod_qpsk = 0;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 0;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 77) //'M' key, toggle qpsk - phase 2 6000 sps
|
||||
{
|
||||
if (state->rf_mod == 0)
|
||||
if (c == 99) //'c' key, toggle compact mode
|
||||
{
|
||||
opts->mod_c4fm = 0;
|
||||
opts->mod_qpsk = 1;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 1;
|
||||
state->samplesPerSymbol = 8;
|
||||
state->symbolCenter = 3;
|
||||
if (opts->ncurses_compact == 1) opts->ncurses_compact = 0;
|
||||
else opts->ncurses_compact = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->mod_c4fm = 1;
|
||||
opts->mod_qpsk = 0;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 0;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 82) //'R', save symbol capture bin with date/time string as name
|
||||
{
|
||||
sprintf (opts->symbol_out_file, "%s %s.bin", getDateN(), getTimeN());
|
||||
if (opts->symbol_out_file[0] != 0)
|
||||
if (c == 116) //'t' key, toggle trunking
|
||||
{
|
||||
opts->symbol_out = 1; //set flag to 1
|
||||
openSymbolOutFile (opts, state);
|
||||
if (opts->p25_trunk == 1) opts->p25_trunk = 0;
|
||||
else opts->p25_trunk = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 114) //'r' key, stop capturing symbol capture bin file
|
||||
{
|
||||
if (opts->symbol_out == 1)
|
||||
if (c == 97) //'a' key, toggle call alert beep
|
||||
{
|
||||
if (opts->call_alert == 1) opts->call_alert = 0;
|
||||
else opts->call_alert = 1;
|
||||
}
|
||||
|
||||
if (c == 104) //'h' key, toggle history
|
||||
{
|
||||
if (opts->ncurses_history == 1) opts->ncurses_history = 0;
|
||||
else opts->ncurses_history = 1;
|
||||
}
|
||||
|
||||
if (c == 113) //'q' key, quit
|
||||
{
|
||||
ncursesClose();
|
||||
cleanupAndExit (opts, state);
|
||||
}
|
||||
|
||||
if (c == 52) // '4' key, toggle force privacy key over fid and svc (dmr)
|
||||
{
|
||||
if (state->M == 1) state->M = 0;
|
||||
else state->M = 1;
|
||||
}
|
||||
|
||||
if (c == 105) //'i' key, toggle signal inversion on inverted types
|
||||
{
|
||||
//Set all signal for inversion or uninversion
|
||||
if (opts->inverted_dmr == 0)
|
||||
{
|
||||
opts->inverted_dmr = 1;
|
||||
opts->inverted_dpmr = 1;
|
||||
opts->inverted_x2tdma = 1;
|
||||
opts->inverted_ysf = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->inverted_dmr = 0;
|
||||
opts->inverted_dpmr = 0;
|
||||
opts->inverted_x2tdma = 0;
|
||||
opts->inverted_ysf = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 109) //'m' key, toggle qpsk/c4fm - everything but phase 2
|
||||
{
|
||||
if (state->rf_mod == 0)
|
||||
{
|
||||
opts->mod_c4fm = 0;
|
||||
opts->mod_qpsk = 1;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 1;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->mod_c4fm = 1;
|
||||
opts->mod_qpsk = 0;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 0;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 77) //'M' key, toggle qpsk - phase 2 6000 sps
|
||||
{
|
||||
if (state->rf_mod == 0)
|
||||
{
|
||||
opts->mod_c4fm = 0;
|
||||
opts->mod_qpsk = 1;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 1;
|
||||
state->samplesPerSymbol = 8;
|
||||
state->symbolCenter = 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
opts->mod_c4fm = 1;
|
||||
opts->mod_qpsk = 0;
|
||||
opts->mod_gfsk = 0;
|
||||
state->rf_mod = 0;
|
||||
state->samplesPerSymbol = 10;
|
||||
state->symbolCenter = 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 82) //'R', save symbol capture bin with date/time string as name
|
||||
{
|
||||
sprintf (opts->symbol_out_file, "%s %s.bin", getDateN(), getTimeN());
|
||||
if (opts->symbol_out_file[0] != 0)
|
||||
{
|
||||
fclose(opts->symbol_out_f);
|
||||
sprintf (opts->audio_in_dev, "%s", opts->symbol_out_file);
|
||||
opts->symbol_out = 1; //set flag to 1
|
||||
openSymbolOutFile (opts, state);
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 114) //'r' key, stop capturing symbol capture bin file
|
||||
{
|
||||
if (opts->symbol_out == 1)
|
||||
{
|
||||
if (opts->symbol_out_file[0] != 0)
|
||||
{
|
||||
fclose(opts->symbol_out_f);
|
||||
sprintf (opts->audio_in_dev, "%s", opts->symbol_out_file);
|
||||
}
|
||||
|
||||
opts->symbol_out = 0;
|
||||
}
|
||||
|
||||
opts->symbol_out = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// if (c == 32) //'space bar' replay last bin file (rework to do wav files too?)
|
||||
@@ -3162,143 +3156,143 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
|
||||
openWavOutFileR (opts, state);
|
||||
}
|
||||
|
||||
//this one could cause issues, but seems okay
|
||||
if (c == 112) //'p' key - stop all per call wav files
|
||||
{
|
||||
//hope this one doesn't cause random crashing or garbage writing
|
||||
closeWavOutFile (opts, state);
|
||||
closeWavOutFileL (opts, state);
|
||||
closeWavOutFileR (opts, state);
|
||||
sprintf (opts->wav_out_file, "%s", "");
|
||||
sprintf (opts->wav_out_fileR, "%s", "");
|
||||
opts->dmr_stereo_wav = 0;
|
||||
}
|
||||
//this one could cause issues, but seems okay
|
||||
if (c == 112) //'p' key - stop all per call wav files
|
||||
{
|
||||
//hope this one doesn't cause random crashing or garbage writing
|
||||
closeWavOutFile (opts, state);
|
||||
closeWavOutFileL (opts, state);
|
||||
closeWavOutFileR (opts, state);
|
||||
sprintf (opts->wav_out_file, "%s", "");
|
||||
sprintf (opts->wav_out_fileR, "%s", "");
|
||||
opts->dmr_stereo_wav = 0;
|
||||
}
|
||||
|
||||
//
|
||||
// if (c == 115) //'s' key, stop playing wav or symbol in files
|
||||
// {
|
||||
// if (opts->symbolfile != NULL)
|
||||
// {
|
||||
// if (opts->audio_in_type == 4)
|
||||
// {
|
||||
// fclose(opts->symbolfile);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (c == 115) //'s' key, stop playing wav or symbol in files
|
||||
// {
|
||||
// if (opts->symbolfile != NULL)
|
||||
// {
|
||||
// if (opts->audio_in_type == 4)
|
||||
// {
|
||||
// fclose(opts->symbolfile);
|
||||
// }
|
||||
// }
|
||||
|
||||
// if (opts->audio_in_type == 2) //wav input file
|
||||
// {
|
||||
// sf_close(opts->audio_in_file);
|
||||
// }
|
||||
// if (opts->audio_in_type == 2) //wav input file
|
||||
// {
|
||||
// sf_close(opts->audio_in_file);
|
||||
// }
|
||||
|
||||
// if (opts->audio_out_type == 0)
|
||||
// {
|
||||
// opts->audio_in_type = 0;
|
||||
// openPulseInput(opts);
|
||||
// }
|
||||
// else opts->audio_in_type = 5;//cleanupAndExit(opts, state);
|
||||
|
||||
// }
|
||||
//
|
||||
// if (opts->audio_out_type == 0)
|
||||
// {
|
||||
// opts->audio_in_type = 0;
|
||||
// openPulseInput(opts);
|
||||
// }
|
||||
// else opts->audio_in_type = 5;//cleanupAndExit(opts, state);
|
||||
|
||||
// }
|
||||
//
|
||||
|
||||
// //Lockout bug in EDACS prevents any group from tuning when using this, not sure why yet
|
||||
// //WARNING! USE THESE WITH CAUTION! IF BREAKING ISSUES OBSERVED, THEN RESTART AND DON'T USE THEM!!
|
||||
if (opts->frame_provoice != 1 && c == 49) //'1' key, lockout slot 1 or conventional tg from tuning/playback during session
|
||||
{
|
||||
state->group_array[state->group_tally].groupNumber = state->lasttg;
|
||||
sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
|
||||
sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
|
||||
state->group_tally++;
|
||||
// //Lockout bug in EDACS prevents any group from tuning when using this, not sure why yet
|
||||
// //WARNING! USE THESE WITH CAUTION! IF BREAKING ISSUES OBSERVED, THEN RESTART AND DON'T USE THEM!!
|
||||
if (opts->frame_provoice != 1 && c == 49) //'1' key, lockout slot 1 or conventional tg from tuning/playback during session
|
||||
{
|
||||
state->group_array[state->group_tally].groupNumber = state->lasttg;
|
||||
sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
|
||||
sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
|
||||
state->group_tally++;
|
||||
|
||||
//test tuning away to break sync, if not working so well, then disable
|
||||
//RIGCTL
|
||||
if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
|
||||
//test tuning away to break sync, if not working so well, then disable
|
||||
//RIGCTL
|
||||
if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
|
||||
|
||||
//rtl_udp
|
||||
if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
|
||||
//rtl_udp
|
||||
if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if (opts->frame_provoice != 1 && c == 50) //'2' key, lockout slot 2 tdma tgR from tuning/playback during session
|
||||
{
|
||||
state->group_array[state->group_tally].groupNumber = state->lasttgR;
|
||||
sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
|
||||
sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
|
||||
state->group_tally++;
|
||||
if (opts->frame_provoice != 1 && c == 50) //'2' key, lockout slot 2 tdma tgR from tuning/playback during session
|
||||
{
|
||||
state->group_array[state->group_tally].groupNumber = state->lasttgR;
|
||||
sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
|
||||
sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
|
||||
state->group_tally++;
|
||||
|
||||
//test tuning away to break sync, if not working so well, then disable
|
||||
//RIGCTL
|
||||
if (opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
|
||||
//test tuning away to break sync, if not working so well, then disable
|
||||
//RIGCTL
|
||||
if (opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
|
||||
|
||||
//rtl_udp
|
||||
if (opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
|
||||
//rtl_udp
|
||||
if (opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if (c == 48) //'0' key, toggle upsampled audio smoothing
|
||||
{
|
||||
if (state->audio_smoothing == 1) state->audio_smoothing = 0;
|
||||
else state->audio_smoothing = 1;
|
||||
}
|
||||
if (c == 48) //'0' key, toggle upsampled audio smoothing
|
||||
{
|
||||
if (state->audio_smoothing == 1) state->audio_smoothing = 0;
|
||||
else state->audio_smoothing = 1;
|
||||
}
|
||||
|
||||
if (opts->p25_trunk == 1 && c == 119) //'w' key, toggle white list/black list mode
|
||||
{
|
||||
if (opts->trunk_use_allow_list == 1) opts->trunk_use_allow_list = 0;
|
||||
else opts->trunk_use_allow_list = 1;
|
||||
}
|
||||
if (opts->p25_trunk == 1 && c == 119) //'w' key, toggle white list/black list mode
|
||||
{
|
||||
if (opts->trunk_use_allow_list == 1) opts->trunk_use_allow_list = 0;
|
||||
else opts->trunk_use_allow_list = 1;
|
||||
}
|
||||
|
||||
if (opts->p25_trunk == 1 && c == 117) //'u' key, toggle tune private calls
|
||||
{
|
||||
if (opts->trunk_tune_private_calls == 1) opts->trunk_tune_private_calls = 0;
|
||||
else opts->trunk_tune_private_calls = 1;
|
||||
}
|
||||
if (opts->p25_trunk == 1 && c == 117) //'u' key, toggle tune private calls
|
||||
{
|
||||
if (opts->trunk_tune_private_calls == 1) opts->trunk_tune_private_calls = 0;
|
||||
else opts->trunk_tune_private_calls = 1;
|
||||
}
|
||||
|
||||
if (opts->p25_trunk == 1 && c == 100) //'d' key, toggle tune data calls
|
||||
{
|
||||
if (opts->trunk_tune_data_calls == 1) opts->trunk_tune_data_calls = 0;
|
||||
else opts->trunk_tune_data_calls = 1;
|
||||
}
|
||||
if (opts->p25_trunk == 1 && c == 100) //'d' key, toggle tune data calls
|
||||
{
|
||||
if (opts->trunk_tune_data_calls == 1) opts->trunk_tune_data_calls = 0;
|
||||
else opts->trunk_tune_data_calls = 1;
|
||||
}
|
||||
|
||||
if (opts->p25_trunk == 1 && c == 103) //'g' key, toggle tune group calls
|
||||
{
|
||||
if (opts->trunk_tune_group_calls == 1) opts->trunk_tune_group_calls = 0;
|
||||
else opts->trunk_tune_group_calls = 1;
|
||||
}
|
||||
if (opts->p25_trunk == 1 && c == 103) //'g' key, toggle tune group calls
|
||||
{
|
||||
if (opts->trunk_tune_group_calls == 1) opts->trunk_tune_group_calls = 0;
|
||||
else opts->trunk_tune_group_calls = 1;
|
||||
}
|
||||
|
||||
if (c == 70) //'F' key - toggle agressive sync/crc failure/ras
|
||||
{
|
||||
if (opts->aggressive_framesync == 0) opts->aggressive_framesync = 1;
|
||||
else opts->aggressive_framesync = 0;
|
||||
}
|
||||
if (c == 70) //'F' key - toggle agressive sync/crc failure/ras
|
||||
{
|
||||
if (opts->aggressive_framesync == 0) opts->aggressive_framesync = 1;
|
||||
else opts->aggressive_framesync = 0;
|
||||
}
|
||||
|
||||
if (c == 68) //'D' key - Reset DMR Site Parms/Call Strings, etc.
|
||||
{
|
||||
//dmr trunking/ncurses stuff
|
||||
state->dmr_rest_channel = -1; //init on -1
|
||||
state->dmr_mfid = -1; //
|
||||
if (c == 68) //'D' key - Reset DMR Site Parms/Call Strings, etc.
|
||||
{
|
||||
//dmr trunking/ncurses stuff
|
||||
state->dmr_rest_channel = -1; //init on -1
|
||||
state->dmr_mfid = -1; //
|
||||
|
||||
//dmr mfid branding and site parms
|
||||
sprintf(state->dmr_branding_sub, "%s", "");
|
||||
sprintf(state->dmr_branding, "%s", "");
|
||||
sprintf (state->dmr_site_parms, "%s", "");
|
||||
//dmr mfid branding and site parms
|
||||
sprintf(state->dmr_branding_sub, "%s", "");
|
||||
sprintf(state->dmr_branding, "%s", "");
|
||||
sprintf (state->dmr_site_parms, "%s", "");
|
||||
|
||||
//DMR Location Area - DMRLA B***S***
|
||||
opts->dmr_dmrla_is_set = 0;
|
||||
opts->dmr_dmrla_n = 0;
|
||||
//DMR Location Area - DMRLA B***S***
|
||||
opts->dmr_dmrla_is_set = 0;
|
||||
opts->dmr_dmrla_n = 0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//Debug/Troubleshooting Option
|
||||
if (c == 90) //'Z' key - Simulate NoCarrier/No VC/CC sync to zero out more stuff (capital Z)
|
||||
{
|
||||
// opts->p25_is_tuned = 0;
|
||||
state->last_cc_sync_time = 0;
|
||||
state->last_vc_sync_time = 0;
|
||||
noCarrier(opts, state);
|
||||
}
|
||||
//Debug/Troubleshooting Option
|
||||
if (c == 90) //'Z' key - Simulate NoCarrier/No VC/CC sync to zero out more stuff (capital Z)
|
||||
{
|
||||
// opts->p25_is_tuned = 0;
|
||||
state->last_cc_sync_time = 0;
|
||||
state->last_vc_sync_time = 0;
|
||||
noCarrier(opts, state);
|
||||
}
|
||||
|
||||
//anything with an entry box will need the inputs and outputs stopped first
|
||||
//so probably just write a function to handle c input, and when c = certain values
|
||||
//needing an entry box, then stop all of those
|
||||
//anything with an entry box will need the inputs and outputs stopped first
|
||||
//so probably just write a function to handle c input, and when c = certain values
|
||||
//needing an entry box, then stop all of those
|
||||
|
||||
} //end ncursesPrinter
|
||||
|
||||
|
||||
@@ -111,17 +111,15 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
|
||||
trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
|
||||
}
|
||||
|
||||
//load tail 16 bits into check variable to compare vs computed crc value
|
||||
crc = crc12f (trellis_buf, 84); //80
|
||||
for (int i = 0; i < 12; i++)
|
||||
{
|
||||
check = check << 1;
|
||||
check = check + trellis_buf[80+i];
|
||||
check = check | trellis_buf[84+i]; //80
|
||||
}
|
||||
|
||||
crc = crc12f (trellis_buf, 80);
|
||||
|
||||
if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, trellis_buf);
|
||||
//else if (opts->payload == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
|
||||
// else if (opts->payload == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
|
||||
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
@@ -131,7 +129,7 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
|
||||
{
|
||||
fprintf (stderr, "[%02X]", m_data[i]);
|
||||
}
|
||||
fprintf (stderr, " - %03X %03X", crc, check);
|
||||
fprintf (stderr, " - %03X %03X", check, crc);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -211,11 +209,11 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
|
||||
trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
|
||||
}
|
||||
|
||||
crc = crc6(trellis_buf, 32);
|
||||
crc = crc6(trellis_buf, 26); //32
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
check = check << 1;
|
||||
check = check + trellis_buf[i+26];
|
||||
check = check | trellis_buf[i+26];
|
||||
}
|
||||
|
||||
//FIRST! If part of a non_superframe, and CRC is good, send directly to NXDN_Elements_Content_decode
|
||||
@@ -231,16 +229,16 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
|
||||
nsf_sacch[i] = trellis_buf[i+8];
|
||||
}
|
||||
|
||||
if (crc == 0) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch);
|
||||
if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch);
|
||||
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "\n SACCH NSF ");
|
||||
for (int i = 0; i < 5; i++)
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", m_data[i]);
|
||||
}
|
||||
if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
|
||||
if (crc != check) fprintf (stderr, " CRC ERR - %02X %02X", check, crc);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -266,7 +264,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
|
||||
//reset scrambler seed to key value on new superframe
|
||||
if (part_of_frame == 0 && state->nxdn_cipher_type == 0x1) state->payload_miN = 0;
|
||||
|
||||
if (crc == 0)
|
||||
if (crc == check)
|
||||
{
|
||||
state->nxdn_ran = state->nxdn_last_ran = ran;
|
||||
state->nxdn_sf = sf;
|
||||
@@ -294,11 +292,11 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, " SACCH SF Segment #%d ", part_of_frame+1);
|
||||
for (int i = 0; i < 5; i++)
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", m_data[i]);
|
||||
}
|
||||
if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
|
||||
if (crc != check) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -312,6 +310,7 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
|
||||
uint8_t trellis_buf[199];
|
||||
int id = 0;
|
||||
uint16_t crc = 0;
|
||||
uint16_t check = 0;
|
||||
|
||||
for (int i=0; i<348; i++) {
|
||||
deperm[PERM_12_29[i]] = bits[i];
|
||||
@@ -377,6 +376,11 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
|
||||
}
|
||||
|
||||
crc = crc15(trellis_buf, 199);
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
check = check << 1;
|
||||
check = check | trellis_buf[i+184];
|
||||
}
|
||||
|
||||
uint8_t f2u_message_buffer[199];
|
||||
memset (f2u_message_buffer, 0, sizeof(f2u_message_buffer));
|
||||
@@ -388,7 +392,7 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
|
||||
f2u_message_buffer[i] = trellis_buf[i+8];
|
||||
}
|
||||
|
||||
if (crc == 0)
|
||||
if (crc == check)
|
||||
{
|
||||
fprintf (stderr, " F2/U ");
|
||||
//NXDN_Elements_Content_decode(opts, state, 1, trellis_buf);
|
||||
@@ -404,7 +408,7 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
|
||||
fprintf (stderr, "[%02X]", m_data[i]);
|
||||
if (i == 12) fprintf (stderr, "\n ");
|
||||
}
|
||||
if (crc != 0) fprintf (stderr, " CRC ERR ");
|
||||
if (crc != check) fprintf (stderr, " CRC ERR ");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -452,11 +456,6 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
|
||||
temp[i] = depunc[i] << 1;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
temp[i+350] = 0;
|
||||
}
|
||||
|
||||
CNXDNConvolution_start();
|
||||
for (int i = 0U; i < 179U; i++)
|
||||
{
|
||||
@@ -482,20 +481,11 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
|
||||
|
||||
crc = crc16cac(trellis_buf, 171);
|
||||
|
||||
//message type will probably be neccesary beforehand on single/dual meessage runs
|
||||
//run message, check len, load into a seperate buffer, send to element, do same with other piece?
|
||||
uint8_t MessageType = 0;
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
MessageType = MessageType << 1;
|
||||
MessageType = MessageType + trellis_buf[i+2]; //double check this on CAC
|
||||
}
|
||||
|
||||
uint8_t cac_message_buffer[171];
|
||||
memset (cac_message_buffer, 0, sizeof(cac_message_buffer));
|
||||
|
||||
//shift the cac_message into the appropriate byte arrangement for element_decoder
|
||||
for (int i = 0; i < 160; i++) //in future, we can use this to send multiple messages to decoder, if present
|
||||
//shift the cac_message into the appropriate byte arrangement for element_decoder -- skip SR field
|
||||
for (int i = 0; i < 160; i++)
|
||||
{
|
||||
cac_message_buffer[i] = trellis_buf[i+8];
|
||||
}
|
||||
@@ -564,7 +554,7 @@ void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType)
|
||||
state->nxdn_last_tg = 0;
|
||||
state->nxdn_cipher_type = 0;
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
sprintf (state->nxdn_call_type, "%s", "");
|
||||
}
|
||||
}
|
||||
@@ -669,13 +659,13 @@ static uint16_t crc15(const uint8_t buf[], int len)
|
||||
|
||||
static uint16_t crc16cac(const uint8_t buf[], int len)
|
||||
{
|
||||
int crc = 0xc3ee;
|
||||
int poly = (1<<12) + (1<<5) + 1;
|
||||
for (int i=0;i<len;i++) {
|
||||
crc = ((crc << 1) | buf[i]) & 0x1ffff;
|
||||
if(crc & 0x10000)
|
||||
crc = (crc & 0xffff) ^ poly;
|
||||
uint32_t crc = 0xc3ee; //not sure why this though
|
||||
uint32_t poly = (1<<12) + (1<<5) + 1; //poly is fine
|
||||
for (int i=0;i<len;i++)
|
||||
{
|
||||
crc = ((crc << 1) | buf[i]) & 0x1ffff;
|
||||
if(crc & 0x10000) crc = (crc & 0xffff) ^ poly;
|
||||
}
|
||||
crc = crc ^ 0xffff;
|
||||
return crc & 0xffff;
|
||||
crc = crc ^ 0xffff;
|
||||
return crc & 0xffff;
|
||||
}
|
||||
@@ -233,6 +233,11 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
long int freq = 0;
|
||||
freq = nxdn_channel_to_frequency(opts, state, Channel);
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
|
||||
//check for control channel frequency in the channel map if not available
|
||||
if (opts->p25_trunk == 1 && state->p25_cc_freq == 0)
|
||||
{
|
||||
@@ -288,35 +293,44 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
if (opts->use_rigctl == 1)
|
||||
{
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1;
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
state->last_vc_sync_time = time(NULL); //useful?
|
||||
//
|
||||
|
||||
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
SetFreq(opts->rigctl_sockfd, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
|
||||
//set rid and tg when we actually tune to it
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
}
|
||||
//rtl_udp
|
||||
else if (opts->audio_in_type == 3)
|
||||
{
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1;
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
state->last_vc_sync_time = time(NULL);
|
||||
//
|
||||
|
||||
rtl_udp_tune (opts, state, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1;
|
||||
|
||||
//set rid and tg when we actually tune to it
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
}
|
||||
//set rid and tg when we actually tune to it
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -653,6 +667,18 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
fprintf(stderr, "Src=%u - Dst/TG=%u ", SourceUnitID & 0xFFFF, DestinationID & 0xFFFF);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
//check by keyid first, then by tgt id
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
// if (state->rkey_array[KeyID] != 0) state->R = state->rkey_array[KeyID];
|
||||
if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];
|
||||
|
||||
if (state->M == 1)
|
||||
{
|
||||
state->nxdn_cipher_type = 0x1;
|
||||
CipherType = 0x1;
|
||||
}
|
||||
|
||||
/* Print the "Cipher Type" */
|
||||
if(CipherType != 0)
|
||||
{
|
||||
@@ -667,8 +693,6 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
if (state->rkey_array[KeyID] != 0) state->R = state->rkey_array[KeyID];
|
||||
|
||||
if (state->nxdn_cipher_type == 0x01 && state->R > 0) //scrambler key value
|
||||
{
|
||||
@@ -680,7 +704,7 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
//only grab if CRC is okay
|
||||
if(state->NxdnElementsContent.VCallCrcIsGood)
|
||||
{
|
||||
if ( (SourceUnitID & 0xFFFF) > 0 )
|
||||
if ( (SourceUnitID & 0xFFFF) > 0 ) //
|
||||
{
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
|
||||
@@ -86,6 +86,15 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
|
||||
facch2 = 0;
|
||||
sacch = 0;
|
||||
cac = 0;
|
||||
|
||||
//test for inbound direction lich when trunking (false positive) and skip
|
||||
//all inbound lich are even value (lsb is set to 0 for inbound direction)
|
||||
if (lich % 2 == 0 && opts->p25_trunk == 1)
|
||||
{
|
||||
if (opts->payload == 1) fprintf(stderr, " Simplex/Inbound NXDN lich on trunking system - type 0x%02X\n", lich);
|
||||
goto END;
|
||||
}
|
||||
|
||||
switch(lich) { //cases without breaks continue to flow downwards until they hit the break
|
||||
case 0x01: // CAC types
|
||||
case 0x05:
|
||||
@@ -123,7 +132,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
|
||||
break;
|
||||
case 0x36: //vch in both
|
||||
case 0x37:
|
||||
case 0x56:
|
||||
case 0x56:
|
||||
case 0x57:
|
||||
case 0x77:
|
||||
voice = 3;
|
||||
@@ -151,7 +160,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
|
||||
default:
|
||||
if (opts->payload == 1) fprintf(stderr, " false sync or unsupported NXDN lich type 0x%02X\n", lich);
|
||||
//reset the sacch field, we probably got a false sync and need to wipe or give a bad crc
|
||||
memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly
|
||||
voice = 0;
|
||||
@@ -241,7 +250,9 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
|
||||
|
||||
}
|
||||
|
||||
state->nxdn_sacch_non_superframe = (lich == 0x20 || lich == 0x21 || lich == 0x61 || lich == 0x40 || lich == 0x41) ? true : false;
|
||||
if (lich == 0x20 || lich == 0x21 || lich == 0x61 || lich == 0x40 || lich == 0x41) state->nxdn_sacch_non_superframe = TRUE;
|
||||
else state->nxdn_sacch_non_superframe = FALSE;
|
||||
|
||||
if (sacch)nxdn_deperm_sacch(opts, state, sacch_bits);
|
||||
if (cac) nxdn_deperm_cac(opts, state, cac_bits);
|
||||
if (facch2) nxdn_deperm_facch2_udch(opts, state, facch2_bits);
|
||||
|
||||
@@ -40,7 +40,8 @@ static int find_min(uint8_t list[], int len) {
|
||||
index = i;
|
||||
unique = 1;
|
||||
} else if (list[i] == min) {
|
||||
unique = 0;
|
||||
//unique = 0;
|
||||
; //do nothing, still can be correct and pass CRC
|
||||
}
|
||||
}
|
||||
/* return -1 if a minimum can't be found */
|
||||
|
||||
110
src/p25p1_tsbk.c
110
src/p25p1_tsbk.c
@@ -7,6 +7,73 @@
|
||||
*-----------------------------------------------------------------------------*/
|
||||
|
||||
#include "dsd.h"
|
||||
|
||||
int block_convolution (int payload[196], uint8_t decoded[12])
|
||||
{
|
||||
int ec = -1; //initialize error value
|
||||
|
||||
uint8_t deinterleaved_bits[196];
|
||||
uint8_t trellis_bytes[12];
|
||||
uint8_t m_data[14];
|
||||
uint8_t temp[210]; //temp bit position buffer for convolution
|
||||
|
||||
//initialize our deinterleaved bits and bytes with zeroes
|
||||
for (int i = 0; i < 196; i++) deinterleaved_bits[i] = 0;
|
||||
for (int i = 0; i < 210; i++) temp[i] = 0;
|
||||
for (int i = 0; i < 12; i++) trellis_bytes[i] = 0;
|
||||
for (int i = 0; i < 14; i++) m_data[i] = 0;
|
||||
|
||||
//convolution decoder
|
||||
uint8_t s0;
|
||||
uint8_t s1;
|
||||
|
||||
//initialize our decoded byte buffer with zeroes
|
||||
for (int i = 0; i < 12; i++) decoded[i] = 0;
|
||||
|
||||
static const uint16_t deinterleave_tsbk[] = {
|
||||
0, 1, 2, 3, 52, 53, 54, 55, 100,101,102,103, 148,149,150,151,
|
||||
4, 5, 6, 7, 56, 57, 58, 59, 104,105,106,107, 152,153,154,155,
|
||||
8, 9, 10, 11, 60, 61, 62, 63, 108,109,110,111, 156,157,158,159,
|
||||
12, 13, 14, 15, 64, 65, 66, 67, 112,113,114,115, 160,161,162,163,
|
||||
16, 17, 18, 19, 68, 69, 70, 71, 116,117,118,119, 164,165,166,167,
|
||||
20, 21, 22, 23, 72, 73, 74, 75, 120,121,122,123, 168,169,170,171,
|
||||
24, 25, 26, 27, 76, 77, 78, 79, 124,125,126,127, 172,173,174,175,
|
||||
28, 29, 30, 31, 80, 81, 82, 83, 128,129,130,131, 176,177,178,179,
|
||||
32, 33, 34, 35, 84, 85, 86, 87, 132,133,134,135, 180,181,182,183,
|
||||
36, 37, 38, 39, 88, 89, 90, 91, 136,137,138,139, 184,185,186,187,
|
||||
40, 41, 42, 43, 92, 93, 94, 95, 140,141,142,143, 188,189,190,191,
|
||||
44, 45, 46, 47, 96, 97, 98, 99, 144,145,146,147, 192,193,194,195,
|
||||
48, 49, 50, 51 };
|
||||
|
||||
//get the deinterleaved bits
|
||||
for (int i = 0; i < 196; i++) deinterleaved_bits[deinterleave_tsbk[i]] = payload[i];
|
||||
|
||||
//shift into proper position for the convolutional decoder
|
||||
for (int i = 0; i < 196; i++) temp[i] = deinterleaved_bits[i] << 1;
|
||||
|
||||
CNXDNConvolution_start();
|
||||
for (int i = 0U; i < 98U; i++) //102U
|
||||
{
|
||||
s0 = temp[(2*i)];
|
||||
s1 = temp[(2*i)+1];
|
||||
|
||||
CNXDNConvolution_decode(s0, s1);
|
||||
}
|
||||
|
||||
CNXDNConvolution_chainback(m_data, 96U); //98U
|
||||
|
||||
//debug print
|
||||
fprintf (stderr, "\n Convolution Chainback - ");
|
||||
for (int i = 0; i < 14; i++) fprintf (stderr, "[%02X]", m_data[i]);
|
||||
|
||||
//transfer m_data to decoded bytes -- when sorted out, can probably send decoded straight to chainback, and save the code
|
||||
// for (int i = 0; i < 12; i++) decoded[i] = m_data[i];
|
||||
|
||||
ec = 0; //unknown if a method exists to returns errors from the convolutional decoder, just rely on CRC check for now
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
||||
void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
{
|
||||
|
||||
@@ -54,6 +121,9 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
|
||||
}
|
||||
|
||||
//test with the nxdn convolutional decoder
|
||||
// ec = block_convolution (tsbkbit, tsbk_byte);
|
||||
|
||||
//send tsbkbit to block_deinterleave and return tsbk_byte
|
||||
ec = bd_bridge(tsbkbit, tsbk_byte);
|
||||
|
||||
@@ -84,7 +154,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
tsbk_byte[i] = byte;
|
||||
}
|
||||
|
||||
//convert tsbk_byte to PDU and send to vPDU handler
|
||||
//convert tsbk_byte to vPDU and send to vPDU handler
|
||||
//...may or may not be entirely compatible,
|
||||
MFID = tsbk_byte[1];
|
||||
PDU[0] = 0x07; //P25p1 TSBK Duid 0x07
|
||||
@@ -106,8 +176,9 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
protectbit = (tsbk_byte[0] >> 6) & 0x1;
|
||||
|
||||
//Don't run NET_STS out of this, or will set wrong NAC/CC //&& PDU[1] != 0x49 && PDU[1] != 0x45
|
||||
//0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus)
|
||||
if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )
|
||||
//0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus) (mfid 90)
|
||||
// if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )
|
||||
if ( (MFID < 0x2 || MFID == 0xA4 || MFID == 0x90) && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )
|
||||
{
|
||||
fprintf (stderr, "%s",KYEL);
|
||||
process_MAC_VPDU(opts, state, 0, PDU);
|
||||
@@ -115,7 +186,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
}
|
||||
|
||||
//set our WACN and SYSID here now that we have valid ec and crc/checksum
|
||||
if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B)
|
||||
else if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B)
|
||||
{
|
||||
long int wacn = (tsbk_byte[3] << 12) | (tsbk_byte[4] << 4) | (tsbk_byte[5] >> 4);;
|
||||
int sysid = ((tsbk_byte[5] & 0xF) << 8) | tsbk_byte[6];
|
||||
@@ -143,16 +214,43 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s",KCYN);
|
||||
fprintf (stderr, "\n P25 PDU Payload ");
|
||||
fprintf (stderr, "\n P25 PDU Payload #%d ", j);
|
||||
for (i = 0; i < 12; i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", tsbk_byte[i]);
|
||||
}
|
||||
}
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
fprintf (stderr, "%s",KCYN);
|
||||
fprintf (stderr, "\n P25 PDU Payload #%d ", j+1);
|
||||
for (i = 0; i < 12; i++)
|
||||
{
|
||||
fprintf (stderr, "[%02X]", tsbk_byte[i]);
|
||||
}
|
||||
fprintf (stderr, "\n MFID %02X Protected: %d Last Block: %d", MFID, protectbit, (tsbk_byte[0] >> 7) );
|
||||
|
||||
if (ec != 0)
|
||||
{
|
||||
fprintf (stderr, "%s",KRED);
|
||||
fprintf (stderr, " (FEC ERR)");
|
||||
}
|
||||
else if (err != 0)
|
||||
{
|
||||
fprintf (stderr, "%s",KRED);
|
||||
fprintf (stderr, " (CRC ERR)");
|
||||
}
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
}
|
||||
}
|
||||
|
||||
//reset for next rep
|
||||
ec = -2;
|
||||
err = -2;
|
||||
@@ -165,5 +263,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
|
||||
j = 4; //set j to break the loop early
|
||||
}
|
||||
}
|
||||
|
||||
fprintf (stderr, "%s ", KNRM);
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
|
||||
@@ -940,7 +940,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
|
||||
}
|
||||
|
||||
//Unit-to-Unit Answer Request (UU_ANS_REQ)
|
||||
if (MAC[1+len_a] == 0x45)
|
||||
if (MAC[1+len_a] == 0x45 && MAC[2+len_a] != 0x90)
|
||||
{
|
||||
int svc = MAC[2+len_a];
|
||||
int answer = MAC[3+len_a];
|
||||
@@ -952,17 +952,17 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
|
||||
|
||||
}
|
||||
|
||||
//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT)
|
||||
if (MAC[1+len_a] == 0x48)
|
||||
{
|
||||
fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");
|
||||
}
|
||||
//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT) //look at PDU for this, see if this is tunable
|
||||
// if (MAC[1+len_a] == 0x48 && MAC[2+len_a] != 0x90)
|
||||
// {
|
||||
// fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");
|
||||
// }
|
||||
|
||||
//Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
|
||||
if (MAC[1+len_a] == 0x49)
|
||||
{
|
||||
fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");
|
||||
}
|
||||
// //Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
|
||||
// if (MAC[1+len_a] == 0x49 && MAC[2+len_a] != 0x90)
|
||||
// {
|
||||
// fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");
|
||||
// }
|
||||
|
||||
//Synchronization Broadcast (SYNC_BCST)
|
||||
if (MAC[1+len_a] == 0x70)
|
||||
@@ -986,12 +986,12 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
|
||||
else offhour = ( (ltoff & 0b11111 ) / 2);
|
||||
|
||||
int seconds = slots / 135; //very rough estimation, but may be close enough for grins
|
||||
if (seconds > 60) seconds = 60; //sanity check for rounding error
|
||||
if (seconds > 59) seconds = 59; //sanity check for rounding error
|
||||
fprintf (stderr, " Date: 20%02d.%02d.%02d Time: %02d:%02d:%02d UTC\n",
|
||||
year, month, day, hour, min, seconds);
|
||||
fprintf (stderr, " Local Time Offset: %.01f Hours;", offhour);
|
||||
//if ist bit is set, then time on system may be considered invalid (i.e., no external time sync)
|
||||
if (ist % 1)
|
||||
if (ist == 1)
|
||||
{
|
||||
fprintf (stderr, " Invalid System Time ");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user