NASA Ocean Color

ocssw V2022

 /*
  * Program to decode Channel Access Data Units following
  * CCSDS TM Sync and Channel Coding as proposed for use on Outernet.
  *
  * Mark McCrum 
  */
  
 //    Modification history:
 //  Programmer     Organization   Date     Ver   Description of change
 //  ----------     ------------   ----     ---   ---------------------
 //  Joel Gales     FutureTech     10/18/18 0.90  Continue processing after
 //                                               decode error.
 //  Liang Hong     SAIC           05/05/23 1.00  moved excess warning to verbose
  
 #include "fec.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
  
 #define I           4       /* Interleave depth */
 #define L_SYMBOL        223     /* RS Symbol size (bytes) */
 #define L_CODEWORD              255     /* RS Codeword size (bytes) */
 #define L_PARITY                32      /* Codeword parity bytes */
 #define L_CODEBLOCK     (I * L_CODEWORD)
 #define FRAME_SIZE      (I * L_SYMBOL)  /* User data in a frame */
 #define SYMBOLS_NO_CONV         (L_ASM + L_CODEBLOCK)
 #define MAX_SYMBOLS     ( 2 * (L_ASM + L_CODEBLOCK + 1))
                         /* Max symbols in a CADU */
 #define L_ASM           4       /* Length of sync vector */
  
 /* Viterbi decoded config */
 #define V_FRAMEBITS     (8 * SYMBOLS_NO_CONV) /* Bits in frame */
  
 #define VERSION "1.00"
  
 void formatHex(unsigned char* data, int length) {
   int col = 0;
   while(length) {
     printf("0x%02hhx", *(data++));
     length--;
     if (length) {
       printf(", ");
     }
     col += 4;
     if (col > 80) {
       col = 0;
       putchar('\n');
     }
   }
   putchar('\n');
 }
  
 void outputHex(unsigned char* data, int length) {
   while(length) {
     printf("%02hhx", *(data++));
     length--;
   }
 }
  
 /*
  * LFSR for CCSDS Pseudo-random number generator
  *
  * lfsr Pointer to state of linear feedback shift register. Should initially
  *      be 0xFF
  *
  * o    Pointer to output byte, existing value will be xor'd with the next
  *      random number output by the generator.
  */
 void prng(unsigned char* lfsr, unsigned char* o) {
   unsigned char rnd = 0U;
   unsigned char bit = 0U;
   unsigned int i;
   for (i = 0; i < 8; i++) {
     rnd = (rnd << 1) | (*lfsr & 0x1U);
     bit = (((*lfsr >> 3) ^ *lfsr) ^ (*lfsr >> 5)) ^ (*lfsr >>7);
     *lfsr = (*lfsr >> 1) | (bit << 7);
   } 
   *o = *o ^ rnd;
 } 
  
 void convDecode(unsigned char* data, unsigned char* coded) {
   void *vp = create_viterbi27(V_FRAMEBITS);
   int polys[] = {V27POLYB, -V27POLYA};  /* CCSDS Polynomial config */
   unsigned char symbols[2 * (V_FRAMEBITS + 6)]; /* Channel symbols inc.
                                                         tail bits */
   int i;
  
   /* build array of symbols (one element per bit) includes 6 tail bits*/
   for (i = 0; i < 2 * (V_FRAMEBITS + 6); i++) {
     symbols[i ] = ((coded[i/8] << (i % 8)) & 0x80) > 0 ? 255 : 0;
   }
  
   set_viterbi27_polynomial(polys);
   init_viterbi27(vp, 0);
  
   /* Decode block */
   update_viterbi27_blk(vp, symbols, V_FRAMEBITS + 6);
       
   /* Do Viterbi chainback */
   chainback_viterbi27(vp, data, V_FRAMEBITS,0);
  
   delete_viterbi27(vp);
 }
  
 void showHelp(char *progname) {
   printf("\nTest decoded for Outernet\n");
   printf("\nDecode Channel Access Data Units encoded via propsed use of");
   printf("\nCCSDS TM Sync and Channel Coding standard\n\n");
   printf("Use: %s [options]\n", progname);
   printf(" c Indicates that CADU has been convolutionally coded\n"); 
   printf("   A Viterbi decoder will be used\n");
   printf("Output:\n");
   printf(" Decoded frame\n");
   printf("Notes:\n");
   printf(" Errors from the Reed-Solomon decode are detected but not\n");
   printf(" corrected.\n"); 
   exit(0);
 }
  
  
 int main(int argc, char** argv) {
   unsigned char sync[] = {0x1A, 0xCF, 0xFC, 0x1D};  /* Attached sync marker */
   unsigned char symbols[MAX_SYMBOLS];           /* CADU symbols         */
   unsigned char convdecoded[SYMBOLS_NO_CONV + 1];
                             /* frame after conv decoding */
   //unsigned char frame[ FRAME_SIZE ];          /* Transfer frame       */
   unsigned char codeword[L_CODEWORD];               /* Single RS code word*/
   unsigned char lfsr = 0xFFU;       /* Shift register for randomiser  */    
   //unsigned char csr = 0x00;         /* Shift register for convolutional coder */
   //unsigned char flush = 0x00;       /* Flush byte for convolutional coder */
   int rsErrCnt;             /* RS error count */
   //int pad = 0;                      /* RS coding padding */
   int i, j;                         /* Loop counters */
   int d;                            /* Getopt option */
   int convolution = 0;              /* Do convolutional coding? */
   int verbose = 0;
  
   FILE* in;// = stdin;          /* Input file */
   FILE* out;                    /* Output file */
   int caduSymbols;
   int errPos[L_PARITY];             /* Error positions */
  
   printf("outernetDecode %s (%s %s)\n", VERSION, __DATE__, __TIME__);
  
   if ( argc == 1) {
     printf("\nouternetDecode input_downlink_filename output_telemetry_filename\n");
     return 0;
   }
  
   /* Process command line options */
   while ((d = getopt(argc, argv, "cv")) != EOF) {
     switch(d) {
     case 'c':
       convolution = 1;
       break;
     case 'v':
       verbose = 1;
       break;
     case '?':
       showHelp(argv[0]);
     }
   }
  
   printf("MAX_SYMBOLS: %d\n", MAX_SYMBOLS);
   printf("FRAME_SIZE: %d\n", FRAME_SIZE);
   
   /* Number of bytes to read per frame depends on convolutional coding */
   caduSymbols = convolution ? MAX_SYMBOLS : SYMBOLS_NO_CONV;
  
   in = fopen(argv[optind], "r");
   out = fopen(argv[optind+1], "w");
  
   int ierr=0;
   while (fread(symbols, sizeof(char), caduSymbols, in) == caduSymbols) {
  
     lfsr = 0xFFU;   /* reset the randomiser shift register */
     memset(convdecoded, 0, SYMBOLS_NO_CONV);
     if (convolution) {
       /* Run a viterbi decoder on the data */
       convDecode(convdecoded, symbols);
     } else {
       memcpy(convdecoded, symbols, SYMBOLS_NO_CONV);
     }
     /* Check the attached sync marker */
     if(memcmp(sync, convdecoded, L_ASM) != 0) {
       fprintf(stderr, "ASM not found\n");
       //      break;
     }
  
     /* De-randomise the data */
     for (i = 0; i < ( L_CODEBLOCK); i++) {
       prng(&lfsr, &convdecoded[L_ASM + i]);
     }
  
     /* Check parity */
     for (i = 0; i < I; i++) {
       /* codeword interleaving */
       for (j = 0; j < L_SYMBOL; j++) {
         codeword[j] = convdecoded[L_ASM + i + j * I];
       }
         
       /* parity interleaving */
       for(j = 0; j < L_PARITY; j++) {
         codeword[j + L_SYMBOL] = 
           convdecoded[L_ASM + FRAME_SIZE + i + j * I];
       }
         
       /* run the RS decoder */
       rsErrCnt = decode_rs_ccsds(codeword, errPos, 0, 0);
       if (rsErrCnt == -1) {
         if (verbose > 0) fprintf(stderr, "Uncorrectable errors in frame\n");
         ierr = 1;
         //        break;
       } else if (rsErrCnt > 0 & verbose > 0) {
         /* TODO: Copy the corrections back into the frame */
         fprintf(stderr, "%d errors in block\n", rsErrCnt);
         while(rsErrCnt) {
           fprintf(stderr, "symbol: %i\n", 
                   errPos[--rsErrCnt]);          
         }
       }
     }
     if (ierr == 0) {
       /* Output the frame */
       //      outputHex(&convdecoded[L_ASM], FRAME_SIZE);
       //putchar('\n');
       fwrite(&convdecoded[L_ASM], sizeof(char), FRAME_SIZE, out);
     } else {
       ierr = 0;
     }
   }
  
   fclose(in);
   fclose(out);
   
   return 0;
 }
  

