Merge pull request #370 from alanbjohnston/fc
Version v2.1 with FunCube Mode and Cross Band Repeater modemaster-ff
Alan Johnston
6 months ago
committed by
GitHub
commit
b4242cce04
@ -0,0 +1,46 @@
|
||||
pcm.!default {
|
||||
type asym
|
||||
playback.pcm "softvol"
|
||||
capture.pcm "shared_mic"
|
||||
}
|
||||
|
||||
ctl.!default {
|
||||
type hw
|
||||
card 2
|
||||
}
|
||||
|
||||
# Playback with software volume and mixing
|
||||
pcm.softvol {
|
||||
type softvol
|
||||
slave.pcm "shared_speaker"
|
||||
control {
|
||||
name "Master"
|
||||
card 2
|
||||
}
|
||||
}
|
||||
|
||||
pcm.shared_speaker {
|
||||
type dmix
|
||||
ipc_key 1024
|
||||
slave {
|
||||
pcm "hw:2,0"
|
||||
rate 48000
|
||||
period_time 0
|
||||
period_size 1024
|
||||
buffer_size 4096
|
||||
}
|
||||
}
|
||||
|
||||
# Recording with input mixing
|
||||
pcm.shared_mic {
|
||||
type dsnoop
|
||||
ipc_key 2048
|
||||
slave {
|
||||
pcm "hw:2,0"
|
||||
# channels 1
|
||||
rate 48000
|
||||
period_time 0
|
||||
period_size 1024
|
||||
buffer_size 4096
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,529 @@
|
||||
#include <string.h>
|
||||
#include "codecAO40.h"
|
||||
|
||||
/* ---------------------- */
|
||||
/* AO40 Encoder - Decoder */
|
||||
/* ---------------------- */
|
||||
|
||||
/* Scramble and RS encode 256 byte blocks of data into 5200 bits
|
||||
* or Descramble and RS decode 5200 bits into the 256 bytes of data
|
||||
*
|
||||
* --------------------------------------------------------------------------
|
||||
* This decoder has evolved extensively through the work of Phil Karn. It draws
|
||||
* on his own ideas and optimisations, and on the work of others. The lineage
|
||||
* is as below, and parts of the authors' notices are included here. (JRM)
|
||||
|
||||
* AO40 encoder / decoder
|
||||
* Copyright 2002 Phil Karn, KA9Q
|
||||
* May be used under the terms of the GNU General Public License (GPL)
|
||||
*
|
||||
* Reed-Solomon coding and decoding
|
||||
* Phil Karn (karn@ka9q.ampr.org) September 1996
|
||||
*
|
||||
* This file is derived from the program "new_rs_erasures.c" by Robert
|
||||
* Morelos-Zaragoza (robert@spectra.eng.hawaii.edu) and Hari Thirumoorthy
|
||||
* (harit@spectra.eng.hawaii.edu), Aug 1995
|
||||
* --------------------------------------------------------------------------
|
||||
*
|
||||
* From the RM-Z & HT program:
|
||||
* The encoding and decoding methods are based on the
|
||||
* book "Error Control Coding: Fundamentals and Applications",
|
||||
* by Lin and Costello, Prentice Hall, 1983, ISBN 0-13-283796-X
|
||||
* Portions of this program are from a Reed-Solomon encoder/decoder
|
||||
* in C, written by Simon Rockliff (simon@augean.ua.oz.au) on 21/9/89.
|
||||
* --------------------------------------------------------------------------
|
||||
*
|
||||
* From the 1989/1991 SR program (also based on Lin and Costello):
|
||||
* This program may be freely modified and/or given to whoever wants it.
|
||||
* A condition of such distribution is that the author's contribution be
|
||||
* acknowledged by his name being left in the comments heading the program,
|
||||
* Simon Rockliff, 26th June 1991
|
||||
*
|
||||
*/
|
||||
|
||||
/* Defines for RS Decoder(s) */
|
||||
#ifndef min
|
||||
#define min(a,b) ((a) < (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
/*
|
||||
CCodecAO40::CCodecAO40(void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
CCodecAO40::~CCodecAO40(void)
|
||||
{
|
||||
}
|
||||
|
||||
*/
|
||||
//int CCodecAO40::mod255(int x) {
|
||||
int mod255(int x) {
|
||||
while (x >= 255) {
|
||||
x -= 255;
|
||||
x = (x >> 8) + (x & 255);
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
//int CCodecAO40::decode_rs_8(char *data, int *eras_pos, int no_eras){
|
||||
int decode_rs_8(char *data, int *eras_pos, int no_eras){
|
||||
|
||||
int deg_lambda, el, deg_omega;
|
||||
int i, j, r,k;
|
||||
unsigned char u,q,tmp,num1,num2,den,discr_r;
|
||||
unsigned char lambda[NROOTS+1], s[NROOTS]; /* Err+Eras Locator poly and syndrome poly */
|
||||
unsigned char b[NROOTS+1], t[NROOTS+1], omega[NROOTS+1];
|
||||
unsigned char root[NROOTS], reg[NROOTS+1], loc[NROOTS];
|
||||
int syn_error, count;
|
||||
|
||||
/* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
|
||||
for(i=0;i<NROOTS;i++)
|
||||
s[i] = data[0];
|
||||
|
||||
for(j=1;j<NN;j++){
|
||||
for(i=0;i<NROOTS;i++){
|
||||
if(s[i] == 0){
|
||||
s[i] = data[j];
|
||||
} else {
|
||||
s[i] = data[j] ^ ALPHA_TO[mod255(INDEX_OF[s[i]] + (FCR+i)*PRIM)];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Convert syndromes to index form, checking for nonzero condition */
|
||||
syn_error = 0;
|
||||
for(i=0;i<NROOTS;i++){
|
||||
syn_error |= s[i];
|
||||
s[i] = INDEX_OF[s[i]];
|
||||
}
|
||||
|
||||
if (!syn_error) {
|
||||
/* if syndrome is zero, data[] is a codeword and there are no
|
||||
* errors to correct. So return data[] unmodified
|
||||
*/
|
||||
count = 0;
|
||||
goto finish;
|
||||
}
|
||||
memset(&lambda[1],0,NROOTS*sizeof(lambda[0]));
|
||||
lambda[0] = 1;
|
||||
|
||||
if (no_eras > 0) {
|
||||
/* Init lambda to be the erasure locator polynomial */
|
||||
lambda[1] = ALPHA_TO[mod255(PRIM*(NN-1-eras_pos[0]))];
|
||||
for (i = 1; i < no_eras; i++) {
|
||||
u = mod255(PRIM*(NN-1-eras_pos[i]));
|
||||
for (j = i+1; j > 0; j--) {
|
||||
tmp = INDEX_OF[lambda[j - 1]];
|
||||
if(tmp != A0)
|
||||
lambda[j] ^= ALPHA_TO[mod255(u + tmp)];
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i=0;i<NROOTS+1;i++)
|
||||
b[i] = INDEX_OF[lambda[i]];
|
||||
|
||||
/*
|
||||
* Begin Berlekamp-Massey algorithm to determine error+erasure
|
||||
* locator polynomial
|
||||
*/
|
||||
r = no_eras;
|
||||
el = no_eras;
|
||||
while (++r <= NROOTS) { /* r is the step number */
|
||||
/* Compute discrepancy at the r-th step in poly-form */
|
||||
discr_r = 0;
|
||||
for (i = 0; i < r; i++){
|
||||
if ((lambda[i] != 0) && (s[r-i-1] != A0)) {
|
||||
discr_r ^= ALPHA_TO[mod255(INDEX_OF[lambda[i]] + s[r-i-1])];
|
||||
}
|
||||
}
|
||||
discr_r = INDEX_OF[discr_r]; /* Index form */
|
||||
if (discr_r == A0) {
|
||||
/* 2 lines below: B(x) <-- x*B(x) */
|
||||
memmove(&b[1],b,NROOTS*sizeof(b[0]));
|
||||
b[0] = A0;
|
||||
} else {
|
||||
/* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
|
||||
t[0] = lambda[0];
|
||||
for (i = 0 ; i < NROOTS; i++) {
|
||||
if(b[i] != A0)
|
||||
t[i+1] = lambda[i+1] ^ ALPHA_TO[mod255(discr_r + b[i])];
|
||||
else
|
||||
t[i+1] = lambda[i+1];
|
||||
}
|
||||
if (2 * el <= r + no_eras - 1) {
|
||||
el = r + no_eras - el;
|
||||
/*
|
||||
* 2 lines below: B(x) <-- inv(discr_r) *
|
||||
* lambda(x)
|
||||
*/
|
||||
for (i = 0; i <= NROOTS; i++)
|
||||
b[i] = (lambda[i] == 0) ? A0 : mod255(INDEX_OF[lambda[i]] - discr_r + NN);
|
||||
} else {
|
||||
/* 2 lines below: B(x) <-- x*B(x) */
|
||||
memmove(&b[1],b,NROOTS*sizeof(b[0]));
|
||||
b[0] = A0;
|
||||
}
|
||||
memcpy(lambda,t,(NROOTS+1)*sizeof(t[0]));
|
||||
}
|
||||
}
|
||||
|
||||
/* Convert lambda to index form and compute deg(lambda(x)) */
|
||||
deg_lambda = 0;
|
||||
for(i=0;i<NROOTS+1;i++){
|
||||
lambda[i] = INDEX_OF[lambda[i]];
|
||||
if(lambda[i] != A0)
|
||||
deg_lambda = i;
|
||||
}
|
||||
/* Find roots of the error+erasure locator polynomial by Chien search */
|
||||
memcpy(®[1],&lambda[1],NROOTS*sizeof(reg[0]));
|
||||
count = 0; /* Number of roots of lambda(x) */
|
||||
for (i = 1,k=IPRIM-1; i <= NN; i++,k = mod255(k+IPRIM)) {
|
||||
q = 1; /* lambda[0] is always 0 */
|
||||
for (j = deg_lambda; j > 0; j--){
|
||||
if (reg[j] != A0) {
|
||||
reg[j] = mod255(reg[j] + j);
|
||||
q ^= ALPHA_TO[reg[j]];
|
||||
}
|
||||
}
|
||||
if (q != 0)
|
||||
continue; /* Not a root */
|
||||
/* store root (index-form) and error location number */
|
||||
root[count] = i;
|
||||
loc[count] = k;
|
||||
/* If we've already found max possible roots,
|
||||
* abort the search to save time
|
||||
*/
|
||||
if(++count == deg_lambda)
|
||||
break;
|
||||
}
|
||||
if (deg_lambda != count) {
|
||||
/*
|
||||
* deg(lambda) unequal to number of roots => uncorrectable
|
||||
* error detected
|
||||
*/
|
||||
count = -1;
|
||||
goto finish;
|
||||
}
|
||||
/*
|
||||
* Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
|
||||
* x**NROOTS). in index form. Also find deg(omega).
|
||||
*/
|
||||
deg_omega = 0;
|
||||
for (i = 0; i < NROOTS;i++){
|
||||
tmp = 0;
|
||||
j = (deg_lambda < i) ? deg_lambda : i;
|
||||
for(;j >= 0; j--){
|
||||
if ((s[i - j] != A0) && (lambda[j] != A0))
|
||||
tmp ^= ALPHA_TO[mod255(s[i - j] + lambda[j])];
|
||||
}
|
||||
if(tmp != 0)
|
||||
deg_omega = i;
|
||||
omega[i] = INDEX_OF[tmp];
|
||||
}
|
||||
omega[NROOTS] = A0;
|
||||
|
||||
/*
|
||||
* Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
|
||||
* inv(X(l))**(FCR-1) and den = lambda_pr(inv(X(l))) all in poly-form
|
||||
*/
|
||||
for (j = count-1; j >=0; j--) {
|
||||
num1 = 0;
|
||||
for (i = deg_omega; i >= 0; i--) {
|
||||
if (omega[i] != A0)
|
||||
num1 ^= ALPHA_TO[mod255(omega[i] + i * root[j])];
|
||||
}
|
||||
num2 = ALPHA_TO[mod255(root[j] * (FCR - 1) + NN)];
|
||||
den = 0;
|
||||
|
||||
/* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
|
||||
for (i = min(deg_lambda,NROOTS-1) & ~1; i >= 0; i -=2) {
|
||||
if(lambda[i+1] != A0)
|
||||
den ^= ALPHA_TO[mod255(lambda[i+1] + i * root[j])];
|
||||
}
|
||||
if (den == 0) {
|
||||
count = -1;
|
||||
goto finish;
|
||||
}
|
||||
/* Apply error to data */
|
||||
if (num1 != 0) {
|
||||
data[loc[j]] ^= ALPHA_TO[mod255(INDEX_OF[num1] + INDEX_OF[num2] + NN - INDEX_OF[den])];
|
||||
}
|
||||
}
|
||||
finish:
|
||||
if(eras_pos != NULL){
|
||||
for(i=0;i<count;i++)
|
||||
eras_pos[i] = loc[i];
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* ---------- */
|
||||
/* Re-encoder */
|
||||
/* ---------- */
|
||||
|
||||
/* Reference encoder for proposed coded AO-40 telemetry format - v1.0 7 Jan 2002
|
||||
* Copyright 2002, Phil Karn, KA9Q
|
||||
* This software may be used under the terms of the GNU Public License (GPL)
|
||||
*/
|
||||
|
||||
/* Adapted from the above enc_ref.c as used by the spacecraft (JRM) */
|
||||
|
||||
|
||||
/* Write one binary channel symbol into the interleaver frame and update the pointers */
|
||||
//void CCodecAO40::interleave_symbol(int c)
|
||||
void interleave_symbol(int c)
|
||||
{
|
||||
int row,col;
|
||||
col=m_ileaver_index/COLUMNS;
|
||||
row=m_ileaver_index%COLUMNS;
|
||||
if(c)
|
||||
{
|
||||
m_encoded[row*ROWS+col] = 1;
|
||||
}
|
||||
m_ileaver_index++;
|
||||
}
|
||||
|
||||
/* Convolutionally encode and interleave one byte */
|
||||
//void CCodecAO40::encode_and_interleave(unsigned char c,int cnt){
|
||||
void encode_and_interleave(unsigned char c,int cnt){
|
||||
while(cnt-- != 0)
|
||||
{
|
||||
m_conv_sr = (m_conv_sr << 1) | (c >> 7);
|
||||
c <<= 1;
|
||||
interleave_symbol( Partab[m_conv_sr & CPOLYA]);
|
||||
interleave_symbol(!Partab[m_conv_sr & CPOLYB]); /* Second encoder symbol is inverted */
|
||||
}
|
||||
}
|
||||
|
||||
/* Scramble a byte, convolutionally encode and interleave into frame */
|
||||
//void CCodecAO40::scramble_and_encode(unsigned char c){
|
||||
void scramble_and_encode(unsigned char c){
|
||||
c ^= Scrambler[m_encoded_bytes]; /* Scramble byte */
|
||||
encode_and_interleave(c,8); /* RS encode and place into reencode buffer */
|
||||
}
|
||||
|
||||
/* Encodes the 256 byte source block RSdecdata[] into 5200 byte block of symbols
|
||||
* results stored in m_encoded.
|
||||
* On success encoded buffer is returned, an zeroed buffer on failure
|
||||
*/
|
||||
//const unsigned char *CCodecAO40::encode(unsigned char *source_bytes, int byte_count)
|
||||
const unsigned char *encode(unsigned char *source_bytes, int byte_count)
|
||||
{
|
||||
if(BLOCKSIZE != byte_count || NULL == source_bytes )
|
||||
{
|
||||
memset(m_encoded, 0, BLOCKSIZE);
|
||||
return m_encoded;
|
||||
}
|
||||
|
||||
init_encoder();
|
||||
|
||||
for(int i=0;i<BLOCKSIZE;i++)
|
||||
{
|
||||
encode_byte(source_bytes[i]) ;
|
||||
}
|
||||
|
||||
for(int i=0;i<64;i++)
|
||||
{
|
||||
encode_parity();
|
||||
}
|
||||
|
||||
return m_encoded;
|
||||
}
|
||||
|
||||
/* The original three C user's entry points now follow. They are:
|
||||
|
||||
init_encoder() Called once before using system.
|
||||
encode_byte(unsigned char c) Called with each user byte (i.e. 256 calls)
|
||||
encode_parity() Called 64 times to finish off
|
||||
|
||||
*/
|
||||
|
||||
/* This function initializes the encoder. */
|
||||
//void CCodecAO40::init_encoder(void){
|
||||
void init_encoder(void){
|
||||
int i,j,sr;
|
||||
|
||||
m_encoded_bytes = 0;
|
||||
m_conv_sr = 0;
|
||||
m_ileaver_index = COLUMNS; /* Sync vector is in first column; data starts here */
|
||||
|
||||
for(j=0;j<RSBLOCKS;j++) /* Flush parity array */
|
||||
{
|
||||
for(i=0;i<NROOTS;i++)
|
||||
{
|
||||
m_RS_block[j][i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Clear re-encoded array */
|
||||
for(i=0;i<SYMPBLOCK;i++)
|
||||
{
|
||||
m_encoded[i] = 0;
|
||||
}
|
||||
|
||||
/* Generate sync vector, interleave into re-encode array, 1st column */
|
||||
sr = 0x7f;
|
||||
for(i=0;i<65;i++)
|
||||
{
|
||||
if(sr & 64)
|
||||
{
|
||||
m_encoded[ROWS*i] = 1; /* Every 80th symbol is a sync bit */
|
||||
}
|
||||
sr = (sr << 1) | Partab[sr & SYNC_POLY];
|
||||
}
|
||||
}
|
||||
|
||||
/* This function is called with each user data byte to be encoded into the
|
||||
* current frame. It should be called in sequence 256 times per frame, followed
|
||||
* by 64 calls to encode_parity().
|
||||
*/
|
||||
//void CCodecAO40::encode_byte(unsigned char c){
|
||||
void encode_byte(unsigned char c){
|
||||
unsigned char *rp; /* RS block pointer */
|
||||
int i;
|
||||
unsigned char feedback;
|
||||
|
||||
/* Update the appropriate Reed-Solomon codeword */
|
||||
rp = m_RS_block[m_encoded_bytes & 1];
|
||||
|
||||
/* Compute feedback term */
|
||||
feedback = INDEX_OF[c ^ rp[0]];
|
||||
|
||||
/* If feedback is non-zero, multiply by each generator polynomial coefficient and
|
||||
* add to corresponding shift register elements
|
||||
*/
|
||||
if(feedback != A0){
|
||||
int j;
|
||||
|
||||
/* This loop exploits the palindromic nature of the generator polynomial
|
||||
* to halve the number of discrete multiplications
|
||||
*/
|
||||
for(j=0;j<15;j++){
|
||||
unsigned char t;
|
||||
|
||||
t = ALPHA_TO[mod255(feedback + RS_poly[j])];
|
||||
rp[j+1] ^= t; rp[31-j] ^= t;
|
||||
}
|
||||
rp[16] ^= ALPHA_TO[mod255(feedback + RS_poly[15])];
|
||||
}
|
||||
|
||||
/* Shift 32 byte RS register one position down */
|
||||
for(i=0;i<31;i++)
|
||||
rp[i] = rp[i+1];
|
||||
|
||||
/* Handle highest order coefficient, which is unity */
|
||||
if(feedback != A0){
|
||||
rp[31] = ALPHA_TO[feedback];
|
||||
} else {
|
||||
rp[31] = 0;
|
||||
}
|
||||
scramble_and_encode(c);
|
||||
m_encoded_bytes++;
|
||||
}
|
||||
|
||||
/* This function should be called 64 times after the 256 data bytes
|
||||
* have been passed to update_encoder. Each call scrambles, encodes and
|
||||
* interleaves one byte of Reed-Solomon parity.
|
||||
*/
|
||||
//void CCodecAO40::encode_parity(void) {
|
||||
void encode_parity(void) {
|
||||
unsigned char c;
|
||||
|
||||
c = m_RS_block[m_encoded_bytes & 1][(m_encoded_bytes-256)>>1];
|
||||
scramble_and_encode(c);
|
||||
if(++m_encoded_bytes == 320){
|
||||
/* Tail off the convolutional encoder (flush) */
|
||||
encode_and_interleave(0,6);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//void CCodecAO40::descramble_to_rsblocks(unsigned char viterbi_decoded[NBITS_OUT], char rsblocks[RSBLOCKS][NN])
|
||||
void descramble_to_rsblocks(unsigned char viterbi_decoded[NBITS_OUT], char rsblocks[RSBLOCKS][NN])
|
||||
{
|
||||
/* interleave into Reed Solomon codeblocks */
|
||||
memset(rsblocks,0,RSBLOCKS*NN); /* Zero rsblocks array */
|
||||
int di = 0;
|
||||
int si = 0;
|
||||
for(int col=RSPAD;col<NN;col++)
|
||||
{
|
||||
for(int row=0;row<RSBLOCKS;row++)
|
||||
{
|
||||
rsblocks[row][col] = viterbi_decoded[di++] ^ Scrambler[si++]; /* Remove scrambling */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------- */
|
||||
/* Decoder */
|
||||
/* -------- */
|
||||
|
||||
/* ------------------- */
|
||||
|
||||
/* There are two RS decoders, processing 128 bytes each.
|
||||
*
|
||||
* If both RS decoders are SUCCESSFUL
|
||||
* On exit:
|
||||
* rs_failures = 0
|
||||
* rserrs[x] = number of errors corrected; range 0 to 16 (x= 0 or 1)
|
||||
* Data output is in array RSdecdata[256].
|
||||
*
|
||||
* If an RS decoder FAILS
|
||||
* On exit:
|
||||
* rs_failures = 1 or 2 (i.e. != 0)
|
||||
* rserrs[x] contains -1
|
||||
* Data output should not be used.
|
||||
*/
|
||||
//int CCodecAO40::decode(unsigned char vitdecdata[NBITS_OUT], unsigned char *decoded_data)
|
||||
int decode(unsigned char vitdecdata[NBITS_OUT], unsigned char *decoded_data)
|
||||
{
|
||||
int row, col, row_errors, total_errors;
|
||||
char rsblocks[RSBLOCKS][NN];
|
||||
|
||||
descramble_to_rsblocks(vitdecdata, rsblocks);
|
||||
|
||||
/* Run RS-decoder(s) */
|
||||
row_errors = total_errors = 0;
|
||||
for(row=0; row<RSBLOCKS && row_errors!= -1; row++)
|
||||
{
|
||||
// decode row, returns -1 on failure or number of corrected errors
|
||||
row_errors = decode_rs_8(rsblocks[row],NULL,0);
|
||||
total_errors += row_errors;
|
||||
}
|
||||
|
||||
if(row_errors != -1)
|
||||
{
|
||||
/* if frame decoded OK, deinterleave data from RS codeword(s) */
|
||||
int j = 0;
|
||||
for(col=RSPAD;col<KK;col++)
|
||||
{
|
||||
for(row=0;row<RSBLOCKS;row++)
|
||||
{
|
||||
decoded_data[j++] = rsblocks[row][col];
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
total_errors = -1;
|
||||
}
|
||||
|
||||
return total_errors;
|
||||
}
|
||||
|
||||
/* Compairs raw input symbols to current buffer of encoded symbols and counts the errors */
|
||||
//int CCodecAO40::count_errors(unsigned char *raw_symbols)
|
||||
int count_errors(unsigned char *raw_symbols)
|
||||
{
|
||||
int error_count = 0;
|
||||
for(int i=0;i<SYMPBLOCK;i++)
|
||||
{
|
||||
if ( m_encoded[i] != (raw_symbols[i]>>7) )
|
||||
{
|
||||
error_count++ ;
|
||||
}
|
||||
}
|
||||
return error_count;
|
||||
}
|
||||
@ -0,0 +1,110 @@
|
||||
/* AO40 encoder / decoder
|
||||
* Copyright 2002 Phil Karn, KA9Q
|
||||
* May be used under the terms of the GNU General Public License (GPL)
|
||||
* See CodecAO40.cpp for lineage
|
||||
*
|
||||
* This file is part of FUNcubeLib.
|
||||
*
|
||||
* FUNcubeLib 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.
|
||||
*
|
||||
* FUNcubeLib 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 FUNcubeLib If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
//#include "fecConstants.h"
|
||||
|
||||
|
||||
/*
|
||||
Amsat P3 FEC Encoder/decoder system. Look-up tables
|
||||
Created by Phil Karn KA9Q and James Miller G3RUH
|
||||
Last modified 2003 Jun 20
|
||||
*/
|
||||
|
||||
/* Defines for Viterbi Decoder for r=1/2 k=7 (to CCSDS convention) */
|
||||
#define K 7 /* Constraint length */
|
||||
#define N 2 /* Number of symbols per data bit */
|
||||
#define CPOLYA 0x4f /* First convolutional encoder polynomial */
|
||||
#define CPOLYB 0x6d /* Second convolutional encoder polynomial */
|
||||
|
||||
#define SYNC_POLY 0x48 /* Sync vector PN polynomial */
|
||||
|
||||
#define NN 255
|
||||
#define KK 223
|
||||
#define NROOTS 32 /* NN-KK */
|
||||
#define A0 (NN)
|
||||
#define FCR 112
|
||||
#define PRIM 11
|
||||
#define IPRIM 116
|
||||
#define BLOCKSIZE 256 /* Data bytes per frame */
|
||||
#define RSBLOCKS 2 /* Number of RS decoder blocks */
|
||||
#define RSPAD 95 /* Unused bytes in block (KK-BLOCKSIZE/RSBLOCKS) */
|
||||
|
||||
/* Defines for Interleaver */
|
||||
#define ROWS 80 /* Block interleaver rows */
|
||||
#define COLUMNS 65 /* Block interleaver columns */
|
||||
#define SYMPBLOCK (ROWS*COLUMNS) /* Encoded symbols per block */
|
||||
|
||||
/* Number of symbols in an FEC block that are */
|
||||
/* passed to the Viterbi decoder (320*8 + 6) */
|
||||
#define NBITS ((BLOCKSIZE+NROOTS*RSBLOCKS)*8+K-1)
|
||||
/* Number of bits obtained from Viterbi decoder */
|
||||
#define NBITS_OUT (BLOCKSIZE+NROOTS*RSBLOCKS)
|
||||
|
||||
|
||||
extern unsigned char m_RS_block[RSBLOCKS][NROOTS]; /* RS parity blocks */
|
||||
extern unsigned char m_encoded[SYMPBLOCK] ; /* encoded symbols */
|
||||
extern int m_encoded_bytes; /* Byte counter for encode_data() */
|
||||
extern int m_ileaver_index; /* Byte counter for interleaver */
|
||||
extern unsigned char m_conv_sr; /* Convolutional encoder shift register state */
|
||||
|
||||
extern const unsigned char RS_poly[];
|
||||
extern const unsigned char ALPHA_TO[];
|
||||
extern const unsigned char INDEX_OF[];
|
||||
extern const unsigned char Partab[];
|
||||
extern const unsigned char Scrambler[];
|
||||
|
||||
//class CCodecAO40
|
||||
//{
|
||||
//public:
|
||||
// CCodecAO40(void);
|
||||
// virtual ~CCodecAO40(void);
|
||||
|
||||
int decode(unsigned char viterbi_decoded[NBITS_OUT], unsigned char *decoded_data);
|
||||
|
||||
/* Encodes the 256 byte source block into 5200 byte block of symbols into m_encoded buffer */
|
||||
const unsigned char *encode(
|
||||
unsigned char *source_bytes, /* input to encode */
|
||||
int byte_count); /* input length in bytes */
|
||||
|
||||
/* Compares raw input symbols to current buffer of encoded symbols and counts the errors */
|
||||
int count_errors( unsigned char *raw_symbols);
|
||||
|
||||
//private:
|
||||
int mod255(int x);
|
||||
int decode_rs_8(char *data, int *eras_pos, int no_eras);
|
||||
void scramble_and_encode(unsigned char c);
|
||||
void encode_and_interleave(unsigned char c,int cnt);
|
||||
|
||||
void descramble_to_rsblocks(
|
||||
unsigned char viterbi_decoded[NBITS_OUT],
|
||||
char rsblocks[RSBLOCKS][NN]);
|
||||
|
||||
void init_encoder(void);
|
||||
void encode_byte(unsigned char c);
|
||||
void encode_parity(void);
|
||||
|
||||
void interleave_symbol(int c);
|
||||
|
||||
|
||||
//};
|
||||
@ -1,2 +1,2 @@
|
||||
ADEVICE hw:CARD=Device,DEV=0 default
|
||||
ADEVICE shared_mic hw:CARD=Loopback,DEV=1
|
||||
DTMF
|
||||
|
||||
@ -0,0 +1,128 @@
|
||||
#pragma once
|
||||
|
||||
/*
|
||||
Amsat P3 FEC Encoder/decoder system. Look-up tables
|
||||
Created by Phil Karn KA9Q and James Miller G3RUH
|
||||
Last modified 2003 Jun 20
|
||||
*/
|
||||
|
||||
/* Defines for Viterbi Decoder for r=1/2 k=7 (to CCSDS convention) */
|
||||
#define K 7 /* Constraint length */
|
||||
#define N 2 /* Number of symbols per data bit */
|
||||
#define CPOLYA 0x4f /* First convolutional encoder polynomial */
|
||||
#define CPOLYB 0x6d /* Second convolutional encoder polynomial */
|
||||
|
||||
#define SYNC_POLY 0x48 /* Sync vector PN polynomial */
|
||||
|
||||
#define NN 255
|
||||
#define KK 223
|
||||
#define NROOTS 32 /* NN-KK */
|
||||
#define A0 (NN)
|
||||
#define FCR 112
|
||||
#define PRIM 11
|
||||
#define IPRIM 116
|
||||
#define BLOCKSIZE 256 /* Data bytes per frame */
|
||||
#define RSBLOCKS 2 /* Number of RS decoder blocks */
|
||||
#define RSPAD 95 /* Unused bytes in block (KK-BLOCKSIZE/RSBLOCKS) */
|
||||
|
||||
/* Defines for Interleaver */
|
||||
#define ROWS 80 /* Block interleaver rows */
|
||||
#define COLUMNS 65 /* Block interleaver columns */
|
||||
#define SYMPBLOCK (ROWS*COLUMNS) /* Encoded symbols per block */
|
||||
|
||||
/* Number of symbols in an FEC block that are */
|
||||
/* passed to the Viterbi decoder (320*8 + 6) */
|
||||
#define NBITS ((BLOCKSIZE+NROOTS*RSBLOCKS)*8+K-1)
|
||||
/* Number of bits obtained from Viterbi decoder */
|
||||
#define NBITS_OUT (BLOCKSIZE+NROOTS*RSBLOCKS)
|
||||
|
||||
const unsigned char RS_poly[] = {
|
||||
249, 59, 66, 4, 43,126,251, 97, 30, 3,213, 50, 66,170, 5, 24
|
||||
};
|
||||
|
||||
/* Tables for RS decoder */
|
||||
/* Galois field log/antilog tables */
|
||||
const unsigned char ALPHA_TO[] =
|
||||
{
|
||||
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x87, 0x89, 0x95, 0xad, 0xdd, 0x3d, 0x7a, 0xf4,
|
||||
0x6f, 0xde, 0x3b, 0x76, 0xec, 0x5f, 0xbe, 0xfb, 0x71, 0xe2, 0x43, 0x86, 0x8b, 0x91, 0xa5, 0xcd,
|
||||
0x1d, 0x3a, 0x74, 0xe8, 0x57, 0xae, 0xdb, 0x31, 0x62, 0xc4, 0x0f, 0x1e, 0x3c, 0x78, 0xf0, 0x67,
|
||||
0xce, 0x1b, 0x36, 0x6c, 0xd8, 0x37, 0x6e, 0xdc, 0x3f, 0x7e, 0xfc, 0x7f, 0xfe, 0x7b, 0xf6, 0x6b,
|
||||
0xd6, 0x2b, 0x56, 0xac, 0xdf, 0x39, 0x72, 0xe4, 0x4f, 0x9e, 0xbb, 0xf1, 0x65, 0xca, 0x13, 0x26,
|
||||
0x4c, 0x98, 0xb7, 0xe9, 0x55, 0xaa, 0xd3, 0x21, 0x42, 0x84, 0x8f, 0x99, 0xb5, 0xed, 0x5d, 0xba,
|
||||
0xf3, 0x61, 0xc2, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0,
|
||||
0x47, 0x8e, 0x9b, 0xb1, 0xe5, 0x4d, 0x9a, 0xb3, 0xe1, 0x45, 0x8a, 0x93, 0xa1, 0xc5, 0x0d, 0x1a,
|
||||
0x34, 0x68, 0xd0, 0x27, 0x4e, 0x9c, 0xbf, 0xf9, 0x75, 0xea, 0x53, 0xa6, 0xcb, 0x11, 0x22, 0x44,
|
||||
0x88, 0x97, 0xa9, 0xd5, 0x2d, 0x5a, 0xb4, 0xef, 0x59, 0xb2, 0xe3, 0x41, 0x82, 0x83, 0x81, 0x85,
|
||||
0x8d, 0x9d, 0xbd, 0xfd, 0x7d, 0xfa, 0x73, 0xe6, 0x4b, 0x96, 0xab, 0xd1, 0x25, 0x4a, 0x94, 0xaf,
|
||||
0xd9, 0x35, 0x6a, 0xd4, 0x2f, 0x5e, 0xbc, 0xff, 0x79, 0xf2, 0x63, 0xc6, 0x0b, 0x16, 0x2c, 0x58,
|
||||
0xb0, 0xe7, 0x49, 0x92, 0xa3, 0xc1, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0xc7, 0x09, 0x12, 0x24,
|
||||
0x48, 0x90, 0xa7, 0xc9, 0x15, 0x2a, 0x54, 0xa8, 0xd7, 0x29, 0x52, 0xa4, 0xcf, 0x19, 0x32, 0x64,
|
||||
0xc8, 0x17, 0x2e, 0x5c, 0xb8, 0xf7, 0x69, 0xd2, 0x23, 0x46, 0x8c, 0x9f, 0xb9, 0xf5, 0x6d, 0xda,
|
||||
0x33, 0x66, 0xcc, 0x1f, 0x3e, 0x7c, 0xf8, 0x77, 0xee, 0x5b, 0xb6, 0xeb, 0x51, 0xa2, 0xc3, 0x00,
|
||||
};
|
||||
|
||||
const unsigned char INDEX_OF[]=
|
||||
{
|
||||
0xff, 0x00, 0x01, 0x63, 0x02, 0xc6, 0x64, 0x6a, 0x03, 0xcd, 0xc7, 0xbc, 0x65, 0x7e, 0x6b, 0x2a,
|
||||
0x04, 0x8d, 0xce, 0x4e, 0xc8, 0xd4, 0xbd, 0xe1, 0x66, 0xdd, 0x7f, 0x31, 0x6c, 0x20, 0x2b, 0xf3,
|
||||
0x05, 0x57, 0x8e, 0xe8, 0xcf, 0xac, 0x4f, 0x83, 0xc9, 0xd9, 0xd5, 0x41, 0xbe, 0x94, 0xe2, 0xb4,
|
||||
0x67, 0x27, 0xde, 0xf0, 0x80, 0xb1, 0x32, 0x35, 0x6d, 0x45, 0x21, 0x12, 0x2c, 0x0d, 0xf4, 0x38,
|
||||
0x06, 0x9b, 0x58, 0x1a, 0x8f, 0x79, 0xe9, 0x70, 0xd0, 0xc2, 0xad, 0xa8, 0x50, 0x75, 0x84, 0x48,
|
||||
0xca, 0xfc, 0xda, 0x8a, 0xd6, 0x54, 0x42, 0x24, 0xbf, 0x98, 0x95, 0xf9, 0xe3, 0x5e, 0xb5, 0x15,
|
||||
0x68, 0x61, 0x28, 0xba, 0xdf, 0x4c, 0xf1, 0x2f, 0x81, 0xe6, 0xb2, 0x3f, 0x33, 0xee, 0x36, 0x10,
|
||||
0x6e, 0x18, 0x46, 0xa6, 0x22, 0x88, 0x13, 0xf7, 0x2d, 0xb8, 0x0e, 0x3d, 0xf5, 0xa4, 0x39, 0x3b,
|
||||
0x07, 0x9e, 0x9c, 0x9d, 0x59, 0x9f, 0x1b, 0x08, 0x90, 0x09, 0x7a, 0x1c, 0xea, 0xa0, 0x71, 0x5a,
|
||||
0xd1, 0x1d, 0xc3, 0x7b, 0xae, 0x0a, 0xa9, 0x91, 0x51, 0x5b, 0x76, 0x72, 0x85, 0xa1, 0x49, 0xeb,
|
||||
0xcb, 0x7c, 0xfd, 0xc4, 0xdb, 0x1e, 0x8b, 0xd2, 0xd7, 0x92, 0x55, 0xaa, 0x43, 0x0b, 0x25, 0xaf,
|
||||
0xc0, 0x73, 0x99, 0x77, 0x96, 0x5c, 0xfa, 0x52, 0xe4, 0xec, 0x5f, 0x4a, 0xb6, 0xa2, 0x16, 0x86,
|
||||
0x69, 0xc5, 0x62, 0xfe, 0x29, 0x7d, 0xbb, 0xcc, 0xe0, 0xd3, 0x4d, 0x8c, 0xf2, 0x1f, 0x30, 0xdc,
|
||||
0x82, 0xab, 0xe7, 0x56, 0xb3, 0x93, 0x40, 0xd8, 0x34, 0xb0, 0xef, 0x26, 0x37, 0x0c, 0x11, 0x44,
|
||||
0x6f, 0x78, 0x19, 0x9a, 0x47, 0x74, 0xa7, 0xc1, 0x23, 0x53, 0x89, 0xfb, 0x14, 0x5d, 0xf8, 0x97,
|
||||
0x2e, 0x4b, 0xb9, 0x60, 0x0f, 0xed, 0x3e, 0xe5, 0xf6, 0x87, 0xa5, 0x17, 0x3a, 0xa3, 0x3c, 0xb7,
|
||||
};
|
||||
|
||||
/* 8-bit parity table */
|
||||
const unsigned char Partab[] = {
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
||||
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
};
|
||||
|
||||
/* Scramble byte table */
|
||||
const unsigned char Scrambler[]=
|
||||
{
|
||||
0xff, 0x48, 0x0e, 0xc0, 0x9a, 0x0d, 0x70, 0xbc, 0x8e, 0x2c, 0x93, 0xad, 0xa7, 0xb7, 0x46, 0xce,
|
||||
0x5a, 0x97, 0x7d, 0xcc, 0x32, 0xa2, 0xbf, 0x3e, 0x0a, 0x10, 0xf1, 0x88, 0x94, 0xcd, 0xea, 0xb1,
|
||||
0xfe, 0x90, 0x1d, 0x81, 0x34, 0x1a, 0xe1, 0x79, 0x1c, 0x59, 0x27, 0x5b, 0x4f, 0x6e, 0x8d, 0x9c,
|
||||
0xb5, 0x2e, 0xfb, 0x98, 0x65, 0x45, 0x7e, 0x7c, 0x14, 0x21, 0xe3, 0x11, 0x29, 0x9b, 0xd5, 0x63,
|
||||
0xfd, 0x20, 0x3b, 0x02, 0x68, 0x35, 0xc2, 0xf2, 0x38, 0xb2, 0x4e, 0xb6, 0x9e, 0xdd, 0x1b, 0x39,
|
||||
0x6a, 0x5d, 0xf7, 0x30, 0xca, 0x8a, 0xfc, 0xf8, 0x28, 0x43, 0xc6, 0x22, 0x53, 0x37, 0xaa, 0xc7,
|
||||
0xfa, 0x40, 0x76, 0x04, 0xd0, 0x6b, 0x85, 0xe4, 0x71, 0x64, 0x9d, 0x6d, 0x3d, 0xba, 0x36, 0x72,
|
||||
0xd4, 0xbb, 0xee, 0x61, 0x95, 0x15, 0xf9, 0xf0, 0x50, 0x87, 0x8c, 0x44, 0xa6, 0x6f, 0x55, 0x8f,
|
||||
0xf4, 0x80, 0xec, 0x09, 0xa0, 0xd7, 0x0b, 0xc8, 0xe2, 0xc9, 0x3a, 0xda, 0x7b, 0x74, 0x6c, 0xe5,
|
||||
0xa9, 0x77, 0xdc, 0xc3, 0x2a, 0x2b, 0xf3, 0xe0, 0xa1, 0x0f, 0x18, 0x89, 0x4c, 0xde, 0xab, 0x1f,
|
||||
0xe9, 0x01, 0xd8, 0x13, 0x41, 0xae, 0x17, 0x91, 0xc5, 0x92, 0x75, 0xb4, 0xf6, 0xe8, 0xd9, 0xcb,
|
||||
0x52, 0xef, 0xb9, 0x86, 0x54, 0x57, 0xe7, 0xc1, 0x42, 0x1e, 0x31, 0x12, 0x99, 0xbd, 0x56, 0x3f,
|
||||
0xd2, 0x03, 0xb0, 0x26, 0x83, 0x5c, 0x2f, 0x23, 0x8b, 0x24, 0xeb, 0x69, 0xed, 0xd1, 0xb3, 0x96,
|
||||
0xa5, 0xdf, 0x73, 0x0c, 0xa8, 0xaf, 0xcf, 0x82, 0x84, 0x3c, 0x62, 0x25, 0x33, 0x7a, 0xac, 0x7f,
|
||||
0xa4, 0x07, 0x60, 0x4d, 0x06, 0xb8, 0x5e, 0x47, 0x16, 0x49, 0xd6, 0xd3, 0xdb, 0xa3, 0x67, 0x2d,
|
||||
0x4b, 0xbe, 0xe6, 0x19, 0x51, 0x5f, 0x9f, 0x05, 0x08, 0x78, 0xc4, 0x4a, 0x66, 0xf5, 0x58, 0xff,
|
||||
0x48, 0x0e, 0xc0, 0x9a, 0x0d, 0x70, 0xbc, 0x8e, 0x2c, 0x93, 0xad, 0xa7, 0xb7, 0x46, 0xce, 0x5a,
|
||||
0x97, 0x7d, 0xcc, 0x32, 0xa2, 0xbf, 0x3e, 0x0a, 0x10, 0xf1, 0x88, 0x94, 0xcd, 0xea, 0xb1, 0xfe,
|
||||
0x90, 0x1d, 0x81, 0x34, 0x1a, 0xe1, 0x79, 0x1c, 0x59, 0x27, 0x5b, 0x4f, 0x6e, 0x8d, 0x9c, 0xb5,
|
||||
0x2e, 0xfb, 0x98, 0x65, 0x45, 0x7e, 0x7c, 0x14, 0x21, 0xe3, 0x11, 0x29, 0x9b, 0xd5, 0x63, 0xfd,
|
||||
};
|
||||
@ -1 +1 @@
|
||||
ADEVICE plughw:CARD=Loopback,DEV=1 plughw:CARD=b1,DEV=0
|
||||
ADEVICE plughw:CARD=Loopback,DEV=1
|
||||
|
||||
@ -0,0 +1,211 @@
|
||||
import sys
|
||||
from os import system
|
||||
from time import sleep
|
||||
import logging
|
||||
import random
|
||||
from PIL import Image, ImageDraw, ImageFont, ImageColor
|
||||
import subprocess
|
||||
import io
|
||||
import datetime
|
||||
|
||||
logging.basicConfig(format='%(message)s')
|
||||
# logging.warning('CC-Warning!')
|
||||
|
||||
|
||||
def fstr(template):
|
||||
return eval(f"f'{template}'")
|
||||
|
||||
def system_and_print(string):
|
||||
print(string)
|
||||
system(string)
|
||||
|
||||
FC_EPS = 1
|
||||
FC_BOB = 25
|
||||
FC_SW = 50
|
||||
FC_PAYLOAD = 55
|
||||
extended = 1
|
||||
|
||||
sequence, image_id, image_count = 0, 0, 0
|
||||
Vx, Vy, Vz, Vb = 0, 0, 0, 0
|
||||
Ix, Iy, Iz, Ic, Ib = 0, 0, 0, 0, 0
|
||||
frame_count, frame_type = 0, " "
|
||||
frequency_string, frequency, errors, first_byte = " ", 0, 0, 0
|
||||
|
||||
#html_dir = "/home/pi/CubeSatSim/groundstation/public_html/"
|
||||
html_dir = "/home/pi/fctelem/public_html/"
|
||||
image_dir = "/home/pi/fctelem/"
|
||||
image = "image_file"
|
||||
ssdv = "/home/pi/ssdv/ssdv -d -J "
|
||||
|
||||
date_time_string = str(datetime.datetime.now())
|
||||
date_time = date_time_string[:21]
|
||||
|
||||
system_and_print("sudo rm " + image_dir + image)
|
||||
#system_and_print("sudo rm " + html_dir + "*")
|
||||
system_and_print("sudo rm " + html_dir + "images/*")
|
||||
|
||||
try:
|
||||
with open('/home/pi/fctelem/fctelem.cfg', 'r') as config:
|
||||
config_string = config.read()
|
||||
print(config_string)
|
||||
except:
|
||||
print("Error loading fctelem.cfg")
|
||||
|
||||
#system_and_print("cp /home/pi/CubeSatSim/sstv/sstv_image_1_320_x_256.jpg " + html_dir + "image_file.jpeg")
|
||||
|
||||
head_string = '<HEAD><meta http-equiv="refresh" content="5"><title>FunCube CubeSatSim Telemetry</title></HEAD>\n<HTML>\n<H2>FunCube CubeSatSim Telemetry</H2>' + \
|
||||
'fcdctl ' + config_string + '<p><pre> <img height="256" width="320" src="' + image + \
|
||||
'.jpeg"><br> <A HREF="images" target="_blank">All images</a><br>'
|
||||
foot_string = '</HTML>'
|
||||
telem_string_format = " Image: {image_id:3d} count: {image_count:2d}<p>" + \
|
||||
" Vx(mV): {Vx:5d} Vy(mV): {Vy:5d} Vz(mV): {Vz:5d}<p>" + \
|
||||
" Ix(mA): {Ix:5d} Iy(mA): {Iy:5d} Iz(mA): {Iz:5d}<p>" + \
|
||||
" Vbat(mV): {Vb:5d} Ibat(mA): {Ib:5d}<br><br></pre>" + \
|
||||
" Freq: {frequency:10.1f} errors: {errors} Seq: {sequence:d} {frame_type} frames: {frame_count:d}"
|
||||
label_string = "date time , frm, freq off, err, h, seq, frame, img, c, Vx, Vy, Vz, Ix, Iy, Iz, Vb, Ib "
|
||||
label_string_html = label_string.replace(" "," ")
|
||||
csv_format = "{date_time:21s}, {frame_count:4d}, {frequency:10.1f}, {errors:3d}, {first_byte: 2x}, {sequence:5d}, {frame_type:9s}, {image_id:3d}, {image_count:2d}, " + \
|
||||
"{Vx:5d}, {Vy:5d}, {Vz:5d}, {Ix:5d}, {Iy:5d}, {Iz:5d}, {Vb:5d}, {Ib:5d}"
|
||||
|
||||
|
||||
telem_string = fstr(telem_string_format)
|
||||
with open(html_dir + "index.html", "w+") as html_file:
|
||||
html_file.write(head_string)
|
||||
html_file.write(telem_string)
|
||||
html_file.write(foot_string)
|
||||
|
||||
with open(html_dir + "images/telem.csv.txt", "w+") as csv_file:
|
||||
# csv_file.write(csv_format)
|
||||
csv_file.write(label_string)
|
||||
csv_file.write("\n")
|
||||
|
||||
image_id = 256 # set illegal image ID for null # random.randint(0, 255)
|
||||
image_count = 1;
|
||||
|
||||
# sys.exit()
|
||||
|
||||
if __name__ == "__main__":
|
||||
debug_mode = False
|
||||
counter = 1
|
||||
if (len(sys.argv)) > 1:
|
||||
# print("There are arguments!")
|
||||
if ('d' == sys.argv[1]):
|
||||
debug_mode = True
|
||||
print(debug_mode)
|
||||
for line in sys.stdin:
|
||||
if (debug_mode):
|
||||
print(line, end =" ")
|
||||
logging.warning(line)
|
||||
|
||||
if ((line.find("data: ")) > 0):
|
||||
print("\ndata block found!\n")
|
||||
frame_count += 1
|
||||
data_block_string = line.split()
|
||||
# print(data_block_string)
|
||||
frequency_string = data_block_string[2]
|
||||
print(frequency_string)
|
||||
frequency = float(frequency_string[:len(frequency_string) - 2])
|
||||
print(frequency)
|
||||
errors = int(data_block_string[5])
|
||||
data_block = [int(number_string,16) for number_string in data_block_string[7:]]
|
||||
first_byte = data_block[0]
|
||||
if (first_byte == 0xE0) or (first_byte == 0xE1):
|
||||
if (data_block[0] == 0xE0):
|
||||
frame_type = "RT1+IMG1"
|
||||
if (data_block[0] == 0xE1):
|
||||
frame_type = "RT2+IMG2"
|
||||
print(frame_type)
|
||||
print(data_block[extended + 51], data_block[extended + 50], data_block[extended + 49])
|
||||
sequence = data_block[extended + 51] + data_block[extended + 50] * 2**8 + data_block[extended + 49] * 2**16
|
||||
print("Sequence number: {:d}".format(sequence))
|
||||
Vx = (data_block[extended + FC_EPS + 0] * 2**6) + (data_block[extended + FC_EPS + 1] >> 2)
|
||||
Vy = (0x03 & data_block[extended + FC_EPS + 1]) * 2**12 + data_block[extended + FC_EPS + 2] * 2**4 + (data_block[extended + FC_EPS + 3] >> 4)
|
||||
Vz = (0x0f & data_block[extended + FC_EPS + 3]) * 2**10 + data_block[extended + FC_EPS + 4] * 2**2 + (data_block[extended + FC_EPS + 5] >> 6)
|
||||
Vb = (0x3f & data_block[extended + FC_EPS + 5]) * 2**8 + data_block[extended + FC_EPS + 6]
|
||||
Ix = data_block[extended + FC_EPS + 7] * 2**2 + (data_block[extended + FC_EPS + 8] >> 6)
|
||||
Iy = (0x3f & data_block[extended + FC_EPS + 8]) * 2**4 + (data_block[extended + FC_EPS + 9] >> 4)
|
||||
Iz = (0x0f & data_block[extended + FC_EPS + 9]) * 2**6 + (data_block[extended + FC_EPS + 10] >> 2)
|
||||
Ic = (0x03 & data_block[extended + FC_EPS + 10]) * 2**8 + data_block[extended + FC_EPS + 11]
|
||||
Ib = data_block[extended + FC_EPS + 12] * 2**2 + ((0xc0 & data_block[extended + FC_EPS + 13]) >> 6)
|
||||
if (Ib == 0):
|
||||
Ib = 0 - Ic
|
||||
print("Vx: {:d} mV Vy: {:d} mV Vz: {:d} mV".format(Vx, Vy, Vz))
|
||||
print('Payload {:x} {:x} \n'.format(data_block[FC_PAYLOAD + extended], data_block[FC_PAYLOAD + extended + 1]))
|
||||
if (data_block[FC_PAYLOAD + extended] == 0x55) and (data_block[FC_PAYLOAD + extended + 1] == 0x68):
|
||||
try:
|
||||
print("Writing this image payload block to file " + image + "_payload")
|
||||
immutable_payload = bytes(bytearray(data_block[(FC_PAYLOAD + extended):])) # payload)
|
||||
# print(immutable_payload)
|
||||
with open(image_dir + image + "_payload", "wb") as binary_file:
|
||||
binary_file.write(immutable_payload)
|
||||
except:
|
||||
print("File error")
|
||||
# try:
|
||||
print("Processing payload with ssdv, saving image to " + image + "_paylad.jpeg and log to ssdv_output")
|
||||
system_and_print(ssdv + image_dir + image + "_payload " +
|
||||
image_dir + image + "_payload.jpeg 2>&1 | sudo tee /home/pi/fctelem/ssdv_output")
|
||||
print("Parsing ssdv_output")
|
||||
with open("/home/pi/fctelem/ssdv_output", "r") as file:
|
||||
for line in file:
|
||||
# print("line:")
|
||||
# print(line)
|
||||
if ((line.find("mage ID:")) > 0):
|
||||
# print("\nImage ID found!\n")
|
||||
image_id_string = line.split()
|
||||
# print(image_id_string)
|
||||
new_image_id = int(image_id_string[2], 16)
|
||||
# print(new_image_id)
|
||||
if (new_image_id != image_id):
|
||||
print("End of image")
|
||||
if (image_id != 256):
|
||||
print("Saving complete image")
|
||||
system_and_print("cp " + html_dir + "image_file.jpeg " + html_dir + "images/" + image + str(image_id) + "." + str(image_count) + ".jpeg")
|
||||
system_and_print("sudo rm " + image_dir + image)
|
||||
else:
|
||||
system_and_print("sudo rm " + image_dir + image)
|
||||
print("New Image ID: ")
|
||||
print(new_image_id)
|
||||
image_id = new_image_id
|
||||
image_count = 1
|
||||
else:
|
||||
image_count += 1
|
||||
print("new image_count:")
|
||||
print(image_count)
|
||||
print("Appending block to file " + image)
|
||||
with open(image_dir + image, "ab") as binary_file:
|
||||
binary_file.write(immutable_payload)
|
||||
print("Running ssdv with all blocks in file " + image + " saving as " + html_dir + "image_file.jpeg")
|
||||
system_and_print(ssdv + image_dir + image + " " + html_dir + "image_file.jpeg")
|
||||
telem_string = fstr(telem_string_format)
|
||||
print("Writing index.html file")
|
||||
with open(html_dir + "index.html", "w") as html_file:
|
||||
html_file.write(head_string)
|
||||
html_file.write(telem_string)
|
||||
html_file.write("<br><pre>")
|
||||
with open(html_dir + "/images/telem.csv.txt", "r") as csv_file:
|
||||
for line in csv_file:
|
||||
html_file.write(line)
|
||||
html_file.write("<br>")
|
||||
date_time_string = str(datetime.datetime.now())
|
||||
date_time = date_time_string[:21]
|
||||
tlm_string = fstr(csv_format)
|
||||
html_file.write(tlm_string)
|
||||
html_file.write("</pre><br>")
|
||||
html_file.write(foot_string)
|
||||
else:
|
||||
print("Payload not an image!")
|
||||
# image_id = 256 # set illegal image_id to force new image
|
||||
else:
|
||||
print("Unknown Sat Id or Frame")
|
||||
sequence, image_id, image_count = 0, 0, 0
|
||||
Vx, Vy, Vz, Vb = 0, 0, 0, 0
|
||||
Ix, Iy, Iz, Ic, Ib = 0, 0, 0, 0, 0
|
||||
frame_count, frame_type = 0, " "
|
||||
frequency_string, errors = " ", 0
|
||||
|
||||
tlm_string = fstr(csv_format)
|
||||
with open(html_dir + "/images/telem.csv.txt", "a") as csv_file:
|
||||
csv_file.write(tlm_string)
|
||||
csv_file.write("\n")
|
||||
|
||||
|
||||
@ -0,0 +1,10 @@
|
||||
[Desktop Entry]
|
||||
Type=Application
|
||||
Exec=/home/pi/CubeSatSim/groundstation/fctelem.sh
|
||||
Name=FunCube Telem
|
||||
Comment=FunCube Telemetry Web App
|
||||
Icon=/home/pi/Icons/fc-icon.png
|
||||
Path=/home/pi
|
||||
Terminal=true
|
||||
Categories=HamRadio
|
||||
Keywords=Ham Radio;SDR
|
||||
@ -0,0 +1,153 @@
|
||||
#!/bin/bash
|
||||
# script to run FunCube Pi Telemetry App
|
||||
|
||||
echo "Script to run FunCube CubeSatSim Telemetry"
|
||||
|
||||
echo
|
||||
|
||||
echo "The Chromium browser will load in a few seconds with fctelem."
|
||||
|
||||
echo "You can also use another web browser if you are on the same network as your Pi."
|
||||
|
||||
|
||||
echo
|
||||
|
||||
ip=$(hostname -I|cut -f1 -d ' ')
|
||||
|
||||
echo "IP Address to use in web browser is: $ip:8000"
|
||||
|
||||
echo
|
||||
|
||||
ssid=$(iwgetid -r)
|
||||
|
||||
echo "Note: you need to be on the Wifi network: $ssid"
|
||||
|
||||
echo
|
||||
|
||||
sudo killall -9 fctelem &>/dev/null
|
||||
|
||||
sudo killall -9 python3 &>/dev/null
|
||||
|
||||
#sudo killall -9 java &>/dev/null
|
||||
|
||||
#sudo killall -9 rtl_fm &>/dev/null
|
||||
|
||||
#pkill -o chromium &>/dev/null
|
||||
|
||||
#sudo killall -9 rtl_tcp &>/dev/null
|
||||
|
||||
#sudo killall -9 CubicSDR &>/dev/null
|
||||
|
||||
#sudo killall -9 qsstv &>/dev/null
|
||||
|
||||
#sudo killall -9 aplay &>/dev/null
|
||||
|
||||
#sudo killall -9 direwolf &>/dev/null
|
||||
|
||||
#sudo killall -9 zenity &>/dev/null
|
||||
|
||||
#sudo systemctl stop rtl_tcp
|
||||
|
||||
#sudo systemctl stop openwebrx
|
||||
|
||||
|
||||
if [[ $(/home/pi/fcdctl/fcdctl -l | grep "No FCD found") ]]; then
|
||||
echo "No FunCube Dongle Found!"
|
||||
echo "Plug in FCD and try running again"
|
||||
sleep 30
|
||||
exit
|
||||
else
|
||||
echo "FCD Found! Setting Gain"
|
||||
|
||||
FILE=/home/pi/fctelem/fctelem.cfg
|
||||
if [ -f "$FILE" ]; then
|
||||
|
||||
# config_string=$(</home/pi/fctelem/fctelem.cfg)
|
||||
config_string=$(<$FILE)
|
||||
|
||||
else
|
||||
echo "No fctelem.cfg file"
|
||||
echo "Creating it"
|
||||
config_string="-g 1 -m 1 -i 0"
|
||||
echo $config_string >> FILE
|
||||
fi
|
||||
|
||||
/home/pi/fcdctl/fcdctl $config_string
|
||||
|
||||
# /home/pi/fcdctl/fcdctl -g 1 -m 1 -i 0
|
||||
echo
|
||||
fi
|
||||
|
||||
|
||||
frequency=$(zenity --list 2>/dev/null --width=410 --height=180 --title="FunCube Telem Decoding" --text="Choose the frequency for FunCube decoding:" --column="kHz" --column="Use" 434900 "CubeSatSim" Other "Choose another frequency")
|
||||
|
||||
echo $frequency
|
||||
|
||||
if [ -z "$frequency" ]; then
|
||||
|
||||
echo "No choice made. Exiting."
|
||||
sleep 3
|
||||
exit
|
||||
|
||||
fi
|
||||
|
||||
if [ "$frequency" = "434900" ]; then
|
||||
|
||||
frequency=434900000
|
||||
|
||||
elif [ "$frequency" = "Other" ]; then
|
||||
|
||||
echo
|
||||
|
||||
echo "Enter the frequency in kiloHertz"
|
||||
|
||||
echo
|
||||
|
||||
read -r frequency
|
||||
|
||||
frequency=$frequency"000"
|
||||
|
||||
fi
|
||||
|
||||
echo "Frequency is" $frequency
|
||||
echo
|
||||
echo "If your CubeSatSim is transmitting in FunCube mode (mode 7) you should get some frames after 30 seconds"
|
||||
echo
|
||||
|
||||
sleep 3
|
||||
|
||||
echo "connectport=64516 connectaddress='localhost' autotuneoffset=100000 outdir='/home/pi/go/app/fctelem/data' frequency=$frequency" > /home/pi/fctelem/fcdecode.conf
|
||||
|
||||
# FILE=/home/pi/CubeSatSim/groundstation/public_html
|
||||
FILE=/home/pi/CubeSatSim/fctelem/public_html
|
||||
if [ ! -d "$FILE" ]; then
|
||||
echo "Making public_html directory"
|
||||
mkdir /home/pi/fctelem/public_html
|
||||
mkdir /home/pi/fctelem/public_html/images
|
||||
fi
|
||||
|
||||
cd /home/pi/fctelem/public_html
|
||||
|
||||
cp /home/pi/CubeSatSim/groundstation/index.html .
|
||||
|
||||
cp /home/pi/CubeSatSim/sstv/sstv_image_1_320_x_256.jpg ./image_file.jpeg
|
||||
|
||||
python3 -m http.server &
|
||||
|
||||
setsid chromium-browser --check-for-update-interval=1 --simulate-critical-update --noerrdialogs --disable-infobars http://127.0.0.1:8000 &>/dev/null &
|
||||
|
||||
cd /home/pi/fctelem
|
||||
|
||||
sudo ./fctelem | python3 /home/pi/CubeSatSim/groundstation/fc_block_decode.py
|
||||
|
||||
# sleep 10
|
||||
|
||||
#read val
|
||||
|
||||
#sudo killall -9 fctelem &>/dev/null
|
||||
|
||||
#sudo killall -9 python3 &>/dev/null
|
||||
|
||||
sleep 10
|
||||
|
||||
#$SHELL
|
||||
@ -0,0 +1,9 @@
|
||||
<HEAD><meta http-equiv="refresh" content="5"></HEAD>
|
||||
<HTML>
|
||||
FunCube CubeSatSim Telemetry
|
||||
<p>
|
||||
<img src="image_file.jpeg">
|
||||
<!--
|
||||
<img src="image_file.jpeg" id="reloader" onLoad="setTimeout( () => { document.getElementById('reloader').src='image_file.jpeg' + '?' + new Date().getMilliseconds() } ,5000)" />
|
||||
-->
|
||||
</p>
|
||||
|
After Width: | Height: | Size: 23 KiB |
Loading…
Reference in new issue