mirror of https://github.com/n7tae/tcd.git
Tom Early
4 years ago
parent
f2caa34d6c
commit
3d3ff08eda
@ -0,0 +1,106 @@
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "Controller.h"
|
||||
|
||||
bool CController::Start()
|
||||
{
|
||||
if (socket.Open("urfd2tcd", this))
|
||||
{
|
||||
keep_running = false;
|
||||
return true;
|
||||
}
|
||||
future = std::async(std::launch::async, &CController::Processing, this);
|
||||
return false;
|
||||
}
|
||||
|
||||
void CController::Stop()
|
||||
{
|
||||
keep_running = false;
|
||||
future.get();
|
||||
socket.Close();
|
||||
}
|
||||
|
||||
void CController::Processing()
|
||||
{
|
||||
while (keep_running)
|
||||
{
|
||||
// anything to read?
|
||||
}
|
||||
}
|
||||
|
||||
bool CController::InitDevices()
|
||||
{
|
||||
// unpack all the device paths
|
||||
std::set<std::string> deviceset;
|
||||
CSVtoSet(DEVICES, deviceset);
|
||||
if (2 > deviceset.size())
|
||||
{
|
||||
std::cerr << "You must specify at least two DVSI 3003 devices" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
// now initialize each device
|
||||
|
||||
// the first one will be a dstar device
|
||||
Encoding type = Encoding::dstar;
|
||||
for (const auto devpath : deviceset)
|
||||
{
|
||||
// instantiate it
|
||||
auto a3003 = std::make_shared<CDV3003>(type);
|
||||
|
||||
// open it
|
||||
if (a3003->OpenDevice(devpath, 921600))
|
||||
return true;
|
||||
|
||||
// initialize it
|
||||
a3003->InitDV3003();
|
||||
|
||||
// set each of the 3 vocoders to the current type
|
||||
for (uint8_t channel=PKT_CHANNEL0; channel<PKT_CHANNEL2; channel++)
|
||||
{
|
||||
if (a3003->ConfigureCodec(channel, type))
|
||||
return true;
|
||||
}
|
||||
|
||||
// add it to the list, according to type
|
||||
if (Encoding::dstar == type)
|
||||
dstar_devices.push_back(a3003);
|
||||
else
|
||||
dmr_devices.push_back(a3003);
|
||||
|
||||
// finally, toggle the type for the next device
|
||||
type = (type == Encoding::dstar) ? Encoding::dmr : Encoding::dstar;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void CController::CSVtoSet(const std::string &str, std::set<std::string> &set, const std::string &delimiters)
|
||||
{
|
||||
auto lastPos = str.find_first_not_of(delimiters, 0); // Skip delimiters at beginning.
|
||||
auto pos = str.find_first_of(delimiters, lastPos); // Find first non-delimiter.
|
||||
|
||||
while (std::string::npos != pos || std::string::npos != lastPos)
|
||||
{
|
||||
std::string element = str.substr(lastPos, pos-lastPos);
|
||||
set.insert(element);
|
||||
|
||||
lastPos = str.find_first_not_of(delimiters, pos); // Skip delimiters.
|
||||
pos = str.find_first_of(delimiters, lastPos); // Find next non-delimiter.
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <memory>
|
||||
#include <atomic>
|
||||
#include <future>
|
||||
|
||||
#include "DV3003.h"
|
||||
#include "configure.h"
|
||||
#include "UnixPacketSocket.h"
|
||||
|
||||
class CController
|
||||
{
|
||||
public:
|
||||
CController() : keep_running(true) {}
|
||||
bool InitDevices();
|
||||
bool Start();
|
||||
void Stop();
|
||||
bool IsRunning() { return keep_running; }
|
||||
|
||||
private:
|
||||
std::atomic<bool> keep_running;
|
||||
std::future<void> future;
|
||||
std::vector<std::shared_ptr<CDV3003>> dmr_devices, dstar_devices;
|
||||
CUnixPacketClient socket;
|
||||
|
||||
void Processing();
|
||||
|
||||
void CSVtoSet(const std::string &str, std::set<std::string> &set, const std::string &delimiters = ",");
|
||||
};
|
||||
@ -0,0 +1,465 @@
|
||||
/*
|
||||
* Copyright (C) 2014 by Jonathan Naylor G4KLX and John Hays K7VE
|
||||
* Copyright 2016 by Jeremy McDermond (NH6Z)
|
||||
* Copyright 2021 by Thomas Early N7TAE
|
||||
*
|
||||
* Adapted by K7VE from G4KLX dv3000d
|
||||
*/
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cerrno>
|
||||
|
||||
#include <netinet/in.h>
|
||||
|
||||
#include "DV3003.h"
|
||||
|
||||
CDV3003::CDV3003(Encoding t) : type(t), fd(-1)
|
||||
{
|
||||
}
|
||||
|
||||
CDV3003::~CDV3003()
|
||||
{
|
||||
CloseDevice();
|
||||
}
|
||||
|
||||
bool CDV3003::checkResponse(SDV3003_Packet &p, uint8_t response) const
|
||||
{
|
||||
if(p.start_byte != PKT_HEADER || p.header.packet_type != PKT_CONTROL || p.field_id != response)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::IsOpen() const
|
||||
{
|
||||
return fd >= 0;
|
||||
}
|
||||
|
||||
std::string CDV3003::GetDevicePath() const
|
||||
{
|
||||
return devicepath;
|
||||
}
|
||||
|
||||
std::string CDV3003::GetVersion() const
|
||||
{
|
||||
return version;
|
||||
}
|
||||
|
||||
std::string CDV3003::GetProductID() const
|
||||
{
|
||||
return productid;
|
||||
}
|
||||
|
||||
bool CDV3003::SetBaudRate(int baudrate)
|
||||
{
|
||||
struct termios tty;
|
||||
|
||||
if (tcgetattr(fd, &tty) != 0) {
|
||||
std::cerr << devicepath << " tcgetattr: " << strerror(errno) << std::endl;
|
||||
close(fd);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Input speed = output speed
|
||||
cfsetispeed(&tty, B0);
|
||||
|
||||
switch(baudrate) {
|
||||
case 230400:
|
||||
cfsetospeed(&tty, B230400);
|
||||
break;
|
||||
case 460800:
|
||||
cfsetospeed(&tty, B460800);
|
||||
break;
|
||||
case 921600:
|
||||
cfsetospeed(&tty, B921600);
|
||||
break;
|
||||
default:
|
||||
std::cerr << devicepath << " unsupported baud rate " << baudrate << std::endl;
|
||||
close(fd);
|
||||
return true;
|
||||
}
|
||||
|
||||
tty.c_lflag &= ~(ECHO | ECHOE | ICANON | IEXTEN | ISIG);
|
||||
tty.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON | IXOFF | IXANY);
|
||||
tty.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
|
||||
tty.c_cflag |= CS8 | CRTSCTS;
|
||||
tty.c_oflag &= ~(OPOST);
|
||||
tty.c_cc[VMIN] = 0;
|
||||
tty.c_cc[VTIME] = 1;
|
||||
|
||||
if (tcsetattr(fd, TCSANOW, &tty) != 0) {
|
||||
std::cerr << devicepath << " tcsetattr: " << strerror(errno) << std::endl;
|
||||
close(fd);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::OpenDevice(const std::string &ttyname, int baudrate)
|
||||
{
|
||||
fd = open(ttyname.c_str(), O_RDWR | O_NOCTTY | O_SYNC);
|
||||
if (fd < 0) {
|
||||
std::cerr << "error when opening " << ttyname << ": " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
std::cout << "Opened " << ttyname << std::endl;
|
||||
|
||||
if (SetBaudRate(baudrate))
|
||||
return true;
|
||||
|
||||
devicepath.assign(ttyname);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::InitDV3003()
|
||||
{
|
||||
char prodId[17];
|
||||
char versionstr[49];
|
||||
SDV3003_Packet responsePacket, ctrlPacket;
|
||||
|
||||
// ********** hard reset *************
|
||||
ctrlPacket.start_byte = PKT_HEADER;
|
||||
ctrlPacket.header.payload_length = htons(3);
|
||||
ctrlPacket.header.packet_type = PKT_CONTROL;
|
||||
ctrlPacket.field_id = PKT_RESET;
|
||||
ctrlPacket.payload.ctrl.data.paritymode[0] = PKT_PARITYBYTE;
|
||||
ctrlPacket.payload.ctrl.data.paritymode[1] = 0x3U ^ PKT_RESET ^ PKT_PARITYBYTE;
|
||||
if (write(fd, &ctrlPacket, packet_size(ctrlPacket)) == -1) {
|
||||
std::cerr << "InitDV3003: error writing reset packet: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (getresponse(responsePacket)) {
|
||||
std::cerr << "InitDV3003: error receiving response to reset" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (checkResponse(responsePacket, PKT_READY)) {
|
||||
std::cerr << "InitDV3003: invalid response to reset" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ********** turn off parity *********
|
||||
ctrlPacket.header.payload_length = htons(4);
|
||||
ctrlPacket.field_id = PKT_PARITYMODE;
|
||||
ctrlPacket.payload.ctrl.data.paritymode[0] = 0;
|
||||
ctrlPacket.payload.ctrl.data.paritymode[1] = PKT_PARITYBYTE;
|
||||
ctrlPacket.payload.ctrl.data.paritymode[2] = 0x4U ^ PKT_PARITYMODE ^ PKT_PARITYBYTE;
|
||||
if (write(fd, &ctrlPacket, packet_size(ctrlPacket)) == -1) {
|
||||
std::cerr << "InitDV3003: error writing parity control packet: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
memset(&responsePacket, 0, sizeof(responsePacket));
|
||||
if (getresponse(responsePacket)) {
|
||||
std::cerr << "InitDV3003: error receiving response to parity set" << std::endl;
|
||||
dump("Parity Ctrl Response Packet", &responsePacket, 4+ntohs(responsePacket.header.payload_length));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (checkResponse(responsePacket, PKT_PARITYMODE)) {
|
||||
std::cerr << "InitDV3003: invalid response to parity control" << std::endl;
|
||||
dump("Parity Ctrl Response Packet", &responsePacket, packet_size(responsePacket));
|
||||
return true;
|
||||
}
|
||||
|
||||
// ********* Product ID and Version *************
|
||||
ctrlPacket.header.payload_length = htons(1);
|
||||
ctrlPacket.field_id = PKT_PRODID;
|
||||
if (write(fd, &ctrlPacket, packet_size(ctrlPacket)) == -1) {
|
||||
std::cerr << "InitDV3003: error writing product id packet: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (getresponse(responsePacket)) {
|
||||
std::cerr << "InitDV3003: error receiving response to product id request" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (checkResponse(responsePacket, PKT_PRODID)) {
|
||||
std::cerr << "InitDV3003: invalid response to product id query" << std::endl;
|
||||
return true;
|
||||
}
|
||||
strncpy(prodId, responsePacket.payload.ctrl.data.prodid, sizeof(prodId));
|
||||
productid.assign(prodId);
|
||||
|
||||
ctrlPacket.field_id = PKT_VERSTRING;
|
||||
if (write(fd, &ctrlPacket, packet_size(ctrlPacket)) == -1) {
|
||||
std::cerr << "InitDV3003: error writing version packet: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (getresponse(responsePacket)) {
|
||||
std::cerr << "InitDV3003: error receiving response to version request" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (checkResponse(responsePacket, PKT_VERSTRING)) {
|
||||
std::cerr << "InitDV3003: invalid response to version query" << std::endl;
|
||||
return true;
|
||||
}
|
||||
strncpy(versionstr, responsePacket.payload.ctrl.data.version, sizeof(version));
|
||||
version.assign(versionstr);
|
||||
std::cout << "Found " << prodId << " version " << version << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::ConfigureCodec(uint8_t pkt_ch, Encoding type)
|
||||
{
|
||||
SDV3003_Packet controlPacket, responsePacket;
|
||||
const uint8_t dstar[13] { PKT_RATEP, 0x01U, 0x30U, 0x07U, 0x63U, 0x40U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x48U };
|
||||
const uint8_t dmr[13] { PKT_RATEP, 0x04U, 0x31U, 0x07U, 0x54U, 0x24U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x6FU, 0x48U };
|
||||
const uint8_t init[2] { PKT_INIT, 0x3U };
|
||||
|
||||
|
||||
controlPacket.start_byte = PKT_HEADER;
|
||||
controlPacket.header.payload_length = htons(1 + sizeof(SDV3003_Packet::payload.codec));
|
||||
controlPacket.header.packet_type = PKT_CONTROL;
|
||||
controlPacket.field_id = pkt_ch;
|
||||
memcpy(controlPacket.payload.codec.ratep, (type == Encoding::dstar) ? dstar : dmr, 13);
|
||||
memcpy(controlPacket.payload.codec.init, init, 2);
|
||||
|
||||
// write packet
|
||||
if (0 > write(fd, &controlPacket, packet_size(controlPacket)) )
|
||||
{
|
||||
std::cerr << "error writing codec config packet" << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
memset(&responsePacket, 0, sizeof(SDV3003_Packet));
|
||||
if (getresponse(responsePacket)) {
|
||||
std::cerr << "error reading codec config response packet" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((ntohs(responsePacket.header.payload_length) != 6) ||
|
||||
(responsePacket.payload.ctrl.data.resp[1] != PKT_RATEP) ||
|
||||
(responsePacket.payload.ctrl.data.resp[2] != 0x00) ||
|
||||
(responsePacket.payload.ctrl.data.resp[3] != PKT_INIT) ||
|
||||
(responsePacket.payload.ctrl.data.resp[4] != 0x00) ) {
|
||||
std::cerr << "codec config response packet failed" << std::endl;
|
||||
return true;
|
||||
};
|
||||
std::cout << "channel " << (unsigned int)pkt_ch << " is now configured for " << ((Encoding::dstar == type) ? "D-Star" : "DMR") << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
void CDV3003::CloseDevice()
|
||||
{
|
||||
if (fd >= 0) {
|
||||
close(fd);
|
||||
fd = -1;
|
||||
}
|
||||
}
|
||||
|
||||
bool CDV3003::getresponse(SDV3003_Packet &packet)
|
||||
{
|
||||
ssize_t bytesRead;
|
||||
|
||||
// get the start byte
|
||||
packet.start_byte = 0U;
|
||||
const unsigned limit = sizeof(SDV3003_Packet) + 2;
|
||||
unsigned got = 0;
|
||||
for (unsigned i = 0U; i < limit; ++i) {
|
||||
bytesRead = read(fd, &packet.start_byte, 1);
|
||||
if (bytesRead == -1) {
|
||||
std::cerr << "CDV3003: Error reading from serial port: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
if (bytesRead)
|
||||
got++;
|
||||
if (packet.start_byte == PKT_HEADER)
|
||||
break;
|
||||
}
|
||||
if (packet.start_byte != PKT_HEADER) {
|
||||
std::cerr << "CDV3003: Couldn't find start byte in serial data: tried " << limit << " times, got " << got << " bytes" << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
// get the packet size and type (three bytes)
|
||||
ssize_t bytesLeft = sizeof(packet.header);
|
||||
ssize_t total = bytesLeft;
|
||||
while (bytesLeft > 0) {
|
||||
bytesRead = read(fd, ((uint8_t *) &packet.header) + total - bytesLeft, bytesLeft);
|
||||
if(bytesRead == -1) {
|
||||
std::cout << "AMBEserver: Couldn't read serial data header" << std::endl;
|
||||
return true;
|
||||
}
|
||||
bytesLeft -= bytesRead;
|
||||
}
|
||||
|
||||
total = bytesLeft = ntohs(packet.header.payload_length);
|
||||
if (bytesLeft > 1 + int(sizeof(packet.payload))) {
|
||||
std::cout << "AMBEserver: Serial payload exceeds buffer size: " << int(bytesLeft) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
while (bytesLeft > 0) {
|
||||
bytesRead = read(fd, ((uint8_t *) &packet.field_id) + total - bytesLeft, bytesLeft);
|
||||
if (bytesRead == -1) {
|
||||
std::cerr << "AMBEserver: Couldn't read payload: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
bytesLeft -= bytesRead;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::SendAudio(const uint8_t channel, const int16_t *audio) const
|
||||
{
|
||||
// Create Audio packet based on input int8_ts
|
||||
SDV3003_Packet p;
|
||||
p.start_byte = PKT_HEADER;
|
||||
const uint16_t len = 323;
|
||||
p.header.payload_length = htons(len);
|
||||
p.header.packet_type = PKT_SPEECH;
|
||||
p.field_id = channel;
|
||||
p.payload.audio.speechd = 0x0U;
|
||||
p.payload.audio.num_samples = 160U;
|
||||
for (int i=0; i<160; i++)
|
||||
p.payload.audio.samples[i] = htons(audio[i]);
|
||||
|
||||
// send audio packet to DV3000
|
||||
int size = packet_size(p);
|
||||
if (write(fd, &p, size) != size) {
|
||||
std::cerr << "Error sending audio packet" << std::endl;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::GetData(uint8_t *data)
|
||||
{
|
||||
SDV3003_Packet p;
|
||||
// read data packet from DV3000
|
||||
p.start_byte = 0U;
|
||||
if (getresponse(p))
|
||||
return true;
|
||||
if (p.start_byte!=PKT_HEADER || htons(p.header.payload_length)!=12 ||
|
||||
p.header.packet_type!=PKT_CHANNEL || p.payload.ambe.chand!=1U ||
|
||||
p.payload.ambe.num_bits!=72U) {
|
||||
std::cerr << "Error receiving audio packet response" << std::endl;
|
||||
dump("Received AMBE", &p, packet_size(p));
|
||||
return true;
|
||||
}
|
||||
|
||||
// copy it to the output
|
||||
memcpy(data, p.payload.ambe.data, 9);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::SendData(const uint8_t channel, const uint8_t *data) const
|
||||
{
|
||||
// Create data packet
|
||||
SDV3003_Packet p;
|
||||
p.start_byte = PKT_HEADER;
|
||||
p.header.payload_length = htons(12);
|
||||
p.header.packet_type = PKT_CHANNEL;
|
||||
p.field_id = channel;
|
||||
p.payload.ambe.num_bits = 72U;
|
||||
p.payload.ambe.chand = 0x1U;
|
||||
memcpy(p.payload.ambe.data, data, 9);
|
||||
|
||||
// send data packet to DV3000
|
||||
int size = packet_size(p);
|
||||
if (write(fd, &p, size) != size) {
|
||||
std::cerr << "SendData: error sending data packet" << std::endl;
|
||||
dump("Received Data", &p, size);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CDV3003::GetAudio(int16_t *audio)
|
||||
{
|
||||
SDV3003_Packet p;
|
||||
// read audio packet from DV3000
|
||||
p.start_byte = 0U;
|
||||
if (getresponse(p))
|
||||
return true;
|
||||
if (p.start_byte!=PKT_HEADER || htons(p.header.payload_length)!=322 ||
|
||||
p.header.packet_type!=PKT_SPEECH || p.payload.audio.speechd!=0U ||
|
||||
p.payload.audio.num_samples!=160U) {
|
||||
std::cerr << "GetAudio: unexpected audio packet response" << std::endl;
|
||||
int size = packet_size(p);
|
||||
dump("Received Audio", &p, size);
|
||||
return true;
|
||||
}
|
||||
|
||||
for (int i=0; i<160; i++)
|
||||
audio[i] = ntohs(p.payload.audio.samples[i]);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void CDV3003::dump(const char *title, void *pointer, int length) const
|
||||
{
|
||||
assert(title != NULL);
|
||||
assert(pointer != NULL);
|
||||
|
||||
const uint8_t *data = (const uint8_t *)pointer;
|
||||
|
||||
std::cout << title << std::endl;
|
||||
|
||||
unsigned int offset = 0U;
|
||||
|
||||
while (length > 0) {
|
||||
|
||||
unsigned int bytes = (length > 16) ? 16U : length;
|
||||
|
||||
for (unsigned i = 0U; i < bytes; i++) {
|
||||
if (i)
|
||||
std::cout << " ";
|
||||
std::cout << std::hex << std::setw(2) << std::right << std::setfill('0') << int(data[offset + i]);
|
||||
}
|
||||
|
||||
for (unsigned int i = bytes; i < 16U; i++)
|
||||
std::cout << " ";
|
||||
|
||||
std::cout << " *";
|
||||
|
||||
for (unsigned i = 0U; i < bytes; i++) {
|
||||
uint8_t c = data[offset + i];
|
||||
|
||||
if (::isprint(c))
|
||||
std::cout << c;
|
||||
else
|
||||
std::cout << '.';
|
||||
}
|
||||
|
||||
std::cout << '*' << std::endl;
|
||||
|
||||
offset += 16U;
|
||||
|
||||
if (length >= 16)
|
||||
length -= 16;
|
||||
else
|
||||
length = 0;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,115 @@
|
||||
#pragma once
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
#define USB3XXX_MAXPACKETSIZE 1024 // must be multiple of 64
|
||||
|
||||
#define PKT_HEADER 0x61
|
||||
|
||||
#define PKT_CONTROL 0x00
|
||||
#define PKT_CHANNEL 0x01
|
||||
#define PKT_SPEECH 0x02
|
||||
|
||||
#define PKT_SPEECHD 0x00
|
||||
#define PKT_CHAND 0x01
|
||||
#define PKT_RATET 0x09
|
||||
#define PKT_INIT 0x0b
|
||||
#define PKT_PRODID 0x30
|
||||
#define PKT_VERSTRING 0x31
|
||||
#define PKT_PARITYBYTE 0x2F
|
||||
#define PKT_RESET 0x33
|
||||
#define PKT_READY 0x39
|
||||
#define PKT_CHANNEL0 0x40
|
||||
#define PKT_CHANNEL1 0x41
|
||||
#define PKT_CHANNEL2 0x42
|
||||
#define PKT_PARITYMODE 0x3F
|
||||
#define PKT_ECMODE 0x05
|
||||
#define PKT_DCMODE 0x06
|
||||
#define PKT_COMPAND 0x32
|
||||
#define PKT_RATEP 0x0A
|
||||
#define PKT_CHANFMT 0x15
|
||||
#define PKT_SPCHFMT 0x16
|
||||
#define PKT_GAIN 0x4B
|
||||
|
||||
#define packet_size(a) int(1 + sizeof((a).header) + ntohs((a).header.payload_length))
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct dv3003_packet {
|
||||
uint8_t start_byte;
|
||||
struct {
|
||||
uint16_t payload_length;
|
||||
uint8_t packet_type;
|
||||
} header;
|
||||
uint8_t field_id; // for audio and ambe, this is channel# 0x40U, 0x41U or 0x42U
|
||||
union {
|
||||
struct {
|
||||
union {
|
||||
char prodid[16];
|
||||
uint8_t paritymode[3];
|
||||
char version[48];
|
||||
uint8_t resp[5]; // for the codec config response, RATEP and INIT
|
||||
} data;
|
||||
} ctrl;
|
||||
struct {
|
||||
uint8_t ratep[13];
|
||||
uint8_t init[2];
|
||||
} codec;
|
||||
struct {
|
||||
uint8_t speechd; // 0
|
||||
uint8_t num_samples; // 160
|
||||
int16_t samples[160]; // 4 + 1 + 2 + 320 = 327 byte
|
||||
} audio;
|
||||
struct {
|
||||
uint8_t chand; // 1
|
||||
uint8_t num_bits; // 72 (9 bytes)
|
||||
uint8_t data[9]; // 4 + 1 + 2 + 9 = 16 bytes
|
||||
} ambe;
|
||||
} payload;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
using SDV3003_Packet = struct dv3003_packet;
|
||||
enum class Encoding { dstar, dmr };
|
||||
|
||||
class CDV3003 {
|
||||
public:
|
||||
CDV3003(Encoding t);
|
||||
~CDV3003();
|
||||
bool OpenDevice(const std::string &device, int baudrate);
|
||||
bool InitDV3003();
|
||||
bool ConfigureCodec(uint8_t pkt_ch, Encoding type);
|
||||
bool SendAudio(const uint8_t channel, const int16_t *audio) const;
|
||||
bool GetData(uint8_t *data);
|
||||
bool SendData(const uint8_t channel, const uint8_t *data) const;
|
||||
bool GetAudio(int16_t *audio);
|
||||
void CloseDevice();
|
||||
bool IsOpen() const;
|
||||
void dump(const char *title, void *data, int length) const;
|
||||
std::string GetDevicePath() const;
|
||||
std::string GetProductID() const;
|
||||
std::string GetVersion() const;
|
||||
private:
|
||||
const Encoding type;
|
||||
int fd;
|
||||
std::string devicepath, productid, version;
|
||||
bool SetBaudRate(int baudrate);
|
||||
bool getresponse(SDV3003_Packet &packet);
|
||||
bool checkResponse(SDV3003_Packet &responsePacket, uint8_t response) const;
|
||||
};
|
||||
@ -1 +1,3 @@
|
||||
# tcd
|
||||
# TCd
|
||||
|
||||
TCd - A hybrid vocoder that uses both DVSI hardware and open source software to provide a universal transcoding service designed for use by a multi-mode reflector.
|
||||
|
||||
@ -0,0 +1,115 @@
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include "TranscoderPacket.h"
|
||||
|
||||
CTranscoderPacket::CTranscoderPacket() : module(' '), codec_in(ECodecType::none), dstar_set(false), dmr_set(false), m17_set(false)
|
||||
{
|
||||
}
|
||||
|
||||
char CTranscoderPacket::GetModule() const
|
||||
{
|
||||
return module;
|
||||
}
|
||||
|
||||
void CTranscoderPacket::SetModule(char mod)
|
||||
{
|
||||
module = mod;
|
||||
}
|
||||
|
||||
const uint8_t *CTranscoderPacket::GetDStarData()
|
||||
{
|
||||
return data.dstar;
|
||||
}
|
||||
|
||||
const uint8_t *CTranscoderPacket::GetDMRData()
|
||||
{
|
||||
return data.dmr;
|
||||
}
|
||||
|
||||
const uint8_t *CTranscoderPacket::GetM17Data()
|
||||
{
|
||||
return data.m17;
|
||||
}
|
||||
|
||||
void CTranscoderPacket::SetDStarData(const uint8_t *dstar)
|
||||
{
|
||||
memcpy(data.dstar, dstar, 9);
|
||||
dstar_set = true;
|
||||
}
|
||||
void CTranscoderPacket::SetDMRData(const uint8_t *dmr )
|
||||
{
|
||||
memcpy(data.dmr, dmr, 9);
|
||||
dmr_set = true;
|
||||
}
|
||||
|
||||
void CTranscoderPacket::SetM17Data(const uint8_t *m17, bool is_3200)
|
||||
{
|
||||
memcpy(data.m17, m17, is_3200 ? 16 : 8);
|
||||
m17_set = true;
|
||||
m17_is_3200 = is_3200;
|
||||
}
|
||||
|
||||
void CTranscoderPacket::SetCodecIn(ECodecType type, uint8_t *data)
|
||||
{
|
||||
switch (type) {
|
||||
case ECodecType::dstar:
|
||||
SetDStarData(data);
|
||||
break;
|
||||
case ECodecType::dmr:
|
||||
SetDMRData(data);
|
||||
break;
|
||||
case ECodecType::m17_1600:
|
||||
SetM17Data(data, false);
|
||||
break;
|
||||
case ECodecType::m17_3200:
|
||||
SetM17Data(data, true);
|
||||
true;
|
||||
}
|
||||
if (type != ECodecType::none)
|
||||
codec_in = type;
|
||||
}
|
||||
|
||||
ECodecType CTranscoderPacket::GetCodecIn() const
|
||||
{
|
||||
return codec_in;
|
||||
}
|
||||
|
||||
bool CTranscoderPacket::DStarIsSet() const
|
||||
{
|
||||
return dstar_set;
|
||||
}
|
||||
|
||||
bool CTranscoderPacket::DMRIsSet() const
|
||||
{
|
||||
return dmr_set;
|
||||
}
|
||||
|
||||
bool CTranscoderPacket::M17IsSet() const
|
||||
{
|
||||
return m17_set;
|
||||
}
|
||||
|
||||
bool CTranscoderPacket::M17Is3200() const
|
||||
{
|
||||
return m17_is_3200;
|
||||
}
|
||||
|
||||
bool CTranscoderPacket::AllAreSet() const
|
||||
{
|
||||
return (dstar_set && dmr_set && m17_set);
|
||||
}
|
||||
@ -0,0 +1,65 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <cstring>
|
||||
#include <stdint.h>
|
||||
|
||||
using SCodecData = struct codecdata_tag {
|
||||
uint8_t dstar[9];
|
||||
uint8_t dmr[9];
|
||||
uint8_t m17[16];
|
||||
};
|
||||
|
||||
enum class ECodecType { none, dstar, dmr, m17_1600, m17_3200 };
|
||||
|
||||
class CTranscoderPacket
|
||||
{
|
||||
public:
|
||||
// constructor
|
||||
CTranscoderPacket();
|
||||
|
||||
// this packet's refector module;
|
||||
char GetModule() const;
|
||||
void SetModule(char mod);
|
||||
|
||||
// codec
|
||||
const uint8_t *GetDStarData();
|
||||
const uint8_t *GetDMRData();
|
||||
const uint8_t *GetM17Data();
|
||||
void SetDStarData(const uint8_t *dstar);
|
||||
void SetDMRData(const uint8_t *dmr );
|
||||
void SetM17Data(const uint8_t *m17, bool is_3200);
|
||||
|
||||
// first time load
|
||||
void SetCodecIn(ECodecType type, uint8_t *data);
|
||||
|
||||
// state of packet
|
||||
ECodecType GetCodecIn() const;
|
||||
bool DStarIsSet() const;
|
||||
bool DMRIsSet() const;
|
||||
bool M17IsSet() const;
|
||||
bool M17Is3200() const;
|
||||
bool AllAreSet() const;
|
||||
|
||||
private:
|
||||
char module;
|
||||
ECodecType codec_in;
|
||||
bool m17_is_3200, dstar_set, dmr_set, m17_set;
|
||||
SCodecData data;
|
||||
};
|
||||
@ -0,0 +1,219 @@
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
#include <unistd.h>
|
||||
#include <sys/un.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
#include "UnixPacketSocket.h"
|
||||
|
||||
CUnixPacket::CUnixPacket() : m_fd(-1), m_host(NULL) {}
|
||||
|
||||
bool CUnixPacket::Receive(std::vector<uint8_t> &Buffer, unsigned timeout)
|
||||
{
|
||||
// socket valid ?
|
||||
if ( 0 > m_fd )
|
||||
return false;
|
||||
|
||||
// control socket
|
||||
fd_set FdSet;
|
||||
FD_ZERO(&FdSet);
|
||||
FD_SET(m_fd, &FdSet);
|
||||
struct timeval tv;
|
||||
tv.tv_sec = timeout / 1000;
|
||||
tv.tv_usec = (timeout % 1000) * 1000;
|
||||
|
||||
auto rval = select(m_fd + 1, &FdSet, 0, 0, &tv);
|
||||
if (rval < 0)
|
||||
{
|
||||
std::cerr << "select error on Unix socket " << m_name << ": " << strerror(errno) << std::endl;
|
||||
}
|
||||
|
||||
if (rval > 0)
|
||||
{
|
||||
uint8_t buf[USB3XXX_MAXPACKETSIZE];
|
||||
auto len = read(m_fd, buf, USB3XXX_MAXPACKETSIZE);
|
||||
if (len <= 0)
|
||||
return true;
|
||||
Buffer.resize(len);
|
||||
memcpy(Buffer.data(), buf, len);
|
||||
return false;
|
||||
}
|
||||
|
||||
Restart();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CUnixPacket::Write(const void *buffer, const ssize_t size)
|
||||
{
|
||||
if (0 > m_fd)
|
||||
return true;
|
||||
ssize_t written = write(m_fd, buffer, size);
|
||||
if (written != size)
|
||||
{
|
||||
if (-1 == written)
|
||||
{
|
||||
std::cerr << "Write error on '" << m_name << "': " << strerror(errno) << std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "Write error on '" << m_name << "': Only wrote " << written << " of " << size << " bytes" << std::endl;
|
||||
}
|
||||
return Restart();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CUnixPacket::Restart()
|
||||
{
|
||||
if (! m_host->IsRunning())
|
||||
return true;
|
||||
std::cout << "Restarting '" << m_name << "'... " << std::endl;
|
||||
Close();
|
||||
std::string name(m_name);
|
||||
return Open(name.c_str(), m_host);
|
||||
}
|
||||
|
||||
int CUnixPacket::GetFD()
|
||||
{
|
||||
return m_fd;
|
||||
}
|
||||
|
||||
CUnixPacketServer::CUnixPacketServer() : m_server(-1) {}
|
||||
|
||||
CUnixPacketServer::~CUnixPacketServer()
|
||||
{
|
||||
Close();
|
||||
}
|
||||
|
||||
bool CUnixPacketServer::Open(const char *name, CController *host)
|
||||
{
|
||||
m_server = socket(AF_UNIX, SOCK_SEQPACKET, 0);
|
||||
m_host = host;
|
||||
if (m_server < 0)
|
||||
{
|
||||
std::cerr << "Cannot open '" << name << "' socket: " << strerror(errno) << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
struct sockaddr_un addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sun_family = AF_UNIX;
|
||||
memcpy(addr.sun_path+1, name, strlen(name));
|
||||
if (-1 == bind(m_server, (struct sockaddr *)&addr, sizeof(addr)))
|
||||
{
|
||||
std::cerr << "Cannot bind '" << name << "' socket: " << strerror(errno) << std::endl;
|
||||
Close();
|
||||
return true;
|
||||
}
|
||||
|
||||
if (-1 == listen(m_server, 1))
|
||||
{
|
||||
std::cerr << "Cannot listen on '" << name << "' socket: " << strerror(errno) << std::endl;
|
||||
Close();
|
||||
return true;
|
||||
}
|
||||
|
||||
m_fd = accept(m_server, nullptr, 0);
|
||||
if (m_fd < 0)
|
||||
{
|
||||
std::cerr << "Cannot accept on '" << name << "' socket: " << strerror(errno) << std::endl;
|
||||
Close();
|
||||
return true;
|
||||
}
|
||||
|
||||
strncpy(m_name, name, 108);
|
||||
return false;
|
||||
}
|
||||
|
||||
void CUnixPacketServer::Close()
|
||||
{
|
||||
if (m_server >= 0)
|
||||
{
|
||||
close(m_server);
|
||||
m_server = -1;
|
||||
}
|
||||
if (m_fd >= 0)
|
||||
{
|
||||
close(m_fd);
|
||||
m_fd = -1;
|
||||
}
|
||||
}
|
||||
|
||||
CUnixPacketClient::~CUnixPacketClient()
|
||||
{
|
||||
Close();
|
||||
}
|
||||
|
||||
bool CUnixPacketClient::Open(const char *name, CController *host)
|
||||
{
|
||||
m_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
|
||||
if (m_fd < 0)
|
||||
{
|
||||
std::cerr << "Cannot open unix client socket " << name << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
struct sockaddr_un addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sun_family = AF_UNIX;
|
||||
memcpy(addr.sun_path+1, name, strlen(name));
|
||||
int rval = -1;
|
||||
int tries = 0;
|
||||
while (rval < 0)
|
||||
{
|
||||
rval = connect(m_fd, (struct sockaddr *)&addr, sizeof(addr));
|
||||
if (rval < 0)
|
||||
{
|
||||
if (ECONNREFUSED == errno)
|
||||
{
|
||||
if (0 == tries++ % 20)
|
||||
std::cout << "Waiting for " << name << " server to start..." << std::endl;
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(250));
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "Cannot connect '" << name << "' socket: " << strerror(errno) << std::endl;
|
||||
Close();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (! m_host->IsRunning())
|
||||
{
|
||||
Close();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
m_host = host;
|
||||
strncpy(m_name, name, 108);
|
||||
return false;
|
||||
}
|
||||
|
||||
void CUnixPacketClient::Close()
|
||||
{
|
||||
if (m_fd >= 0)
|
||||
{
|
||||
close(m_fd);
|
||||
m_fd = -1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
// tcd - a hybid transcoder using DVSI hardware and Codec2 software
|
||||
// Copyright © 2021 Thomas A. Early N7TAE
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include <vector>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "Controller.h"
|
||||
|
||||
class CUnixPacket
|
||||
{
|
||||
public:
|
||||
CUnixPacket();
|
||||
virtual bool Open(const char *name, CController *host) = 0;
|
||||
virtual void Close() = 0;
|
||||
bool Write(const void *buffer, const ssize_t size);
|
||||
bool Receive(std::vector<uint8_t> &buf, unsigned timeout);
|
||||
int GetFD();
|
||||
protected:
|
||||
bool Restart();
|
||||
int m_fd;
|
||||
CController *m_host;
|
||||
char m_name[108];
|
||||
};
|
||||
|
||||
class CUnixPacketServer : public CUnixPacket
|
||||
{
|
||||
public:
|
||||
CUnixPacketServer();
|
||||
~CUnixPacketServer();
|
||||
bool Open(const char *name, CController *host);
|
||||
void Close();
|
||||
protected:
|
||||
int m_server;
|
||||
};
|
||||
|
||||
class CUnixPacketClient : public CUnixPacket
|
||||
{
|
||||
public:
|
||||
~CUnixPacketClient();
|
||||
bool Open(const char *name, CController *host);
|
||||
void Close();
|
||||
};
|
||||
Loading…
Reference in new issue