main

int main(int argc, char **argv)

Definition: outernetDecode.c:128

L_CODEBLOCK

#define L_CODEBLOCK

Definition: outernetDecode.c:25

l1mapgen.stderr

stderr

Definition: l1mapgen.py:204

init_viterbi27

int init_viterbi27(void *vp, int starting_state)

Definition: fec_seahawk.c:221

int j

Definition: decode_rs.h:73

chainback_viterbi27

int chainback_viterbi27(void *vp, unsigned char *data, unsigned int nbits, unsigned int endstate)

Definition: fec_seahawk.c:242

outputHex

void outputHex(unsigned char *data, int length)

Definition: outernetDecode.c:60

L_ASM

#define L_ASM

Definition: outernetDecode.c:30

out

no change in intended resolving MODur00064 Corrected handling of bad ephemeris attitude resolving resolving GSFcd00179 Corrected handling of fill values for[Sensor|Solar][Zenith|Azimuth] resolving MODxl01751 Changed to validate LUT version against a value retrieved from the resolving MODxl02056 Changed to calculate Solar Diffuser angles without adjustment for estimated post launch changes in the MODIS orientation relative to incidentally resolving defects MODxl01766 Also resolves MODxl01947 Changed to ignore fill values in SCI_ABNORM and SCI_STATE rather than treating them as resolving MODxl01780 Changed to use spacecraft ancillary data to recognise when the mirror encoder data is being set by side A or side B and to change calculations accordingly This removes the need for seperate LUTs for Side A and Side B data it makes the new LUTs incompatible with older versions of the and vice versa Also resolves MODxl01685 A more robust GRing algorithm is being which will create a non default GRing anytime there s even a single geolocated pixel in a granule Removed obsolete messages from seed as required for compatibility with version of the SDP toolkit Corrected test output file names to end in out

Definition: HISTORY.txt:422

V_FRAMEBITS

#define V_FRAMEBITS

Definition: outernetDecode.c:33

update_viterbi27_blk

int update_viterbi27_blk(void *vp, unsigned char sym[], int npairs)

Definition: fec_seahawk.c:297

V27POLYA

#define V27POLYA

Definition: fec.h:13

MAX_SYMBOLS

#define MAX_SYMBOLS