More XPT Tweaks and Notes;

Line Space OCD;
Lite to Aero Rebrand;
2026-11-13 09:17:20 -05:00 · 2023-03-09 19:12:57 -05:00 · 2023-03-09 18:40:36 -05:00 · 2023-03-08 02:25:51 -05:00 · 2023-03-08 02:25:29 -05:00 · 2023-03-08 02:04:56 -05:00
24 changed files with 1714 additions and 680 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-project(dsd-fme-lite)
+project(dsd-fme-aero)
 cmake_minimum_required(VERSION 2.8.11)

 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/")
@@ -38,24 +38,24 @@ list(APPEND SRCS "${CMAKE_CURRENT_BINARY_DIR}/git_ver.c")

 include_directories("${PROJECT_SOURCE_DIR}/include")

-ADD_EXECUTABLE(dsd-fme-lite ${SRCS} ${HEADERS})
-TARGET_LINK_LIBRARIES(dsd-fme-lite ${LIBS})
+ADD_EXECUTABLE(dsd-fme-aero ${SRCS} ${HEADERS})
+TARGET_LINK_LIBRARIES(dsd-fme-aero ${LIBS})

 include(GNUInstallDirs)
-install(TARGETS dsd-fme-lite DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS dsd-fme-aero DESTINATION ${CMAKE_INSTALL_BINDIR})

 # man page
 find_program(HELP2MAN_FOUND help2man)
 if (HELP2MAN_FOUND)
-    add_custom_command(TARGET dsd-fme-lite POST_BUILD
+    add_custom_command(TARGET dsd-fme-aero POST_BUILD
        COMMAND help2man
        ARGS -n "Digital Speech Decoder"
            --version-string=${GIT_TAG}
-            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1
+            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-aero.1
            --no-info
-            $<TARGET_FILE:dsd-fme-lite>
+            $<TARGET_FILE:dsd-fme-aero>
    )
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-aero.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 endif()

 # uninstall target
--- a/include/dsd.h
+++ b/include/dsd.h
@@ -325,7 +325,9 @@ typedef struct

  int p25_trunk; //experimental P25 trunking with RIGCTL (or RTLFM)
  int p25_is_tuned; //set to 1 if currently on VC, set back to 0 if on CC
-  int trunk_hangtime; //hangtime in seconds before tuning back to CC
+  float trunk_hangtime; //hangtime in seconds before tuning back to CC
+
+  int scanner_mode; //experimental -- use the channel map as a conventional scanner, quicker tuning, but no CC

  //csv import filenames
  char group_in_file[1024];
@@ -595,6 +597,7 @@ typedef struct
  int p2_is_lcch; //flag to tell us when a frame is lcch and not sacch

  //iden freq storage for frequency calculations
+  int p25_chan_tdma[16]; //set from iden_up vs iden_up_tdma
  int p25_chan_iden;
  int p25_chan_type[16];
  int p25_trans_off[16];
@@ -811,6 +814,9 @@ int getSymbol (dsd_opts * opts, dsd_state * state, int have_sync);
 void upsample (dsd_state * state, float invalue);
 void processDSTAR (dsd_opts * opts, dsd_state * state);

+//new p25lcw
+void p25_lcw (dsd_opts * opts, dsd_state * state, uint8_t LCW_bits[], uint8_t irrecoverable_errors);
+
 void processP25lcw (dsd_opts * opts, dsd_state * state, char *lcformat, char *mfid, char *lcinfo);
 void processHDU (dsd_opts * opts, dsd_state * state);
 void processLDU1 (dsd_opts * opts, dsd_state * state);
@@ -823,7 +829,8 @@ void processX2TDMAvoice (dsd_opts * opts, dsd_state * state);
 void processDSTAR_HD (dsd_opts * opts, dsd_state * state);
 void processYSF(dsd_opts * opts, dsd_state * state); //YSF
 void processP2(dsd_opts * opts, dsd_state * state); //P2
-void processTSBK(dsd_opts * opts, dsd_state * state);
+void processTSBK(dsd_opts * opts, dsd_state * state); //P25 Trunking Single Block
+void processMPDU(dsd_opts * opts, dsd_state * state); //P25 Multi Block PDU (SAP 0x61 FMT 0x15 or 0x17 for Trunking Blocks)
 short dmr_filter(short sample);
 short nxdn_filter(short sample);
 short dpmr_filter(short sample);
--- a/src/dmr_block.c
+++ b/src/dmr_block.c
@@ -128,12 +128,12 @@ void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t
    if (dpf == 15)
    {
      if      (p_mfid == 0x10) sprintf (mfid_string, "%s", "Motorola");
-      else if (p_mfid == 0x58) sprintf (mfid_string, "%s", "Tait    ");
-      else if (p_mfid == 0x68) sprintf (mfid_string, "%s", "Hytera  ");
-      else if (p_mfid == 0x08) sprintf (mfid_string, "%s", "Hytera  ");
+      else if (p_mfid == 0x58) sprintf (mfid_string, "%s", "Tait");
+      else if (p_mfid == 0x68) sprintf (mfid_string, "%s", "Hytera");
+      else if (p_mfid == 0x08) sprintf (mfid_string, "%s", "Hytera");
      else if (p_mfid == 0x06) sprintf (mfid_string, "%s", "Trid/Mot"); 
      else if (p_mfid == 0x00) sprintf (mfid_string, "%s", "Standard"); 
-      else                     sprintf (mfid_string, "%s", "Other   ");
+      else                     sprintf (mfid_string, "%s", "Other");
    }

    //udt format string handling
@@ -324,6 +324,7 @@ void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t
    state->data_conf_data[slot] = 0;
    state->data_block_counter[slot] = 1; 
    state->data_header_blocks[slot] = 1; 
+    state->data_header_format[slot] = 7;

  }

@@ -384,7 +385,7 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
  uint32_t CRCExtracted = 0;
  uint32_t IrrecoverableErrors = 0; 

-  uint8_t dmr_pdu_sf_bits[8*8*50]; //give plenty of space so we don't go oob
+  uint8_t dmr_pdu_sf_bits[8*24*50]; //give plenty of space so we don't go oob

  //MBC Header and Block CRC
  uint8_t mbc_crc_good[2]; //header and blocks crc pass/fail local storage
--- a/src/dmr_csbk.c
+++ b/src/dmr_csbk.c
@@ -391,9 +391,12 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
        uint32_t target = (uint32_t)ConvertBitIntoBytes(&cs_pdu_bits[32], 24);
        uint32_t source = (uint32_t)ConvertBitIntoBytes(&cs_pdu_bits[56], 24);

+        if (gi)  fprintf (stderr, " Group");
+        if (!gi) fprintf (stderr, " Private");
+
        if (p_kind == 0) fprintf (stderr, " Disable Target PTT (DIS_PTT)");
        if (p_kind == 1) fprintf (stderr, " Enable Target PTT (EN_PTT)");
-        if (p_kind == 2) fprintf (stderr, " Private Call (ILLEGALLY_PARKED)");
+        if (p_kind == 2) fprintf (stderr, " Call (ILLEGALLY_PARKED)");
        if (p_kind == 3) fprintf (stderr, " Enable Target MS PTT (EN_PTT_ONE_MS)");

        fprintf (stderr, "\n");
@@ -1055,7 +1058,7 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
        //get 2-bit status values for each 6 channels (timeslots) 
        for (i = 0; i < 6; i++) xpt_ch[i] = (uint8_t)ConvertBitIntoBytes(&cs_pdu_bits[20+(i*2)], 2);

-        fprintf (stderr, " Hytera XPT Site Status - Free RPT: %d SN: %d\n ", xpt_free+1, xpt_seq);
+        fprintf (stderr, " Hytera XPT Site Status - Free RPT: %d SN: %d\n ", xpt_free, xpt_seq);

        //Print List of Channels and Activity 
        for (i = 0; i < 6; i++) 
@@ -1081,16 +1084,32 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
        }

        //add string for ncurses terminal display
-        sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
+        sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free);

        //assign to cc freq to follow during no sync
-        //current theory is that user should set channel 0 as the 'home repeater' frequency
-        //this can change if this is ever tested by anybody properly
-        if (state->trunk_chan_map[0] != 0)
+        long int ccfreq = 0; 
+
+        //if using rigctl we can set an unknown or updated cc frequency 
+        if (opts->use_rigctl == 1 ) 
        {
-          state->p25_cc_freq = state->trunk_chan_map[0];
-          //set to always tuned
-          opts->p25_is_tuned = 1;
+          ccfreq = GetCurrentFreq (opts->rigctl_sockfd);
+          if (ccfreq != 0)
+          {
+            state->p25_cc_freq = ccfreq;
+            opts->p25_is_tuned = 1;
+          } 
+        }
+
+        //if using rtl input, we can ask for the current frequency tuned
+        if (opts->audio_in_type == 3 )
+        {
+          ccfreq = (long int)opts->rtlsdr_center_freq;
+          if (ccfreq != 0)
+          {
+            state->p25_cc_freq = ccfreq;
+            opts->p25_is_tuned = 1;
+          } 
+
        }

        //Skip tuning calls if group calls are disabled
@@ -1161,6 +1180,11 @@ void dmr_cspdu (dsd_opts * opts, dsd_state * state, uint8_t cs_pdu_bits[], uint8
        //and if calls occur on the home repeater, it'll be too busy with those to go to the free repeater
        //DSD-FME doesn't have any sort of TG priority, so its first come first served, just block or allow

+        //Additional Notes: I've set XPT to set a CC frequency to whichever frequency its tuned to currently and getting
+        //this particular CSBK, if the status portion does work correctly, then it shouldn't matter which frequency it is on
+        //as long as this CSBK comes in and we can tune to other repeater lcns if they have activity and the frequency mapping
+        //is correct in the csv file, assuming the current frequency doesn't have voice activity
+
      } //end 0x0A

      //XPT Site Information - Adj Site Info??
--- a/src/dmr_flco.c
+++ b/src/dmr_flco.c
@@ -84,6 +84,14 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
    if (slot == 0) state->dmr_flco = flco;
    else state->dmr_flcoR = flco;

+    //FID 0x10 and FLCO 0x14, 0x15, 0x16 and 0x17 confirmed as Moto EMB Alias
+    //Can probably assume FID 0x10 FLCO 0x18 is Moto EMB GPS -- to be tested
+    if ( fid == 0x10 && (flco == 0x14 || flco == 0x15 || flco == 0x16 || flco == 0x17 || flco == 0x18) )
+    {
+      flco = flco - 0x10;
+      fid = 0;
+    }
+
    //Embedded Talker Alias Header Only (format and len storage)
    if ( (fid == 0 || fid == 0x68) && type == 3 && flco == 0x04) 
    {
@@ -113,8 +121,8 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
      source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
    }

-    //Unknown CapMax/Moto Things -- 0x14, 0x15, 0x16 are new ones on emb
-    if (fid == 0x10 && (flco == 0x08 || flco == 0x28 || flco == 0x14 || flco == 0x15 || flco == 0x16)) 
+    //Unknown CapMax/Moto Things
+    if (fid == 0x10 && (flco == 0x08 || flco == 0x28)) 
    {
      //NOTE: fid 0x10 and flco 0x08 (emb) produces a lot of 'zero' bytes
      //this has been observed to happen often on CapMax systems, so I believe it could be some CapMax 'thing'
@@ -195,7 +203,7 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
      xpt_res_c = (uint8_t)ConvertBitIntoBytes(&lc_bits[72], 8); //some unknown 8 bit value after the SRC

      //speculation: 16,4 may be the current repeater channel this call will occur on? or the channel to interrupt?, could also be 8 bits?
-      xpt_int = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 4);
+      xpt_int = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 4); //not sure about this value for this FLCO    

      //the crc8 hash is the value represented in the CSBK when dealing with private calls
      for (int i = 0; i < 16; i++) target_hash[i] = lc_bits[32+i];
@@ -213,7 +221,7 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
      if (opts->payload == 1) fprintf(stderr, "HASH=%d ", tg_hash);
      // if (opts->payload == 1) fprintf(stderr, "HSK [%X] ", xpt_hand);

-      if (opts->payload == 1) fprintf(stderr, "CH=%X ", xpt_int+1); //repeater channel to 'interrupt' with this call?
+      // if (opts->payload == 1) fprintf(stderr, "CH=%d ", xpt_int);
      if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X ", flco, fid);

      // if (opts->payload == 1) fprintf(stderr, "RS [%02X][%02X][%02X] ", xpt_res_a, xpt_res_b, xpt_res_c);
@@ -221,14 +229,14 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
      fprintf (stderr, "Hytera XPT ");
      if (reserved == 1) fprintf (stderr, "Group "); //according to observation
      else fprintf (stderr, "Private "); //according to observation
-      fprintf (stderr, "Call Protect ");
+      fprintf (stderr, "Call Alert "); //sounds more reasonable than 'protect'

      fprintf (stderr, "%s", KYEL);
-      fprintf (stderr, "F-Rpt %d", xpt_free+1);
+      fprintf (stderr, "F-Rpt %d", xpt_free);
      fprintf (stderr, "%s ", KNRM);

      //add string for ncurses terminal display
-      sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
+      sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free);

      is_xpt = 1;
      goto END_FLCO;
@@ -899,11 +907,11 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
    //The Priority Repeater and Priority Hash values stem from SDRTrunk, but I've never seen these values not be zeroes
    // fprintf (stderr, " SLCO Hytera XPT - Free RPT %d - PRI RPT %d - PRI HASH: %02X", xpt_free, xpt_pri, xpt_hash);
    //NOTE: on really busy systems, this free repeater assignment can lag due to the 4 TS requirment to get SLC
-    fprintf (stderr, " SLCO Hytera XPT - Free RPT %d ", xpt_free+1); 
+    fprintf (stderr, " SLCO Hytera XPT - Free RPT %d ", xpt_free); 
    sprintf (state->dmr_branding_sub, "XPT ");

    //add string for ncurses terminal display
-    sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free+1);
+    sprintf (state->dmr_site_parms, "Free RPT - %d ", xpt_free);
  }
    
  else fprintf (stderr, " SLCO Unknown - %d ", slco);
@@ -955,6 +963,10 @@ void dmr_embedded_alias_blocks (dsd_opts * opts, dsd_state * state, uint8_t lc_b
  uint8_t len =  state->dmr_alias_len[slot];
  uint8_t start; //starting position depends on context of block and format

+  //Cap Max Variation
+  uint8_t fid = (uint8_t)ConvertBitIntoBytes(&lc_bits[8], 8);
+  if (fid == 0x10) block = block - 0x10; //CapMax adds 0x10 to its FLCO (block num) in its Embedded Aliasing
+
  //there is some issue with the next three lines of code that prevent proper assignments, not sure what.
  //if (block > 4) start = 16;
  //else if (block == 4 && format > 0) start = 23; //8-bit and 16-bit chars
--- a/src/dsd_frame.c
+++ b/src/dsd_frame.c
@@ -486,10 +486,6 @@ processFrame (dsd_opts * opts, dsd_state * state)
      state->currentslot = 0;
      sprintf (state->fsubtype, " LDU1         ");
      state->numtdulc = 0;
-      if (state->payload_algid == 0x81)
-      {
-        fprintf (stderr, "\n");
-      }

      processLDU1 (opts, state);
    }
@@ -542,8 +538,8 @@ processFrame (dsd_opts * opts, dsd_state * state)
        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
      }
      mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
-      state->lasttg = 0;
-      state->lastsrc = 0;
+      // state->lasttg = 0;
+      // state->lastsrc = 0;
      state->lastp25type = 0;
      state->err_str[0] = 0;
      sprintf (state->fsubtype, " TDULC        ");
@@ -604,10 +600,11 @@ processFrame (dsd_opts * opts, dsd_state * state)
    }
  else if (strcmp (duid, "30") == 0)
    {
+      state->dmrburstL = 29;
      if (opts->errorbars == 1)
      {
        printFrameInfo (opts, state);
-        fprintf (stderr," PDU\n"); //multi block/packet PDU
+        fprintf (stderr," MBF\n"); //multi block format PDU
      }
      if (opts->mbe_out_dir[0] != 0)
      {
@@ -619,79 +616,11 @@ processFrame (dsd_opts * opts, dsd_state * state)
        resumeScan (opts, state);
      }
      state->lastp25type = 4;
-      sprintf (state->fsubtype, " PDU          ");
+      sprintf (state->fsubtype, " MBF          ");
+
+      processMPDU(opts, state);
    }

-  // try to guess based on previous frame if unknown type
-  // disabling the guessing game on P1
-
-  // else if (state->lastp25type == 1)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr,"(LDU2) ");
-  //       }
-  //     // if (opts->mbe_out_dir[0] != 0)
-  //     //   {
-  //     //     if (opts->mbe_out_f == NULL)
-  //     //       {
-  //     //         openMbeOutFile (opts, state);
-  //     //       }
-  //     //   }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is LDU2
-  //     state->lastp25type = 2;
-  //     sprintf (state->fsubtype, "(LDU2)        ");
-  //     state->numtdulc = 0;
-  //     processLDU2 (opts, state);
-  //   }
-  // else if (state->lastp25type == 2)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr,"(LDU1) ");
-  //       }
-  //     if (opts->mbe_out_dir[0] != 0)
-  //       {
-  //         if (opts->mbe_out_f == NULL)
-  //           {
-  //             openMbeOutFile (opts, state);
-  //           }
-  //       }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is LDU1
-  //     state->lastp25type = 1;
-  //     sprintf (state->fsubtype, "(LDU1)        ");
-  //     state->numtdulc = 0;
-  //     processLDU1 (opts, state);
-  //   }
-  // else if (state->lastp25type == 3)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr," (TSBK)\n");
-  //       }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is TSBK
-  //     state->lastp25type = 3;
-  //     sprintf (state->fsubtype, "(TSBK)        ");
-
-  //     // Now processing NID
-  //     skipDibit (opts, state, 328-25);
-  //   }
-  // else if (state->lastp25type == 4)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr," (PDU)\n");
-  //       }
-  //     state->lastp25type = 0;
-  //   }
-
  else
  {
    state->lastp25type = 0;
@@ -699,8 +628,8 @@ processFrame (dsd_opts * opts, dsd_state * state)
    if (opts->errorbars == 1)
    {
      printFrameInfo (opts, state);
-      fprintf (stderr," duid:%s *Unknown DUID*\n", duid); //prints on dPMR frame 3
-      // fprintf (stderr, "\n"); //prints on dPMR frame 3
+      // fprintf (stderr," duid:%s *Unknown DUID*\n", duid);
+      fprintf (stderr," duid:%s \n", duid); //DUID ERR
    }
  }
 }
--- a/src/dsd_frame_sync.c
+++ b/src/dsd_frame_sync.c
@@ -150,7 +150,7 @@ getFrameSync (dsd_opts * opts, dsd_state * state)

  //start control channel hunting if using trunking, time needs updating on each successful sync
  //will need to assign frequencies to a CC array for P25 since that isn't imported from CSV
-  if (state->dmr_rest_channel == -1 && opts->p25_is_tuned == 0 && opts->p25_trunk == 1 && ( (time(NULL) - state->last_cc_sync_time) > (opts->trunk_hangtime + 2) ) )
+  if (state->dmr_rest_channel == -1 && opts->p25_is_tuned == 0 && opts->p25_trunk == 1 && ( (time(NULL) - state->last_cc_sync_time) > (opts->trunk_hangtime + 0) ) ) //was 3, go to hangtime value
  {

    //test to switch back to 10/4 P1 QPSK for P25 FDMA CC
@@ -163,10 +163,23 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
    //start going through the lcn/frequencies CC/signal hunting
    fprintf (stderr, "Control Channel Signal Lost. Searching for Control Channel.\n");
    //make sure our current roll value doesn't exceed value of frequencies imported
-    if (state->lcn_freq_roll > state->lcn_freq_count)
+    if (state->lcn_freq_roll >= state->lcn_freq_count) //fixed this to skip the extra wait out at the end of the list
    {
      state->lcn_freq_roll = 0; //reset to zero
    }
+    //roll an extra value up if the current is the same as what's already loaded -- faster hunting on Cap+, etc
+    if (state->lcn_freq_roll != 0)
+    {
+      if (state->trunk_lcn_freq[state->lcn_freq_roll-1] == state->trunk_lcn_freq[state->lcn_freq_roll])
+      {
+        state->lcn_freq_roll++;
+        //check roll again if greater than expected, then go back to zero
+        if (state->lcn_freq_roll >= state->lcn_freq_count) 
+        {
+          state->lcn_freq_roll = 0; //reset to zero
+        } 
+      }
+    }
    //check that we have a non zero value first, then tune next frequency
    if (state->trunk_lcn_freq[state->lcn_freq_roll] != 0) 
    {
@@ -182,7 +195,7 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
        rtl_udp_tune (opts, state, state->trunk_lcn_freq[state->lcn_freq_roll]);
      }
      
-      fprintf (stderr, "Tuning to Control Channel Frequency: %.06lf MHz\n", 
+      fprintf (stderr, "Tuning to Frequency: %.06lf MHz\n", 
                (double)state->trunk_lcn_freq[state->lcn_freq_roll]/1000000);

    }
--- a/src/dsd_main.c
+++ b/src/dsd_main.c
@@ -52,7 +52,7 @@ char * FM_banner[9] = {
  " ██║  ██║ ╚═══██╗██║  ██║    ██╔══╝  ██║╚██╔╝██║██╔══╝  ",
  " ██████╔╝██████╔╝██████╔╝    ██║     ██║ ╚═╝ ██║███████╗",
  " ╚═════╝ ╚═════╝ ╚═════╝     ╚═╝     ╚═╝     ╚═╝╚══════╝",
-  " 'Lite' Edition v2.0.0-40-gc999c97   Windows 32-bit RC4 "
+  " 'Aero' Edition v2.0.0-64-gbd94f83  Windows 32-bit RC5  "
 };

 int comp (const void *a, const void *b)
@@ -77,6 +77,67 @@ void
 noCarrier (dsd_opts * opts, dsd_state * state)
 {

+  // // experimental conventional frequency scanner mode
+  // if (opts->scanner_mode == 1)
+  // {
+
+  //   if (state->lcn_freq_roll > state->lcn_freq_count) //with >= we were cutting one short
+  //   {
+  //     state->lcn_freq_roll = 0; //reset to zero
+  //   }
+  //   //check that we have a non zero value first, then tune next frequency
+  //   if (state->trunk_lcn_freq[state->lcn_freq_roll] != 0) 
+  //   {
+  //     //rigctl
+  //     if (opts->use_rigctl == 1)
+  //     {
+  //       if (opts->setmod_bw != 0 )  SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+  //       SetFreq(opts->rigctl_sockfd, state->trunk_lcn_freq[state->lcn_freq_roll]);
+  //     }
+  //     //rtludp
+  //     if (opts->audio_in_type == 3)
+  //     {
+  //       rtl_udp_tune (opts, state, state->trunk_lcn_freq[state->lcn_freq_roll]);
+  //     }
+
+  //     if (state->lastsynctype != -1) fprintf (stderr, "Resume Scanning Mode\n");
+
+  //   }
+  //   state->lcn_freq_roll++;
+  // }
+  // //end experimental conventional frequency scanner mode
+
+  //experimental conventional frequency scanner mode
+  if (opts->scanner_mode == 1 && ( (time(NULL) - state->last_cc_sync_time) > opts->trunk_hangtime))
+  {
+
+    if (state->lcn_freq_roll >= state->lcn_freq_count)
+    {
+      state->lcn_freq_roll = 0; //reset to zero
+    }
+    //check that we have a non zero value first, then tune next frequency
+    if (state->trunk_lcn_freq[state->lcn_freq_roll] != 0) 
+    {
+      //rigctl
+      if (opts->use_rigctl == 1)
+      {
+        if (opts->setmod_bw != 0 )  SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+        SetFreq(opts->rigctl_sockfd, state->trunk_lcn_freq[state->lcn_freq_roll]);
+      }
+      //rtludp
+      if (opts->audio_in_type == 3)
+      {
+        rtl_udp_tune (opts, state, state->trunk_lcn_freq[state->lcn_freq_roll]);
+      }
+
+      if (state->lastsynctype != -1) fprintf (stderr, "Resume Scanning Mode\n");
+
+    }
+    state->lcn_freq_roll++;
+    state->last_cc_sync_time = time(NULL);
+  }
+  //end experimental conventional frequency scanner mode
+
  //tune back to last known CC when using trunking after x second hangtime 
  if (opts->p25_trunk == 1 && opts->p25_is_tuned == 1 && ( (time(NULL) - state->last_cc_sync_time) > opts->trunk_hangtime) ) 
  {
@@ -501,7 +562,9 @@ initOpts (dsd_opts * opts)

  opts->p25_trunk = 0; //0 disabled, 1 is enabled
  opts->p25_is_tuned = 0; //set to 1 if currently on VC, set back to 0 on carrier drop
-  opts->trunk_hangtime = 1; //1 second hangtime by default before tuning back to CC
+  opts->trunk_hangtime = 1; //1 second hangtime by default before tuning back to CC, going sub 1 sec causes issues with cc slip
+
+  opts->scanner_mode = 0; //0 disabled, 1 is enabled

  //reverse mute 
  opts->reverse_mute = 0;
@@ -884,13 +947,13 @@ usage ()
 {

  printf ("\n");
-  printf ("Usage: dsd-fme-lite [options]            Decoder/Trunking Mode\n");
-  printf ("  or:  dsd-fme-lite [options] -r <files> Read/Play saved mbe data from file(s)\n");
-  printf ("  or:  dsd-fme-lite -h                   Show help\n");
+  printf ("Usage: dsd-fme-aero [options]            Decoder/Trunking Mode\n");
+  printf ("  or:  dsd-fme-aero [options] -r <files> Read/Play saved mbe data from file(s)\n");
+  printf ("  or:  dsd-fme-aero -h                   Show help\n");
  printf ("\n");
  printf ("Display Options:\n");
  printf ("  -N            Use NCurses Terminal\n");
-  printf ("                 dsd-fme-lite -N 2> log.ans \n");
+  printf ("                 dsd-fme-aero -N 2> log.ans \n");
  printf ("  -Z            Log MBE/PDU Payloads to console\n");
  printf ("\n");
  printf ("Input/Output options:\n");
@@ -935,7 +998,7 @@ usage ()
  printf ("  bw   <num>    RTL-SDR VFO Bandwidth kHz (default = 12)(6, 8, 12, 24)  \n");
  printf ("  sq   <num>    RTL-SDR Squelch Level (0 - Open, 25 - Little, 50 - Higher)\n");
  printf ("  udp  <num>    RTL-SDR UDP Remote Port (default = 6020)\n");
-  printf (" Example: dsd-fme-lite -fp -i rtl:0:851.375M:22:-2:12:0:6021\n");
+  printf (" Example: dsd-fme-aero -fp -i rtl:0:851.375M:22:-2:12:0:6021\n");
  printf ("\n");
  printf ("Decoder options:\n");
  printf ("  -fa           Legacy Auto Detection (old methods default)\n");
@@ -979,6 +1042,8 @@ usage ()
  printf ("                 Use this feature to allow MAC_SIGNAL even if CRC errors.\n");
  printf ("  -F            Relax DMR RAS/CRC CSBK/DATA Pass/Fail\n");
  printf ("                 Enabling on some systems could lead to bad voice/data decoding if bad or marginal signal\n");
+  printf ("  -F            Relax NXDN SACCH/FACCH/CAC/F2U CRC Pass/Fail\n");
+  printf ("                 Not recommended on NXDN, but can be bypassed if desired.\n");
  printf ("\n");
  printf ("  -K <dec>      Manually Enter Basic Privacy Key (Decimal Value of Key Number)\n");
  printf ("\n");
@@ -1002,6 +1067,9 @@ usage ()
  printf ("  -G <file>     Import Group List Allow/Block and Label from csv file.\n");
  printf ("                 (See group.csv for example)\n");
  printf ("  -T            Enable Trunking Features (NXDN/P25/EDACS/DMR) with RIGCTL/TCP or RTL Input\n");
+  printf ("  -Y            Enable Fast Scanning Mode with RIGCTL/TCP or RTL Input (Lower z) \n");
+  printf ("                 Experimental -- Can only scan for sync with enabled decoders, don't mix NXDN and DMR/P25!\n");
+  printf ("                 This is not a Trunking Feature, just scans through conventional frequencies fast!\n");
  printf ("  -W            Use Imported Group List as a Trunking Allow/White List -- Only Tune with Mode A\n");
  printf ("  -p            Disable Tune to Private Calls (DMR TIII and P25)\n");
  printf ("  -E            Disable Tune to Group Calls (DMR TIII, Con+, Cap+ and P25)\n");
@@ -1012,10 +1080,10 @@ usage ()
  printf ("  -B <Hertz>    Set RIGCTL Setmod Bandwidth in Hertz (0 - default - OFF)\n");
  printf ("                 P25 - 7000-12000; P25 (QPSK) - 12000; NXDN48 - 4000; DMR - 7000; EDACS/PV - 12500;\n");
  printf ("                 May vary based on system stregnth, etc.\n");
-  printf ("  -t <secs>     Set Trunking VC/sync loss hangtime in seconds. (default = 1 second)\n");
+  printf ("  -t <secs>     Set Trunking or Fast Scan VC/sync loss hangtime in seconds. (default = 1 second) (decimal values permitted) \n");
  printf ("\n");
-  printf (" Trunking Example TCP: dsd-fme-lite -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans\n");
-  printf (" Trunking Example RTL: dsd-fme-lite -fs -i rtl:0:450M:26:-2:8:0:6020 -T -C connect_plus_chan.csv -G group.csv -N 2> log.ans\n");
+  printf (" Trunking Example TCP: dsd-fme-aero -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans\n");
+  printf (" Trunking Example RTL: dsd-fme-aero -fs -i rtl:0:450M:26:-2:8:0:6020 -T -C connect_plus_chan.csv -G group.csv -N 2> log.ans\n");
  printf ("\n");
  exit (0);
 }
@@ -1212,7 +1280,7 @@ main (int argc, char **argv)

  exitflag = 0;

-  while ((c = getopt (argc, argv, "haepPqs:t:v:z:i:o:d:c:g:nw:B:C:R:f:m:u:x:A:S:M:G:D:L:VU:Y:K:H:X:NQ:WrlZTF01:2:345:6:7:89:Ek:")) != -1)
+  while ((c = getopt (argc, argv, "haepPqs:t:v:z:i:o:d:c:g:nw:B:C:R:f:m:u:x:A:S:M:G:D:L:VU:YK:H:X:NQ:WrlZTF01:2:345:6:7:89:Ek:")) != -1)
    {
      opterr = 0;
      switch (c)
@@ -1224,10 +1292,14 @@ main (int argc, char **argv)
          opts.call_alert = 1;
          break;

-        //Free'd up switches include Q,Y,z
+        //Free'd up switches include 
        //make sure to put a colon : after each if they need an argument
        //or remove colon if no argument required

+        case 'Y': //conventional scanner mode
+          opts.scanner_mode = 1; //enable scanner
+          opts.p25_trunk = 0; //turn off trunking mode if user enabled it
+          break;

        case 'k': //NXDN multi-key loader
          strncpy(opts.key_in_file, optarg, 1023);
@@ -1315,6 +1387,7 @@ main (int argc, char **argv)
        case 'T': //new letter assignment for trunking, flow down to allow temp numbers
        case '3':
          opts.p25_trunk = 1;
+          opts.scanner_mode = 0; //turn off scanner mode if user enabled it
          break;

        case 'U': //New letter assignment for RIGCTL TCP port, flow down to allow temp numbers
@@ -1323,9 +1396,14 @@ main (int argc, char **argv)
          if (opts.rigctlportno != 0) opts.use_rigctl = 1; 
          break;

+        //NOTE: I changed trunk_hangtime to a float, BUT! time(NULL) returns in second whole numbers
+        //so using anything but whole numbers won't affect the outcome (rounded up?), in the future though,
+        //may change to a different return on sync times and this will matter!
+
        case 't': //New letter assignment for Trunk Hangtime, flow down to allow temp numbers
-        case '6': //hangtime in seconds, default is 1;
-          sscanf (optarg, "%d", &opts.trunk_hangtime);
+        case '6': //hangtime in seconds, default is 1; 
+          sscanf (optarg, "%f", &opts.trunk_hangtime); //updated for float/decimal values
+          fprintf (stderr, "Trunking or Fast Scanner Hang Time set to: %.02f sec\n", opts.trunk_hangtime);
          break;
        
        case 'q': //New letter assignment for Reverse Mute, flow down to allow temp numbers
@@ -1465,6 +1543,7 @@ main (int argc, char **argv)
          //fprintf (stderr,"DMR Stereo Aggressive Resync Disabled!\n");
          fprintf (stderr, "Relax P25 Phase 2 MAC_SIGNAL CRC Checksum Pass/Fail\n");
          fprintf (stderr, "Relax DMR RAS/CRC CSBK/DATA Pass/Fail\n");
+          fprintf (stderr, "Relax NXDN SACCH/FACCH/CAC/F2U CRC Pass/Fail\n");
          fprintf (stderr, "%s", KNRM);
          break;

@@ -1489,7 +1568,7 @@ main (int argc, char **argv)
          // fprintf (stderr,"Writing mbe data temporarily disabled!\n");
          break;

-        case 'c': //now is symbol capture bin output like FME Lite
+        case 'c': 
          strncpy(opts.symbol_out_file, optarg, 1023);
          opts.symbol_out_file[1023] = '\0';
          fprintf (stderr,"Writing + Appending symbol capture to file %s\n", opts.symbol_out_file);
@@ -1612,7 +1691,7 @@ main (int argc, char **argv)
              opts.dmr_stereo = 0;
              opts.dmr_mono = 0;
              state.dmr_stereo = 0;
-              opts.setmod_bw = 12500;
+              // opts.setmod_bw = 12500;
              sprintf (opts.output_name, "EDACS/PV");
              fprintf (stderr,"Setting symbol rate to 9600 / second\n");
              fprintf (stderr,"Decoding only ProVoice frames.\n");
@@ -1639,7 +1718,9 @@ main (int argc, char **argv)
              opts.dmr_mono = 0;
              opts.pulse_digi_rate_out = 48000;
              opts.pulse_digi_out_channels = 1;
-              opts.setmod_bw = 12000;
+              // opts.setmod_bw = 12000;
+              opts.ssize = 36; //128 current default, fall back to old default on P1 only systems
+              opts.msize = 15; //1024 current default, fall back to old default on P1 only systems
              sprintf (opts.output_name, "P25P1");
              fprintf (stderr,"Decoding only P25 Phase 1 frames.\n");
            }
@@ -1720,7 +1801,7 @@ main (int argc, char **argv)
                  opts.dmr_stereo = 1;
                  state.dmr_stereo = 0;
                  opts.dmr_mono = 0;
-                  opts.setmod_bw = 12000;
+                  // opts.setmod_bw = 12000;
                  sprintf (opts.output_name, "P25P2");
                  fprintf (stderr,"Decoding P25-P2 frames C4FM or OP25 Symbol Captures!\n");
                  }
@@ -1743,7 +1824,7 @@ main (int argc, char **argv)
                state.rf_mod = 0;
                opts.dmr_stereo = 1;
                opts.dmr_mono = 0;
-                opts.setmod_bw = 7000;
+                // opts.setmod_bw = 7000;
                opts.pulse_digi_rate_out = 24000;
                opts.pulse_digi_out_channels = 2;
                sprintf (opts.output_name, "DMR Stereo");
@@ -1771,7 +1852,7 @@ main (int argc, char **argv)
                      state.rf_mod = 0;
                      opts.dmr_stereo = 1;
                      opts.dmr_mono = 0;
-                      opts.setmod_bw = 12000; //safe default on both DMR and P25
+                      // opts.setmod_bw = 12000; //safe default on both DMR and P25
                      opts.pulse_digi_rate_out = 24000;
                      opts.pulse_digi_out_channels = 2;
                      sprintf (opts.output_name, "XDMA");
@@ -1823,7 +1904,7 @@ main (int argc, char **argv)
              opts.dmr_mono = 1;
              opts.dmr_stereo = 0;
              state.dmr_stereo = 0; //0
-              opts.setmod_bw = 7000;
+              // opts.setmod_bw = 7000;
              sprintf (opts.output_name, "DMR Mono");
              fprintf(stderr, "Notice: DMR cannot autodetect polarity. \n Use -xr option if Inverted Signal expected.\n");
              fprintf (stderr,"Decoding only DMR Mono. \nUsing DMR Stereo '-fs' or XDMA '-ft' is highly encouraged.\n");
@@ -1889,7 +1970,7 @@ main (int argc, char **argv)
              opts.mod_qpsk = 1;
              opts.mod_gfsk = 0;
              state.rf_mod = 1;
-              opts.setmod_bw = 12000;
+              // opts.setmod_bw = 12000;
              fprintf (stderr,"Enabling only QPSK modulation optimizations.\n");
            }
          else if (optarg[0] == '2')
@@ -1900,7 +1981,7 @@ main (int argc, char **argv)
              state.rf_mod = 1;
              state.samplesPerSymbol = 8; 
              state.symbolCenter = 3; 
-              opts.setmod_bw = 12000;
+              // opts.setmod_bw = 12000;
              fprintf (stderr,"Enabling 6000 sps P25p2 CQPSK.\n");
            }
          //test
@@ -1912,7 +1993,7 @@ main (int argc, char **argv)
              state.rf_mod = 0;
              state.samplesPerSymbol = 10; 
              state.symbolCenter = 4; 
-              opts.setmod_bw = 12000;
+              // opts.setmod_bw = 12000;
              fprintf (stderr,"Enabling 6000 sps P25p2 C4FM.\n");
            }
          else if (optarg[0] == '4')
@@ -1923,7 +2004,7 @@ main (int argc, char **argv)
            state.rf_mod = 0;
            state.samplesPerSymbol = 8; 
            state.symbolCenter = 3; 
-            opts.setmod_bw = 12000;
+            // opts.setmod_bw = 12000;
            fprintf (stderr,"Enabling 6000 sps P25p2 all optimizations.\n");
          }
          break;
--- a/src/dsd_mbe.c
+++ b/src/dsd_mbe.c
@@ -317,7 +317,7 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
          if (state->rkey_array[hash] != 0)
          {
            state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
-            state->K1 = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
+            state->K1 = state->H = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
            opts->dmr_mute_encL = 0;
          }
          // else opts->dmr_mute_encL = 1; //may cause issues for manual key entry (non-csv)
@@ -444,7 +444,7 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
          if (state->rkey_array[hash] != 0)
          {
            state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
-            state->K1 = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
+            state->K1 = state->H = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
            opts->dmr_mute_encR = 0;
          }
          // else opts->dmr_mute_encR = 1; //may cause issues for manual key entry (non-csv)
--- a/src/dsd_ncurses.c
+++ b/src/dsd_ncurses.c
@@ -2061,7 +2061,7 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
  if (opts->ncurses_compact == 1)
  {
    printw ("------------------------------------------------------------------------------\n");
-    printw ("| Digital Speech Decoder: Florida Man Edition - Win32 %s \n", "v2.0.0-40-gc999c97 RC4");
+    printw ("| Digital Speech Decoder: Florida Man Edition - Aero %s \n", "v2.0.0-64-gbd94f83 RC5");
  }
  if (opts->ncurses_compact == 0)
  {
@@ -2072,8 +2072,8 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
      if (i == 1) printw (" ESC to Menu");
      if (i == 2) printw (" 'q' to Quit ");
      if (i == 4) printw (" MBElib %s", versionstr);
-      if (i == 5) printw (" %s ", "Win32 RC4"); //printw (" %s \n", GIT_TAG);
-      if (i == 6) printw (" %s \n", "v2.0.0-40-gc999c97"); //printw (" %s \n", GIT_TAG);
+      if (i == 5) printw (" %s ", "Aero RC5"); //printw (" %s \n", GIT_TAG);
+      if (i == 6) printw (" %s \n", "v2.0.0-64-gbd94f83"); //printw (" %s \n", GIT_TAG);
      else printw ("\n");
    }
    attroff(COLOR_PAIR(6)); //6
@@ -2179,6 +2179,20 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
    printw ("| Reverse Mute - Muting Unencrypted Voice\n");
  }
  if (opts->aggressive_framesync == 0) printw ("| Selective CRC ERR Bypass Enabled (RAS) \n");
+  if (state->M == 1)
+  {
+    if (state->R != 0)  printw ("| Forcing Key Priority -- NXDN Sc Key: %05lld \n", state->R);
+    if (state->K != 0)  printw ("| Forcing Key Priority -- Moto BP Key: %03lld \n", state->K);
+    if (state->K1 != 0) printw ("| Forcing Key Priority -- tera BP Key: %016llX \n", state->K1);
+    if (state->K != 0 && state->K1 != 0) printw ("| Warning! Multiple DMR Key Types Loaded! \n"); //warning may not be required
+  }
+  if (opts->scanner_mode == 1)
+  {
+    printw ("| Fast Scan Mode Enabled ");
+    if (state->lcn_freq_roll != 0) 
+      printw (" - Frequency: [%.06lf] Mhz", (double)state->trunk_lcn_freq[state->lcn_freq_roll-1]/1000000);
+    printw (" Speed: %.02lf sec \n", opts->trunk_hangtime);  //not sure values less than 1 make a difference, may be system/environment dependent 
+  }

  printw ("------------------------------------------------------------------------------\n");
  attroff(COLOR_PAIR(4));
@@ -2278,8 +2292,8 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)

    printw ("\n");
    printw ("| ");
-    printw ("TGT: [%4d] ", tgn);
-    printw ("SRC: [%4d] ", src);
+    printw ("TGT: [%5d] ", tgn);
+    printw ("SRC: [%5d] ", src);
    if (state->nxdn_alias_block_segment[0][0] > 0) 
    {
      printw ("ALIAS: [");
@@ -2317,7 +2331,8 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
    }
    if (state->nxdn_cipher_type == 0x2 && state->carrier == 1)
    {
-      printw ("IV: [%016llX]", state->payload_miN);
+      attron(COLOR_PAIR(1));
+      printw ("IV: [%016llX] ", state->payload_miN);
      attron(COLOR_PAIR(2));
      printw ("DES-OFB  ");
      attroff(COLOR_PAIR(2));
@@ -2325,7 +2340,8 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
    }
    if (state->nxdn_cipher_type == 0x3 && state->carrier == 1)
    {
-      printw ("IV: [%016llX]", state->payload_miN);
+      attron(COLOR_PAIR(1));
+      printw ("IV: [%016llX] ", state->payload_miN);
      attron(COLOR_PAIR(2));
      printw ("AES-256 ");
      attroff(COLOR_PAIR(2));
@@ -2922,9 +2938,9 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
        printw ("| %s ", SyncTypes[call_matrix[9-j][0]]);
        if (lls == 28 || lls == 29)
        {
-          printw ("RAN [%2lld] ", call_matrix[9-j][1]);
-          printw ("TG [%4lld] ", call_matrix[9-j][4]);
-          printw ("RID [%4lld] ", call_matrix[9-j][2]);
+          printw ("RAN [%02lld] ", call_matrix[9-j][1]);
+          printw ("TG [%5lld] ", call_matrix[9-j][4]);
+          printw ("RID [%5lld] ", call_matrix[9-j][2]);
        }
        //dPMR
        if (lls == 20 || lls == 21 || lls == 22 || lls == 23 ||lls == 24 || lls == 25 || lls == 26 || lls == 27)
@@ -3007,6 +3023,13 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
    else opts->p25_trunk = 1;
  }

+  if (c == 121) //'y' key, toggle scanner mode
+ {
+  if (opts->scanner_mode == 1) opts->scanner_mode = 0;
+  else opts->scanner_mode = 1;
+  opts->p25_trunk = 0; //turn off trunking mode
+ }
+
  if (c == 97) //'a' key, toggle call alert beep
  {
    if (opts->call_alert == 1) opts->call_alert = 0;
@@ -3193,38 +3216,83 @@ ncursesPrinter (dsd_opts * opts, dsd_state * state)
    
  // }
  //
-
-  // //Lockout bug in EDACS prevents any group from tuning when using this, not sure why yet
-  // //WARNING! USE THESE WITH CAUTION! IF BREAKING ISSUES OBSERVED, THEN RESTART AND DON'T USE THEM!!
-  if (opts->frame_provoice != 1 && c == 49) //'1' key, lockout slot 1 or conventional tg from tuning/playback during session
+  
+  //test jumping back to CC on group lockout instead of random frequency to break framesync
+  if (state->lasttg != 0 && opts->frame_provoice != 1 && c == 49) //'1' key, lockout slot 1 or conventional tg from tuning/playback during session
  {
    state->group_array[state->group_tally].groupNumber = state->lasttg;
    sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
    sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
    state->group_tally++;

-    //test tuning away to break sync, if not working so well, then disable
+    //extra safeguards due to sync issues with NXDN
+    memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
+    memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
+
+    //reset dmr blocks
+    dmr_reset_blocks (opts, state);
+
+    //zero out additional items
+    state->lasttg = 0;
+    state->lasttgR = 0;
+    state->lastsrc = 0;
+    state->lastsrcR = 0;
+    state->payload_algid = 0;
+    state->payload_algidR = 0;
+    state->payload_keyid = 0;
+    state->payload_keyidR = 0;
+    state->payload_mi = 0;
+    state->payload_miR = 0;
+    state->payload_miP = 0;
+    state->payload_miN = 0;
+    opts->p25_is_tuned = 0;
+    state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+
+    //tune back to the control channel
    //RIGCTL
-    if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
+    if (opts->p25_trunk == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, state->p25_cc_freq);

    //rtl_udp
-    if (opts->frame_provoice != 1 && opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
+    if (opts->p25_trunk == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, state->p25_cc_freq);

  }

-  if (opts->frame_provoice != 1 && c == 50) //'2' key, lockout slot 2 tdma tgR from tuning/playback during session
+  if (state->lasttgR != 0 && opts->frame_provoice != 1 && c == 50) //'2' key, lockout slot 2 tdma tgR from tuning/playback during session
  {
    state->group_array[state->group_tally].groupNumber = state->lasttgR;
    sprintf (state->group_array[state->group_tally].groupMode, "%s", "B");
    sprintf (state->group_array[state->group_tally].groupName, "%s", "LOCKOUT");
    state->group_tally++;

-    //test tuning away to break sync, if not working so well, then disable
+    //extra safeguards due to sync issues with NXDN
+    memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
+    memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
+
+    //reset dmr blocks
+    dmr_reset_blocks (opts, state);
+
+    //zero out additional items
+    state->lasttg = 0;
+    state->lasttgR = 0;
+    state->lastsrc = 0;
+    state->lastsrcR = 0;
+    state->payload_algid = 0;
+    state->payload_algidR = 0;
+    state->payload_keyid = 0;
+    state->payload_keyidR = 0;
+    state->payload_mi = 0;
+    state->payload_miR = 0;
+    state->payload_miP = 0;
+    state->payload_miN = 0;
+    opts->p25_is_tuned = 0;
+    state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+
+    //tune back to the control channel
    //RIGCTL
-    if (opts->p25_is_tuned == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, 450000000);
+    if (opts->p25_trunk == 1 && opts->use_rigctl == 1) SetFreq(opts->rigctl_sockfd, state->p25_cc_freq);

    //rtl_udp
-    if (opts->p25_is_tuned == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, 450000000);
+    if (opts->p25_trunk == 1 && opts->audio_in_type == 3) rtl_udp_tune (opts, state, state->p25_cc_freq);

  }

--- a/src/nxdn_deperm.c
+++ b/src/nxdn_deperm.c
@@ -42,7 +42,8 @@ static const int PARITY[] = {
 //decoding functions here
 void nxdn_descramble(uint8_t dibits[], int len)
 {
-	for (int i=0; i<sizeof(scramble_t); i++) {
+	for (int i=0; i<len; i++)
+	{
 		if (scramble_t[i] >= len)
 			break;
 		dibits[scramble_t[i]] ^= 0x2;	// invert sign of scrambled dibits
@@ -119,7 +120,7 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
 	}

 	if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
-	// else if (opts->payload == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
+	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);

 	if (opts->payload == 1)
 	{
@@ -137,10 +138,16 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
 //new sacch
 void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 {
-	uint8_t deperm[60];
-	uint8_t depunc[72];
-	uint8_t trellis_buf[32];
-	uint8_t answer[26];
+	//see about initializing these variables
+	uint8_t deperm[60]; 
+	uint8_t depunc[72];  
+	uint8_t trellis_buf[32]; 
+	uint8_t answer[26]; 
+
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
+	memset (trellis_buf, 0, sizeof(trellis_buf));
+	memset (answer, 0, sizeof(answer));
 	int o = 0;
 	uint8_t crc = 0; //value computed by crc6 on payload
 	uint8_t check = 0; //value pulled from last 6 bits
@@ -186,7 +193,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 	}

 	CNXDNConvolution_start();
-  for (int i = 0U; i < 40U; i++) 
+  for (int i = 0U; i < 36U; i++) //40
  {
    s0 = temp[(2*i)];
    s1 = temp[(2*i)+1];
@@ -195,7 +202,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
  }

 	//stored as 5 bytes, will need to convert to trellis_buf after running
-  CNXDNConvolution_chainback(m_data, 36U); 
+  CNXDNConvolution_chainback(m_data, 32U); //36

 	for(int i = 0; i < 4; i++)
  {
@@ -230,6 +237,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		}

 		if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch); 
+		else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, nsf_sacch);

 		if (opts->payload == 1)
 		{ 
@@ -398,6 +406,7 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
 		//NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
 		NXDN_Elements_Content_decode(opts, state, 1, f2u_message_buffer); 
 	} 
+	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, f2u_message_buffer);

 	if (opts->payload == 1)
 	{
@@ -495,6 +504,7 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 		fprintf (stderr, " CAC    ");
 		NXDN_Elements_Content_decode(opts, state, 1, cac_message_buffer);
 	} 
+	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, cac_message_buffer);  

 	if (opts->payload == 1)
 	{
@@ -518,7 +528,7 @@ void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType)
 	if      (MessageType == 0x10) fprintf(stderr, " IDLE");
 	else if (MessageType == 0x11) fprintf(stderr, " DISC"); //disconnect
 	else if (MessageType == 0x01) fprintf(stderr, " VCALL");
-	else if (MessageType == 0x03) fprintf(stderr, " VCALL IV");
+	else if (MessageType == 0x03) fprintf(stderr, " VCALL_IV");
 	
 	else if (MessageType == 0x07) fprintf(stderr, " TX_REL_EX");
 	else if (MessageType == 0x08) fprintf(stderr, " TX_REL");
@@ -545,9 +555,8 @@ void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType)
 	else fprintf(stderr, " Unknown M-%02X", MessageType);
 	fprintf (stderr, "%s", KNRM);

-	//zero out stale values so they won't persist after a transmit release
-	//disable if random messages wipe out the alias
-	if (MessageType == 0x08 || MessageType == 0x10) //idle, tx_rel
+	//zero out stale values so they won't persist after a transmit release, idle, or disconnect
+	if (MessageType == 0x08 || MessageType == 0x10 || MessageType == 0x11) //tx_rel, idle, or disc
 	{
 		memset (state->nxdn_alias_block_segment, 0, sizeof(state->nxdn_alias_block_segment));
 		state->nxdn_last_rid = 0;
--- a/src/nxdn_element.c
+++ b/src/nxdn_element.c
@@ -18,7 +18,7 @@ void NXDN_SACCH_Full_decode(dsd_opts * opts, dsd_state * state)
  uint32_t i;
  uint8_t CrcCorrect = 1;

-  /* Consider all SACCH CRC parts as corrects */
+  /* Consider all SACCH CRC parts as correct */
  CrcCorrect = 1;

  /* Reconstitute the full 72 bits SACCH */
@@ -33,6 +33,7 @@ void NXDN_SACCH_Full_decode(dsd_opts * opts, dsd_state * state)
  /* Decodes the element content */
  // currently only going to run this if all four CRCs are good
  if (CrcCorrect == 1) NXDN_Elements_Content_decode(opts, state, CrcCorrect, SACCH);
+  else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, SACCH);

 } /* End NXDN_SACCH_Full_decode() */

@@ -98,6 +99,36 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
    //DISC
    case 0x11:
      //NXDN_decode_VCALL(opts, state, ElementsContent);
+
+      //tune back to CC here - save about 1-2 seconds
+      if (opts->p25_trunk == 1 && state->p25_cc_freq != 0 && opts->p25_is_tuned == 1)
+      {
+        //rigctl
+        if (opts->use_rigctl == 1)
+        {
+          //extra safeguards due to sync issues with NXDN
+          memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
+          memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
+          // state->lastsynctype = -1; 
+          // state->last_cc_sync_time = time(NULL);
+          opts->p25_is_tuned = 0;
+          if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+          SetFreq(opts->rigctl_sockfd, state->p25_cc_freq); 
+          
+        }
+        //rtl_udp
+        else if (opts->audio_in_type == 3)
+        {
+          //extra safeguards due to sync issues with NXDN
+          memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
+          memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
+          // state->lastsynctype = -1; 
+          // state->last_cc_sync_time = time(NULL);
+          opts->p25_is_tuned = 0;
+          rtl_udp_tune (opts, state,  state->p25_cc_freq); 
+        }
+      }
+      
      break;

    //Idle
@@ -242,13 +273,9 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
  if (opts->p25_trunk == 1 && state->p25_cc_freq == 0)
  {
    long int ccfreq = 0;
-    if (state->trunk_chan_map[0] != 0) state->p25_cc_freq = state->trunk_chan_map[0];
    
-    //we are assuming that the current channel is the control channel
-    //unsure whether or not control signalling is available on NXDN voice channels
-
-    //if not available from the import file, then poll rigctl if its available
-    else if (opts->use_rigctl == 1)
+    //if not available, then poll rigctl if its available
+    if (opts->use_rigctl == 1)
    {
      ccfreq = GetCurrentFreq (opts->rigctl_sockfd);
      if (ccfreq != 0) state->p25_cc_freq = ccfreq;
@@ -261,6 +288,7 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
    }
  }

+
  //run group/source analysis and tune if available/desired
  //group list mode so we can look and see if we need to block tuning any groups, etc
 	char mode[8]; //allow, block, digital, enc, etc
@@ -429,31 +457,9 @@ void NXDN_decode_cch_info(dsd_opts * opts, dsd_state * state, uint8_t * Message)
  freq1 = nxdn_channel_to_frequency (opts, state, channel1);
  freq2 = nxdn_channel_to_frequency (opts, state, channel2);

-  //add handling for adding (or deleting?) frequencies to CC list
-  if (channel1sts & 0x20 || channel1sts & 0x8) //current or new only
-  {
-    if (freq1 != 0) state->p25_cc_freq = freq1;
-    //let's assume the frequency we are tuned to is the current control channel
-    else if (opts->use_rigctl == 1 && state->p25_cc_freq == 0) //if not set from channel map 0 or nxdn_channel_to_frequency and rigctl is available
-    {
-      freq1 = GetCurrentFreq (opts->rigctl_sockfd);
-      if (freq1 != 0) state->p25_cc_freq = freq1;
-    }
-  }
-  else if (channel1sts & 0x8) //Candidate Added
-  {
-    if (freq1 != 0)
-    {
-      //add to trunk_lcn_freq list?
-      for (int i = 0; i <= state->lcn_freq_count; i++)  //<= pretty sure is correct here since we need to go through atleast one rep
-      {
-        if (freq1 == state->trunk_lcn_freq[i]) goto SKIP;
-      }
-      //assign if freq1 not found in array
-      state->trunk_lcn_freq[state->lcn_freq_count] = freq1;
-      state->lcn_freq_count++;
-    }
-  }
+  //removed code below, may have been causing issues with current CC frequency assignment
+  //removed code is unneccesary for trunking purposes
+

  //if a delete, let's not bother trying to remove it from the list for now
  SKIP: ; //do nothing
@@ -477,6 +483,25 @@ void NXDN_decode_srv_info(dsd_opts * opts, dsd_state * state, uint8_t * Message)
  nxdn_location_id_handler (state, location_id);
  fprintf (stderr, "%s", KNRM);

+  //poll for current frequency, will always be the control channel
+  //this PDU is constantly pumped out on the CC CAC Message
+  if (opts->p25_trunk == 1)
+  {
+    long int ccfreq = 0;
+    //if using rigctl, we can poll for the current frequency
+    if (opts->use_rigctl == 1)
+    {
+      ccfreq = GetCurrentFreq (opts->rigctl_sockfd);
+      if (ccfreq != 0) state->p25_cc_freq = ccfreq;
+    }
+    //if using rtl input, we can ask for the current frequency tuned
+    else if (opts->audio_in_type == 3)
+    {
+      ccfreq = (long int)opts->rtlsdr_center_freq;
+      if (ccfreq != 0) state->p25_cc_freq = ccfreq;
+    }
+  }
+
 }

 //externalize the location handler to its own function
@@ -566,31 +591,9 @@ void NXDN_decode_site_info(dsd_opts * opts, dsd_state * state, uint8_t * Message

  fprintf (stderr, "%s", KNRM);

-  //place the freqs into the array for hunting CC or
-  //rotating CCs without user LCN list
-  if (freq1 != 0)
-  {
-    for (int i = 0; i <= state->lcn_freq_count; i++)  //<= pretty sure is correct here since we need to go through atleast one rep
-    {
-      if (freq1 == state->trunk_lcn_freq[i]) goto SKIP;
-    }
-    //assign if freq1 not found in array
-    state->trunk_lcn_freq[state->lcn_freq_count] = freq1;
-    state->lcn_freq_count++;
-    //shim here for main CC freq?
-    state->p25_cc_freq = freq1;
-  }
+  //removed code below, may have been causing issues with current CC frequency assignment
+  //removed code is unneccesary for trunking purposes

-  if (freq2 != 0)
-  {
-    for (int i = 0; i <= state->lcn_freq_count; i++)  //<= pretty sure is correct here since we need to go through atleast one rep
-    {
-      if (freq2 == state->trunk_lcn_freq[i]) goto SKIP;
-    }
-    //assign if freq2 not found in array
-    state->trunk_lcn_freq[state->lcn_freq_count] = freq2;
-    state->lcn_freq_count++;
-  }

  SKIP: ; //do nothing

@@ -670,14 +673,22 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
  //check the rkey array for a scrambler key value
  //check by keyid first, then by tgt id
  //TGT ID and Key ID could clash though if csv or system has both with different keys
-  // if (state->rkey_array[KeyID] != 0) state->R = state->rkey_array[KeyID];
-  if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];
+  if (state->rkey_array[KeyID] != 0) state->R = state->rkey_array[KeyID];
+  else if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];

-  if (state->M == 1)
-  {
-    state->nxdn_cipher_type = 0x1;
-    CipherType = 0x1;
-  } 
+  //consider removing code below, if we get this far (under good crc),
+  //then we will always have a correct cipher type and won't need to
+  //force it, its only needed on the vcall_assgn where no cipher is set
+  //dsd_mbe can also force the scrambler without triggering the settings here
+
+  // if (state->M == 1)
+  // {
+  //   state->nxdn_cipher_type = 0x1;
+  //   CipherType = 0x1;
+  // }
+
+  //debug
+  // if (CipherType > 0x1) state->R = 0; //don't use on manual key entry

  /* Print the "Cipher Type" */
  if(CipherType != 0)
--- a/src/nxdn_frame.c
+++ b/src/nxdn_frame.c
@@ -45,40 +45,48 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	int sr_structure;
 	int sr_ran;

-	uint8_t lich_dibits[8] = {0}; 
-	uint8_t sacch_bits[60] = {0};
-	uint8_t facch_bits_a[144] = {0};
-	uint8_t facch_bits_b[144] = {0};
-	uint8_t cac_bits[300] = {0};
-	uint8_t facch2_bits[348] = {0}; //facch2 or udch, same amount of bits
+	uint8_t lich_dibits[8]; 
+	uint8_t sacch_bits[60];
+	uint8_t facch_bits_a[144];
+	uint8_t facch_bits_b[144];
+	uint8_t cac_bits[300];
+	uint8_t facch2_bits[348]; //facch2 or udch, same amount of bits

  //nxdn bit buffer, for easy assignment handling
-  int nxdn_bit_buffer[364] = {0}; 
-	int nxdn_dibit_buffer[182] = {0};
+  int nxdn_bit_buffer[364]; 
+	int nxdn_dibit_buffer[182];

+	//init all arrays
 	memset (dbuf, 0, sizeof(dbuf));
+	memset (answer, 0, sizeof(answer));
+	memset (sacch_answer, 0, sizeof(sacch_answer));
+	memset (lich_dibits, 0, sizeof(lich_dibits));
+	memset (sacch_bits, 0, sizeof(sacch_bits));
+	memset (facch_bits_b, 0, sizeof(facch_bits_b));
+	memset (facch_bits_a, 0, sizeof(facch_bits_a));
+	memset (cac_bits, 0, sizeof(cac_bits));
+	memset (facch2_bits, 0, sizeof(facch2_bits));
+
+	memset (nxdn_bit_buffer, 0, sizeof(nxdn_bit_buffer));
+	memset (nxdn_dibit_buffer, 0, sizeof(nxdn_dibit_buffer));

 	//collect lich bits first, if they are good, then we can collect the rest of them
-  for (int i = 0; i < 8; i++) 
-  {
-		lich_dibits[i] = dbuf[i] = getDibit(opts, state);
-  }
+  for (int i = 0; i < 8; i++) lich_dibits[i] = dbuf[i] = getDibit(opts, state);

 	nxdn_descramble (lich_dibits, 8);
 	
 	lich = 0;
-	for (int i=0; i<8; i++)
-  {
-    lich |= (lich_dibits[i] >> 1) << (7-i);
-  }
+	for (int i=0; i<8; i++) lich |= (lich_dibits[i] >> 1) << (7-i);
 		
 	lich_parity_received = lich & 1;
 	lich_parity_computed = ((lich >> 7) + (lich >> 6) + (lich >> 5) + (lich >> 4)) & 1;
 	lich = lich >> 1;
 	if (lich_parity_received != lich_parity_computed)
  {
-    //fprintf(stderr, "NXDN lich parity error, ignoring frame \n");
-		return;
+    // fprintf(stderr, "NXDN lich parity error, ignoring frame \n"); //debug
+		// state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
+		goto END;
+		// return;
 	}
  
 	voice = 0;
@@ -92,6 +100,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	if (lich % 2 == 0 && opts->p25_trunk == 1)
 	{
 		if (opts->payload == 1) fprintf(stderr, "  Simplex/Inbound NXDN lich on trunking system - type 0x%02X\n", lich);
+		// state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
 		goto END;
 	}

@@ -225,12 +234,18 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	//vch frames stay inside dbuf, easier to assign that to ambe_fr frames
 	//sacch needs extra handling depending on superframe or non-superframe variety

-	if (voice)
+	if (voice && !facch) //voice only, no facch steal
 	{
 		fprintf (stderr, "%s", KGRN);
 		fprintf (stderr, " Voice ");
 		fprintf (stderr, "%s", KNRM);
 	}
+	else if (voice && facch) //voice with facch steal
+	{
+		fprintf (stderr, "%s", KGRN);
+		fprintf (stderr, " V%d+F%d ", 3 - facch, facch); //print which position on each
+		fprintf (stderr, "%s", KNRM);
+	}
 	else
 	{
 		fprintf (stderr, "%s", KCYN);
@@ -238,7 +253,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		fprintf (stderr, "%s", KNRM);

 		//roll the voice scrambler LFSR here if key available to advance seed (usually just needed on NXDN96)
-		if (state->nxdn_cipher_type == 0x1 && state->R != 0) //!voice, or voice == 0
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0) 
 		{
 			char ambe_temp[49] = {0};
 			char ambe_d[49] = {0};
@@ -248,16 +263,38 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 			}
 		}

-	}  
+	}
+
+	if (voice && facch == 1) //facch steal 1 -- before voice
+	{
+		//force scrambler here, but with unspecified key (just use what's loaded)
+		if (state->M == 1 && state->R != 0) state->nxdn_cipher_type = 0x1; 
+		//roll the voice scrambler LFSR here if key available to advance seed -- half rotation on a facch steal
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0)
+		{
+			char ambe_temp[49] = {0};
+			char ambe_d[49] = {0};
+			for (int i = 0; i < 2; i++)
+			{
+				LFSRN(ambe_temp, ambe_d, state);
+			}
+		}  
+	}

 	if (lich == 0x20 || lich == 0x21 || lich == 0x61 || lich == 0x40 || lich == 0x41) state->nxdn_sacch_non_superframe = TRUE;
 	else state->nxdn_sacch_non_superframe = FALSE;

-	if (sacch)nxdn_deperm_sacch(opts, state, sacch_bits);
-	if (cac) nxdn_deperm_cac(opts, state, cac_bits); 
+	if (sacch)  nxdn_deperm_sacch(opts, state, sacch_bits);
+	if (cac)    nxdn_deperm_cac(opts, state, cac_bits); 
 	if (facch2) nxdn_deperm_facch2_udch(opts, state, facch2_bits);
-	if (facch & 1) nxdn_deperm_facch(opts, state, facch_bits_a);
-	if (facch & 2) nxdn_deperm_facch(opts, state, facch_bits_b);
+
+	//testing purposes -- don't run facch steals on enc -- causing issues with key loader (VCALL_ASSGN_DUP)
+	if (state->nxdn_cipher_type == 0 || state->R == 0) //!voice
+	{
+		if (facch & 1) nxdn_deperm_facch(opts, state, facch_bits_a);
+		if (facch & 2) nxdn_deperm_facch(opts, state, facch_bits_b);
+	}
+	
 	if (voice)
 	{
 		//restore MBE file open here
@@ -281,7 +318,22 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 			}
 			if (opts->frame_nxdn48 == 1) closeMbeOutFile (opts, state); //okay to close right away if nxdn48, no data/voice mixing
 		} 
-	} 
+	}
+
+	if (voice && facch == 2) //facch steal 2 -- after voice
+	{
+		//roll the voice scrambler LFSR here if key available to advance seed -- half rotation on a facch steal
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0)
+		{
+			char ambe_temp[49] = {0};
+			char ambe_d[49] = {0};
+			for (int i = 0; i < 2; i++)
+			{
+				LFSRN(ambe_temp, ambe_d, state);
+			}
+		}  
+	}
+	

 	fprintf (stderr, "\n");
 	END: ; //do nothing
--- a/src/p25_frequency.c
+++ b/src/p25_frequency.c
@@ -76,33 +76,42 @@ long int nxdn_channel_to_frequency(dsd_opts * opts, dsd_state * state, uint16_t
 		return (freq);
 	}

-	//if not found, attempt to find it via calculation 
 	else
 	{
-		if ((channel > 0) && (channel <= 400))
-		{
-			if (opts->frame_nxdn48 == 1) base = 450000000;
-			else base = 451000000;
+		fprintf(stderr, "\n    Channel not found in import file");
+		return (0);
+	} 

-			freq = base + (channel - 1) * 12500;
-			fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
-			return (freq);
-		}
-		else if ((channel >= 401) && (channel <= 800))
-		{
-			if (opts->frame_nxdn48 == 1) base = 460000000;
-			else base = 461000000;
+	//if not found, attempt to find it via calculation 
+	//disabled, frequency 'band plan' isn't standard
+	//like originally believed

-			freq = base + (channel - 401) * 12500;
-			fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
-			return (freq);
-		}
-		else
-		{
-			fprintf(stderr, "\n  Non-standard frequency or channel not found in import file");
-			return (0);
-		}
-	}
+	// else
+	// {
+	// 	if ((channel > 0) && (channel <= 400))
+	// 	{
+	// 		if (opts->frame_nxdn48 == 1) base = 450000000;
+	// 		else base = 451000000;
+
+	// 		freq = base + (channel - 1) * 12500;
+	// 		fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
+	// 		return (freq);
+	// 	}
+	// 	else if ((channel >= 401) && (channel <= 800))
+	// 	{
+	// 		if (opts->frame_nxdn48 == 1) base = 460000000;
+	// 		else base = 461000000;
+
+	// 		freq = base + (channel - 401) * 12500;
+	// 		fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
+	// 		return (freq);
+	// 	}
+	// 	else
+	// 	{
+	// 		fprintf(stderr, "\n  Non-standard frequency or channel not found in import file");
+	// 		return (0);
+	// 	}
+	// }
 	

 }
--- a/src/p25_lcw.c
+++ b/src/p25_lcw.c
@@ -1,160 +1,340 @@
 #include "dsd.h"

-void
-processP25lcw (dsd_opts * opts, dsd_state * state, char *lcformat, char *mfid, char *lcinfo)
+//new p25_lcw function here -- TIA-102.AABF-D LCW Format Messages (if anybody wants to fill the rest out)
+void p25_lcw (dsd_opts * opts, dsd_state * state, uint8_t LCW_bits[], uint8_t irrecoverable_errors)
 {
+  uint8_t lc_format = (uint8_t)ConvertBitIntoBytes(&LCW_bits[0], 8);  //format
+  uint8_t lc_opcode = (uint8_t)ConvertBitIntoBytes(&LCW_bits[2], 8);  //opcode portion of format
+  uint8_t lc_mfid   = (uint8_t)ConvertBitIntoBytes(&LCW_bits[8], 8);  //mfid
+  uint8_t lc_svcopt = (uint8_t)ConvertBitIntoBytes(&LCW_bits[16], 8); //service options
+  uint8_t lc_pf = LCW_bits[0]; //protect flag
+  uint8_t lc_sf = LCW_bits[1]; //Implicit / Explicit MFID Format

-  char tgid[17], tmpstr[255];
-  long talkgroup, source;
-  int i, j;
+  if (lc_pf == 1) //check the protect flag -- if set, its an encrypted lcw
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW Protected ");
+    fprintf (stderr, "%s",KNRM);
+  }

-  tgid[16] = 0;
+  if (lc_pf == 0) //not protected/encrypted lcw
+  {

-  if (opts->p25lc == 1)
-    {
-      fprintf (stderr, "lcformat: %s mfid: %s lcinfo: %s ", lcformat, mfid, lcinfo);
-      if (opts->p25tg == 0)
-        {
-          fprintf (stderr, "\n");
-        }
-    }
+    if (opts->payload == 1) fprintf (stderr, " LCW"); 

-  if (strcmp (lcformat, "00000100") == 0)
+    //check to see if we need to run these as MFID 0 or 1 only (standard)
+    if (lc_mfid == 0 || lc_mfid == 1) //lc_mfid == 0
    {

-      // first tg is the active channel
-      j = 0;
-      for (i = 40; i < 52; i++)
+      //check the service options on applicable formats
+      if (lc_format == 0x4A || lc_format == 0x46 || lc_format == 0x45 
+          || lc_format == 0x44 || lc_format == 0x03 || lc_format == 0x00)
+      {
+
+        if (lc_svcopt & 0x80) fprintf (stderr, " Emergency");
+        if (lc_svcopt & 0x40) fprintf (stderr, " Encrypted");
+
+        if (opts->payload == 1) //hide behind payload due to len
        {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = lcinfo[i];
-            }
-          tmpstr[j] = lcinfo[i];
-          j++;
+          if (lc_svcopt & 0x20) fprintf (stderr, " Duplex");
+          if (lc_svcopt & 0x10) fprintf (stderr, " Packet");
+          else fprintf (stderr, " Circuit");
+          if (lc_svcopt & 0x8) fprintf (stderr, " R"); //reserved bit is on
+          fprintf (stderr, " Priority %d", lc_svcopt & 0x7); //call priority
        }
-      tmpstr[12] = 48;
-      tmpstr[13] = 48;
-      tmpstr[14] = 48;
-      tmpstr[15] = 48;
-      tmpstr[16] = 0;
-      talkgroup = strtol (tmpstr, NULL, 2);
-      state->lasttg = talkgroup;
-      if (state->tgcount < 24)
+      }
+
+      if (lc_format == 0x00)
+      {
+        fprintf (stderr, " Group Voice Channel User");
+        uint8_t res    = (uint8_t)ConvertBitIntoBytes(&LCW_bits[24], 7);
+        uint8_t explicit = LCW_bits[24]; //explicit source id required == 1, full SUID on seperate LCW
+        uint16_t group = (uint16_t)ConvertBitIntoBytes(&LCW_bits[32], 16);
+        uint32_t source = (uint32_t)ConvertBitIntoBytes(&LCW_bits[48], 24);
+        fprintf (stderr, " - Group %d Source %d", group, source);
+
+        //don't set this when zero, annoying blink occurs in ncurses
+        if (group != 0) state->lasttg = group;
+        if (source != 0) state->lastsrc = source;
+
+        sprintf (state->call_string[0], "   Group ");
+        if (lc_svcopt & 0x80) strcat (state->call_string[0], " Emergency  ");
+        else if (lc_svcopt & 0x40) strcat (state->call_string[0], " Encrypted  ");
+        else strcat (state->call_string[0], "            ");
+      }
+
+      else if (lc_format == 0x03)
+      {
+        fprintf (stderr, " Unit to Unit Voice Channel User");
+        uint32_t target = (uint32_t)ConvertBitIntoBytes(&LCW_bits[24], 24);
+        uint32_t source = (uint32_t)ConvertBitIntoBytes(&LCW_bits[48], 24);
+        fprintf (stderr, " - Target %d Source %d", target, source);
+
+        //don't set this when zero, annoying blink occurs in ncurses
+        if (target != 0) state->lasttg = target;
+        if (source != 0) state->lastsrc = source;
+
+        sprintf (state->call_string[0], " Private ");
+        if (lc_svcopt & 0x80) strcat (state->call_string[0], " Emergency  ");
+        else if (lc_svcopt & 0x40) strcat (state->call_string[0], " Encrypted  ");
+        else strcat (state->call_string[0], "            ");
+
+      }
+
+      //uses explicit bit?
+      else if (lc_format == 0x42) //is this group only, or group and private?
+      {
+        fprintf (stderr, " Group Voice Channel Update - ");
+        uint16_t channel1 = (uint16_t)ConvertBitIntoBytes(&LCW_bits[8], 16);
+        uint16_t group1   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[24], 16);
+        uint16_t channel2 = (uint16_t)ConvertBitIntoBytes(&LCW_bits[40], 16);
+        uint16_t group2   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[56], 16);
+
+        if (channel1 && group1)
        {
-          state->tgcount = state->tgcount + 1;
-        }
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "tg: %li ", talkgroup);
+          fprintf (stderr, "Ch: %04X TG: %d; ", channel1, group1);
+          sprintf (state->dmr_lrrp_gps[0], "Active Ch: %04X TG: %d;", channel1, group1);
        }

-      if (opts->p25tg == 1)
+        if (channel2 && group2 && group1 != group2)
        {
-          fprintf (stderr, "tg: %li ", talkgroup);
-
-          // the remaining 3 appear to be other active tg's on the system
-          j = 0;
-          for (i = 28; i < 40; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li ", talkgroup);
-          j = 0;
-          for (i = 16; i < 28; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li ", talkgroup);
-          j = 0;
-          for (i = 4; i < 16; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li\n", talkgroup);
+          fprintf (stderr, "Ch: %04X TG: %d; ", channel2, group2);
+          sprintf (state->dmr_lrrp_gps[1], "Active Ch: %04X TG: %d;", channel2, group2);
        }
+
+      }
+
+      else if (lc_format == 0x44)
+      {
+        fprintf (stderr, " Group Voice Channel Update – Explicit");
+        uint16_t group1   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[24], 16);
+        uint16_t channelt = (uint16_t)ConvertBitIntoBytes(&LCW_bits[40], 16);
+        uint16_t channelr = (uint16_t)ConvertBitIntoBytes(&LCW_bits[56], 16);
+        fprintf (stderr, "Ch: %04X TG: %d; ", channelt, group1);
+      }
+
+      else if (lc_format == 0x45)
+      {
+        fprintf (stderr, " Unit to Unit Answer Request");
+      }
+
+      else if (lc_format == 0x46)
+      {
+        fprintf (stderr, " Telephone Interconnect Voice Channel User");
+      }
+
+      else if (lc_format == 0x47)
+      {
+        fprintf (stderr, " Telephone Interconnect Answer Request");
+      }
+
+      else if (lc_format == 0x49)
+      {
+        fprintf (stderr, " Souce ID Extension");
+      }
+
+      else if (lc_format == 0x4A) 
+      {
+        fprintf (stderr, " Unit to Unit Voice Channel User – Extended");
+        uint32_t target = (uint32_t)ConvertBitIntoBytes(&LCW_bits[16], 24);
+        uint32_t suid   = (uint32_t)ConvertBitIntoBytes(&LCW_bits[40], 24);
+        fprintf (stderr, "TGT: %04X SUID: %d; ", target, suid);
+      }
+
+      else if (lc_format == 0x50)
+      {
+        fprintf (stderr, " Group Affiliation Query");
+      }
+
+      else if (lc_format == 0x51)
+      {
+        fprintf (stderr, " Unit Registration Command");
+      }
+
+      else if (lc_format == 0x52) //wonder if anybody uses this if its deleted/obsolete
+      {
+        fprintf (stderr, " Unit Authentication Command - OBSOLETE");
+      }
+
+      else if (lc_format == 0x53) 
+      {
+        fprintf (stderr, " Status Query");
+      }
+
+      else if (lc_format == 0x54) 
+      {
+        fprintf (stderr, " Status Update");
+      }
+
+      else if (lc_format == 0x55) 
+      {
+        fprintf (stderr, " Status Update");
+      }
+
+      else if (lc_format == 0x56) 
+      {
+        fprintf (stderr, " Call Alert");
+      }
+
+      else if (lc_format == 0x57) 
+      {
+        fprintf (stderr, " Extended Function Command");
+      }
+
+      else if (lc_format == 0x58) 
+      {
+        fprintf (stderr, " Channel Identifier Update");
+      }
+
+      else if (lc_format == 0x59) 
+      {
+        fprintf (stderr, " Channel Identifier Update VU");
+      }
+
+      else if (lc_format == 0x5A) 
+      {
+        fprintf (stderr, " Status Update – Source ID Extension Required");
+      }
+
+      else if (lc_format == 0x5C) 
+      {
+        fprintf (stderr, " Extended Function Command – Source ID Extension Required");
+      }
+
+      else if (lc_format == 0x60) 
+      {
+        fprintf (stderr, " System Service Broadcast");
+      }
+
+      else if (lc_format == 0x61) 
+      {
+        fprintf (stderr, " Secondary Control Channel Broadcast");
+      }
+
+      else if (lc_format == 0x62) 
+      {
+        fprintf (stderr, " Adjacent Site Status Broadcast");
+      }
+
+      else if (lc_format == 0x63) 
+      {
+        fprintf (stderr, " RFSS Status Broadcast");
+      }
+
+      else if (lc_format == 0x64) 
+      {
+        fprintf (stderr, " Network Status Broadcast");
+      }
+
+      else if (lc_format == 0x65) 
+      {
+        fprintf (stderr, " Protection Parameter Broadcast - OBSOLETE");
+      }
+
+
+      else if (lc_format == 0x66) 
+      {
+        fprintf (stderr, " Secondary Control Channel Broadcast – Explicit (LCSCBX)");
+      }
+
+      else if (lc_format == 0x67) //explicit
+      {
+        fprintf (stderr, " Adjacent Site Status (LCASBX)");
+        uint8_t lra = (uint8_t)ConvertBitIntoBytes(&LCW_bits[8], 8);
+        uint16_t channelt = (uint16_t)ConvertBitIntoBytes(&LCW_bits[16], 16);
+        uint8_t rfssid = (uint8_t)ConvertBitIntoBytes(&LCW_bits[32], 8);
+        uint8_t siteid = (uint8_t)ConvertBitIntoBytes(&LCW_bits[40], 8);
+        uint16_t channelr = (uint16_t)ConvertBitIntoBytes(&LCW_bits[48], 16);
+        uint8_t cfva = (uint8_t)ConvertBitIntoBytes(&LCW_bits[64], 4);
+        fprintf (stderr, " - RFSS %d Site %d CH %04X", rfssid, siteid, channelt);
+
+        //debug print only
+        // fprintf (stderr, "\n  ");
+        // fprintf (stderr, "  LRA [%02X] RFSS [%03d] SITE [%03d] CHAN-T [%04X] CHAN-R [%02X] CFVA [%X]\n  ", lra, rfssid, siteid, channelt, channelr, cfva);
+        // if (cfva & 0x8) fprintf (stderr, " Conventional");
+        // if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+        // if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+        // else fprintf (stderr, " Last Known");
+        if (cfva & 0x1) fprintf (stderr, "- Connection Active");
+        // process_channel_to_freq (opts, state, channelt);
+        //end debug, way too much for a simple link control line 
+
+
+      }
+
+      else if (lc_format == 0x68) 
+      {
+        fprintf (stderr, " RFSS Status Broadcast – Explicit (LCRSBX)");
+      }
+
+      else if (lc_format == 0x69) 
+      {
+        fprintf (stderr, " Network Status Broadcast – Explicit (LCNSBX)");
+      }
+
+      else if (lc_format == 0x6A) 
+      {
+        fprintf (stderr, " Conventional Fallback");
+      }
+
+      else if (lc_format == 0x6B) 
+      {
+        fprintf (stderr, " Message Update – Source ID Extension Required");
+      }
+
+      //tune back to CC here - save about 1-2 seconds
+      else if (lc_format == 0x4F) //# Call Termination/Cancellation 
+      {
+        fprintf (stderr, " Call Termination/Cancellation");
+        if (opts->p25_trunk == 1 && state->p25_cc_freq != 0 && opts->p25_is_tuned == 1)
+        {
+          //rigctl
+          if (opts->use_rigctl == 1)
+          {
+            state->lasttg = 0;
+            state->lastsrc = 0;
+            state->payload_algid = 0; 
+            state->payload_keyid = 0;
+            // state->payload_miP = 0;
+            //reset some strings
+            sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+            sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+            sprintf (state->dmr_lrrp_gps[0], "%s", ""); //this is used for active ch in p25 trunking
+            sprintf (state->dmr_lrrp_gps[1], "%s", ""); //this is used for active ch in p25 trunking
+            opts->p25_is_tuned = 0;
+            state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+            if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+            SetFreq(opts->rigctl_sockfd, state->p25_cc_freq);        
+          }
+          //rtl_udp
+          else if (opts->audio_in_type == 3)
+          {
+            state->lasttg = 0;
+            state->lastsrc = 0;
+            state->payload_algid = 0;
+            state->payload_keyid = 0;
+            // state->payload_miP = 0;
+            //reset some strings
+            sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+            sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+            sprintf (state->dmr_lrrp_gps[0], "%s", ""); //this is used for active ch in p25 trunking
+            sprintf (state->dmr_lrrp_gps[1], "%s", ""); //this is used for active ch in p25 trunking
+            opts->p25_is_tuned = 0;
+            state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+            rtl_udp_tune (opts, state,  state->p25_cc_freq); 
+          }
+        }
+      }
+
+      else fprintf (stderr, " Unknown Format %02X MFID %02X SVC %02X", lc_format, lc_mfid, lc_svcopt);
    }

-  else if (strcmp (lcformat, "00000000") == 0)
-    {
-      j = 0;
-      if (strcmp (mfid, "10010000") == 0)
-        {
-          for (i = 20; i < 32; i++)
-            {
-              if (state->tgcount < 24)
-                {
-                  state->tg[state->tgcount][j] = lcinfo[i];
-                }
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-        }
-      else
-        {
-          for (i = 16; i < 32; i++)
-            {
-              if (state->tgcount < 24)
-                {
-                  state->tg[state->tgcount][j] = lcinfo[i];
-                }
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-        }
-      tmpstr[16] = 0;
-      talkgroup = strtol (tmpstr, NULL, 2);
-      state->lasttg = talkgroup;
-      if (state->tgcount < 24)
-        {
-          state->tgcount = state->tgcount + 1;
-        }
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "tg: %li ", talkgroup);
-        }
+    //not a duplicate, this one will print if not MFID 0 or 1
+    else fprintf (stderr, " Unknown Format %02X MFID %02X ", lc_format, lc_mfid);
+  }
+
+  //ending line break
+  fprintf (stderr, "\n");

-      j = 0;
-      for (i = 32; i < 56; i++)
-        {
-          tmpstr[j] = lcinfo[i];
-          j++;
-        }
-      tmpstr[24] = 0;
-      source = strtol (tmpstr, NULL, 2);
-      state->lastsrc = source;
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "src: %li emr: %c\n", source, lcinfo[0]);
-        }
-    }
-  else if ((opts->p25tg == 1) && (opts->p25lc == 1))
-    {
-      fprintf (stderr, "\n");
-    }
 }
+
--- a/src/p25p1_hdu.c
+++ b/src/p25p1_hdu.c
@@ -453,93 +453,40 @@ processHDU(dsd_opts* opts, dsd_state* state)
  status = getDibit (opts, state);
  //TODO: Do something useful with the status bits...

-  //if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, and no errors??
-  if (state->carrier == 1)
-  {
-    algidhex = strtol (algid, NULL, 2);
-    kidhex = strtol (kid, NULL, 2);
-
-    state->payload_algid = algidhex;
-    state->payload_keyid = kidhex;
-    //state->payload_mfid = ConvertBitIntoBytes(&mfid[0], 7);
-    //state->payload_mfid = strtol (mfid, NULL, 2);
-
-    mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
-    mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
-    mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
-    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
-    state->payload_miP = (mihex1 << 32) | (mihex2);
-  }
+  algidhex = strtol (algid, NULL, 2);
+  kidhex = strtol (kid, NULL, 2);
+  mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
+  mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
+  mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);

  //set vc counter to 0
  state->p25vc = 0;

-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+  if (irrecoverable_errors == 0)
  {
+
    fprintf (stderr, "%s", KYEL);
-    fprintf (stderr, " HDU  ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX MFID: 0x%02X", algidhex, kidhex, mihex1, mihex2, mihex3, state->payload_mfid);
+    fprintf (stderr, " HDU  ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
    fprintf (stderr, "%s", KNRM);
+    state->payload_algid = algidhex;
+    state->payload_keyid = kidhex;
+    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
+    state->payload_miP = (mihex1 << 32) | (mihex2);
+
+    if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+    {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " ENC");
+      fprintf (stderr, "%s", KNRM);
+    }
+
+    fprintf (stderr, "\n");
  }
-
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
-  {
-    fprintf (stderr, "%s", KRED);
-    fprintf (stderr, " ENC \n");
-    fprintf (stderr, "%s", KNRM);
-  }
-
-  if (opts->p25enc == 1 && opts->payload == 0)
-    {
-      algidhex = strtol (algid, NULL, 2);
-      kidhex = strtol (kid, NULL, 2);
-    }
-  if (opts->p25lc == 1)
-    {
-      fprintf (stderr, "mfid: %s tgid: %s ", mfid, tgid);
-      if (opts->p25tg == 0)
-        {
-          fprintf (stderr, "\n");
-        }
-    }
-
-  j = 0;
-  if (strcmp (mfid, "10010000") == 0)
-    {
-      for (i = 4; i < 16; i++)
-        {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = tgid[i];
-            }
-          tmpstr[j] = tgid[i];
-          j++;
-        }
-      tmpstr[12] = '0';
-      tmpstr[13] = '0';
-      tmpstr[14] = '0';
-      tmpstr[15] = '0';
-    }
  else
-    {
-      for (i = 0; i < 16; i++)
-        {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = tgid[i];
-            }
-          tmpstr[j] = tgid[i];
-          j++;
-        }
-    }
-  tmpstr[16] = 0;
-  talkgroup = strtol (tmpstr, NULL, 2);
-  state->lasttg = talkgroup;
-  if (state->tgcount < 24)
-    {
-      state->tgcount = state->tgcount + 1;
-    }
-  if (opts->p25tg == 1)
-    {
-      fprintf (stderr, "tg: %li\n", talkgroup);
-    }
+  {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " HDU FEC ERR \n");
+      fprintf (stderr, "%s", KNRM);
+  }
+  
 }
--- a/src/p25p1_ldu1.c
+++ b/src/p25p1_ldu1.c
@@ -324,15 +324,53 @@ processLDU1 (dsd_opts* opts, dsd_state* state)
  lcinfo[54]  = hex_data[ 0][4] + '0';
  lcinfo[55]  = hex_data[ 0][5] + '0';

-  unsigned long long int lcinfohex = 0;
-  if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, otherwise, garbage values may be collected
-  {
-    state->payload_mfid = strtol (mfid, NULL, 2);
+  int j;
+  uint8_t LCW_bytes[9];
+  uint8_t LCW_bits[72];
+  memset (LCW_bytes, 0, sizeof(LCW_bytes));
+  memset (LCW_bits, 0, sizeof(LCW_bits));

-    //state->payload_mfid = ConvertBitIntoBytes(&mfid[0], 7);
-    lcinfohex = ConvertBitIntoBytes(&lcinfo[0], 55);
-    //fprintf (stderr, " LDU1 LCINFO %16llX \n", lcinfohex);
+  //load array above into byte form first
+  LCW_bytes[0] = (uint8_t) ConvertBitIntoBytes(&lcformat[0], 8);
+  LCW_bytes[1] = (uint8_t) ConvertBitIntoBytes(&mfid[0], 8);
+  for (i = 0; i < 7; i++) LCW_bytes[i+2] = (uint8_t) ConvertBitIntoBytes(&lcinfo[i*8], 8);
+
+  //load as bit array next (easier to process data in bit form)
+  for(i = 0, j = 0; i < 9; i++, j+=8)
+  {
+    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    LCW_bits[j + 1] = (LCW_bytes[i] >> 6) & 0x01;
+    LCW_bits[j + 2] = (LCW_bytes[i] >> 5) & 0x01;
+    LCW_bits[j + 3] = (LCW_bytes[i] >> 4) & 0x01;
+    LCW_bits[j + 4] = (LCW_bytes[i] >> 3) & 0x01;
+    LCW_bits[j + 5] = (LCW_bytes[i] >> 2) & 0x01;
+    LCW_bits[j + 6] = (LCW_bytes[i] >> 1) & 0x01;
+    LCW_bits[j + 7] = (LCW_bytes[i] >> 0) & 0x01;
+  }
+ 
+  //send to new P25 LCW function
+  if (irrecoverable_errors == 0)
+  {
+    fprintf (stderr, "%s", KYEL);
+    p25_lcw (opts, state, LCW_bits, 0);
+    fprintf (stderr, "%s", KNRM);
+  }
+  else
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW FEC ERR ");
+    fprintf (stderr, "%s\n", KNRM);
  }

-  processP25lcw (opts, state, lcformat, mfid, lcinfo);
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, " P25 LCW Payload ");
+    for (i = 0; i < 9; i++)
+    {
+      fprintf (stderr, "[%02X]", LCW_bytes[i]);
+    }
+    
+    fprintf (stderr, "%s\n", KNRM);
+  }
 }
--- a/src/p25p1_ldu2.c
+++ b/src/p25p1_ldu2.c
@@ -357,37 +357,37 @@ processLDU2 (dsd_opts * opts, dsd_state * state)
  kid[14]  = hex_data[ 0][4] + '0';
  kid[15]  = hex_data[ 0][5] + '0';

+  algidhex = strtol (algid, NULL, 2);
+  kidhex = strtol (kid, NULL, 2);
+  mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
+  mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
+  mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);

-  //if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, and no errors??
-  if (state->carrier == 1)
-  {
-
-    algidhex = strtol (algid, NULL, 2);
-    kidhex = strtol (kid, NULL, 2);
-
-    state->payload_algid = algidhex;
-    state->payload_keyid = kidhex;
-
-    mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
-    mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
-    mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
-    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
-    state->payload_miP = (mihex1 << 32) | (mihex2);
-
-  }
-
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+  if (irrecoverable_errors == 0)
  {
    fprintf (stderr, "%s", KYEL);
    fprintf (stderr, " LDU2 ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
    fprintf (stderr, "%s", KNRM);
-  }

-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+    state->payload_algid = algidhex;
+    state->payload_keyid = kidhex;
+    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
+    state->payload_miP = (mihex1 << 32) | (mihex2);
+
+    if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+    {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " ENC");
+      fprintf (stderr, "%s", KNRM);
+    }
+
+    fprintf (stderr, "\n");
+  }
+  else
  {
-    fprintf (stderr, "%s", KRED);
-    fprintf (stderr, " ENC \n");
-    fprintf (stderr, "%s", KNRM);
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " LDU2 FEC ERR \n");
+      fprintf (stderr, "%s", KNRM);
  }

 }
--- a/src/p25p1_mdpu.c
+++ b/src/p25p1_mdpu.c
@@ -0,0 +1,463 @@
+/*-------------------------------------------------------------------------------
+ * p25p1_mpdu.c
+ * P25p1 Multi Block PDU and Multi Block Trunking
+ *
+ * LWVMOBILE
+ * 2023-03 DSD-FME Florida Man Edition
+ *-----------------------------------------------------------------------------*/
+
+#include "dsd.h"
+
+static uint32_t crc32mbf(uint8_t buf[], int len)
+{	
+  uint32_t g = 0x04c11db7;
+  uint64_t crc = 0;
+  for (int i = 0; i < len; i++)
+  {
+    crc <<= 1;
+    int b = ( buf [i / 8] >> (7 - (i % 8)) ) & 1;
+    if (((crc >> 32) ^ b) & 1) crc ^= g;
+  }
+  crc = (crc & 0xffffffff) ^ 0xffffffff;
+  return crc;
+}
+
+void processMPDU(dsd_opts * opts, dsd_state * state)
+{
+  
+  int tsbkbit[196]; //tsbk bit array, 196 trellis encoded bits
+  int tsbk_dibit[98];
+
+  memset (tsbkbit, 0, sizeof(tsbkbit));
+  memset (tsbk_dibit, 0, sizeof(tsbk_dibit));
+
+  int dibit = 0;
+
+  uint8_t tsbk_byte[12]; //12 byte return from bd_bridge (block_deinterleave)
+  memset (tsbk_byte, 0, sizeof(tsbk_byte));
+
+  unsigned long long int PDU[24];
+  memset (PDU, 0, sizeof(PDU));
+
+  int tsbk_decoded_bits[190]; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+  memset (tsbk_decoded_bits, 0, sizeof(tsbk_decoded_bits));
+
+  uint8_t mpdu_decoded_bits[288];
+  memset (mpdu_decoded_bits, 0, sizeof(mpdu_decoded_bits));
+
+  uint8_t mpdu_crc_bits[196]; 
+  memset (mpdu_crc_bits, 0, sizeof(mpdu_crc_bits));
+
+  uint8_t mpdu_crc_bytes[24];
+  memset (mpdu_crc_bytes, 0, sizeof(mpdu_crc_bytes));
+
+  int flushing_bits[196]; //for flushing the trellis state machine
+  memset (flushing_bits, 0, sizeof(flushing_bits));
+
+  int i, j, k, b, x, y;
+  int ec[3]; //error value returned from (block_deinterleave)
+  int err[2]; //error value returned from ccrc16 or crc32
+  memset (ec, -2, sizeof(ec));
+  memset (err, -2, sizeof(err));
+
+  int skipdibit = 14; //initial status dibit will occur at 14, then add 36 each time it occurs
+  int protectbit = 0;
+  int MFID = 0xFF; //Manufacturer ID
+
+  uint8_t mpdu_byte[36];
+  memset (mpdu_byte, 0, sizeof(mpdu_byte));
+
+  uint8_t io = 0; 
+  uint8_t fmt = 0;  
+  uint8_t sap = 0; 
+  uint8_t blks = 0; 
+  uint8_t opcode = 0;
+
+  //CRC32
+  uint32_t CRCComputed = 0;
+  uint32_t CRCExtracted = 0;
+
+  //collect three reps of 101 dibits (98 valid dibits with status dibits interlaced)
+  for (j = 0; j < 3; j++)
+  {
+    k = 0;
+    for (i = 0; i < 101; i++)
+    {
+
+      dibit = getDibit(opts, state);
+
+      if (i+(j*101) != skipdibit) //
+      {
+        tsbk_dibit[k] =   dibit;
+        tsbkbit[k*2]   = (dibit >> 1) & 1;
+        tsbkbit[k*2+1] = (dibit & 1);
+        k++;
+      }
+
+      if (i+(j*101) == skipdibit) 
+      {
+        skipdibit += 36; //was set to 35, this was the bug
+      }
+
+    }
+
+    //flushing the trellis state machine
+    if (j == 0)
+    {
+      bd_bridge(flushing_bits, tsbk_byte);
+      //reset tsbk_byte afterwards
+      memset (tsbk_byte, 0, sizeof(tsbk_byte));
+    } 
+
+    //send tsbkbit to block_deinterleave and return tsbk_byte
+    ec[j] = bd_bridge(tsbkbit, tsbk_byte);
+
+    //too many bit manipulations!
+    k = 0;
+    for (i = 0; i < 12; i++)
+    {
+      for (x = 0; x < 8; x++)
+      {
+        tsbk_decoded_bits[k] = ((tsbk_byte[i] << x) & 0x80) >> 7;
+        k++;
+      }
+    }
+
+    //CRC16 on the header
+    if (j == 0) err[0] = crc16_lb_bridge(tsbk_decoded_bits, 80);
+
+    //load into bit array for storage (easier decoding for future PDUs)
+    for (i = 0; i < 96; i++) mpdu_decoded_bits[i+(j*96)] = (uint8_t)tsbk_decoded_bits[i];
+
+    //shuffle corrected bits back into tsbk_byte
+    k = 0;
+    for (i = 0; i < 12; i++)
+    {
+      int byte = 0;
+      for (x = 0; x < 8; x++)
+      {
+        byte = byte << 1;
+        byte = byte | tsbk_decoded_bits[k];
+        k++;
+      }
+      tsbk_byte[i] = byte;
+      mpdu_byte[i+(j*12)] = byte; //add to completed MBF format bytes
+    }
+    
+  }
+
+  io   = (mpdu_byte[0] >> 5) & 0x1;
+  fmt  = mpdu_byte[0] & 0x1F;
+  sap  = mpdu_byte[1] & 0x3F;
+  blks = mpdu_byte[6] & 0x7F;
+  MFID = mpdu_byte[2];
+
+  //group list mode so we can look and see if we need to block tuning any groups, etc
+	char mode[8]; //allow, block, digital, enc, etc
+
+	//if we are using allow/whitelist mode, then write 'B' to mode for block
+	//comparison below will look for an 'A' to write to mode if it is allowed
+	if (opts->trunk_use_allow_list == 1) sprintf (mode, "%s", "B");
+
+  fprintf (stderr, "%s",KGRN);
+  fprintf (stderr, " P25 MBF FMT: %02X SAP: %02X", fmt, sap);
+  fprintf (stderr, " Blocks: %02X MFID: %02X", blks, MFID);
+
+  //trunking blocks
+  if ((sap == 0x3D) && ((fmt == 0x17) || (fmt == 0x15)))
+  {
+    if (fmt == 0x15) fprintf (stderr, " UNC");
+    else fprintf (stderr, " ALT");
+    fprintf (stderr, " MBT"); //find way to convert to vPDU or TSBK format?
+    if (fmt == 0x17) opcode = mpdu_byte[7] & 0x3F; //alt MBT
+    else opcode = mpdu_byte[12] & 0x3F; //unconf MBT
+    fprintf (stderr, " - OP: %02X", opcode);
+  }
+
+  //CRC32 is now working! 
+  for (i = 0; i < 196; i++) mpdu_crc_bits[i] = mpdu_decoded_bits[i+96];
+  for (i = 0; i < 24; i++) mpdu_crc_bytes[i] = mpdu_byte[i+12];
+  if (blks == 1) //blocks to follow is 1
+  {
+    CRCExtracted = (uint32_t)ConvertBitIntoBytes(&mpdu_crc_bits[96-32], 32);
+    CRCComputed  = crc32mbf(mpdu_crc_bytes, 96-32);
+    if (CRCComputed == CRCExtracted) err[1] = 0;
+  }
+  if (blks == 2) //blocks to follow is 2
+  {
+    CRCExtracted = (uint32_t)ConvertBitIntoBytes(&mpdu_crc_bits[192-32], 32);
+    CRCComputed  = crc32mbf(mpdu_crc_bytes, 192-32);
+    if (CRCComputed == CRCExtracted) err[1] = 0;
+  }
+
+  //just going to do a couple for now -- the extended format will not be vPDU compatible :(
+  if (err[0] == 0 && err[1] == 0 && io == 1 && fmt == 0x17) //ALT Format
+  {    
+    //NET_STS_BCST -- TIA-102.AABC-D 6.2.11.2
+    if (opcode == 0x3B)
+    {
+      int lra = mpdu_byte[3];
+      int sysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+      int res_a = mpdu_byte[8];
+      int res_b = mpdu_byte[9];
+      long int wacn = (mpdu_byte[12] << 12) | (mpdu_byte[13] << 4) | (mpdu_byte[14] >> 4);
+      int channelt = (mpdu_byte[15] << 8) | mpdu_byte[16];
+      int channelr = (mpdu_byte[17] << 8) | mpdu_byte[18];
+      int ssc =  mpdu_byte[19];
+      fprintf (stderr, "%s",KYEL);
+      fprintf (stderr, "\n Network Status Broadcast MBT - Extended \n");
+      fprintf (stderr, "  LRA [%02X] WACN [%05lX] SYSID [%03X] NAC [%03llX]\n", lra, wacn, sysid, state->p2_cc);
+      fprintf (stderr, "  CHAN-T [%04X] CHAN-R [%04X]", channelt, channelr);
+      long int ct_freq = process_channel_to_freq(opts, state, channelt);
+      long int cr_freq = process_channel_to_freq(opts, state, channelr);
+      
+      state->p25_cc_freq = ct_freq;
+      state->p25_cc_is_tdma = 0; //flag off for CC tuning purposes when system is qpsk
+
+      //place the cc freq into the list at index 0 if 0 is empty, or not the same, 
+      //so we can hunt for rotating CCs without user LCN list
+      if (state->trunk_lcn_freq[0] == 0 || state->trunk_lcn_freq[0] != state->p25_cc_freq)
+      {
+        state->trunk_lcn_freq[0] = state->p25_cc_freq; 
+      } 
+
+      //only set IF these values aren't already hard set by the user
+      if (state->p2_hardset == 0)
+      {
+        state->p2_wacn = wacn;
+        state->p2_sysid = sysid;
+      } 
+    }
+    //RFSS Status Broadcast - Extended 6.2.15.2
+		else if (opcode == 0x3A) 
+		{
+			int lra = mpdu_byte[3];
+			int lsysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+			int rfssid = mpdu_byte[12];
+			int siteid = mpdu_byte[13];
+			int channelt = (mpdu_byte[14] << 8) | mpdu_byte[15];
+      int channelr = (mpdu_byte[16] << 8) | mpdu_byte[17];
+			int sysclass = mpdu_byte[18];
+      fprintf (stderr, "%s",KYEL);
+			fprintf (stderr, "\n RFSS Status Broadcast MBF - Extended \n");
+			fprintf (stderr, "  LRA [%02X] SYSID [%03X] RFSS ID [%02X] SITE ID [%02X]\n  CHAN-T [%04X] CHAN-R [%02X] SSC [%02X] ", lra, lsysid, rfssid, siteid, channelt, channelr, sysclass);
+			process_channel_to_freq (opts, state, channelt);
+			process_channel_to_freq (opts, state, channelr);
+
+			state->p2_siteid = siteid;
+			state->p2_rfssid = rfssid;
+		}
+
+    //Adjacent Status Broadcast (ADJ_STS_BCST) Extended 6.2.2.2
+    else if (opcode == 0x3C) 
+    {
+      int lra = mpdu_byte[3];
+      int cfva = mpdu_byte[4] >> 4;
+			int lsysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+			int rfssid = mpdu_byte[8];
+			int siteid = mpdu_byte[9];
+			int channelt = (mpdu_byte[12] << 8) | mpdu_byte[13];
+			int channelr = (mpdu_byte[14] << 8) | mpdu_byte[15];
+			int sysclass = mpdu_byte[16];  
+      long int wacn = (mpdu_byte[17] << 12) | (mpdu_byte[18] << 4) | (mpdu_byte[19] >> 4);
+      fprintf (stderr, "%s",KYEL);
+      fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
+      fprintf (stderr, "  LRA [%02X] CFVA [%X] RFSS[%03d] SYSID [%03X] SITE [%03X]\n  CHAN-T [%04X] CHAN-R [%04X] SSC [%02X] WACN [%05lX]\n  ", lra, cfva, rfssid, lsysid, siteid, channelt, channelr, sysclass, wacn);
+      if (cfva & 0x8) fprintf (stderr, " Conventional");
+      if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+      if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+      else fprintf (stderr, " Last Known");
+      if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+      process_channel_to_freq (opts, state, channelt);
+      process_channel_to_freq (opts, state, channelr);
+
+    }
+
+    //Group Voice Channel Grant - Extended 
+    else if (opcode == 0x0) 
+    {
+      int svc = mpdu_byte[8]; //look up what these do!
+			int channelt  = (mpdu_byte[14] << 8) | mpdu_byte[15];
+			int channelr  = (mpdu_byte[16] << 8) | mpdu_byte[17];
+      long int source = (mpdu_byte[3] << 16) |(mpdu_byte[4] << 8) | mpdu_byte[5];
+			int group = (mpdu_byte[18] << 8) | mpdu_byte[19];
+			long int freq1 = 0;
+			long int freq2 = 0;
+      fprintf (stderr, "%s",KYEL);
+			fprintf (stderr, "\n Group Voice Channel Grant Update - Extended");
+			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc, channelt, channelr, group, group);
+			freq1 = process_channel_to_freq (opts, state, channelt);
+			freq2 = process_channel_to_freq (opts, state, channelr);
+
+      //add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[0], "Active Ch: %04X TG: %d", channelt, group);
+
+      for (int i = 0; i < state->group_tally; i++)
+      {
+        if (state->group_array[i].groupNumber == group)
+        {
+          fprintf (stderr, " [%s]", state->group_array[i].groupName);
+          strcpy (mode, state->group_array[i].groupMode);
+        }
+      }
+
+      
+			//Skip tuning group calls if group calls are disabled
+			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
+
+			//tune if tuning available
+			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
+  		{
+				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
+    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
+    		{
+					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					if (opts->mod_qpsk == 1)
+					{
+						int spacing = state->p25_chan_spac[channelt >> 12];
+						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						{
+							state->samplesPerSymbol = 8;
+							state->symbolCenter = 3;
+						}	
+					}
+					//rigctl
+          if (opts->use_rigctl == 1)
+					{
+						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+      			SetFreq(opts->rigctl_sockfd, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+					}
+					//rtl_udp
+					else if (opts->audio_in_type == 3)
+					{
+						rtl_udp_tune (opts, state, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1;
+					}
+    		}    
+  		}
+    }
+
+    //Unit to Unit Voice Channel Grant - Extended
+    else if (opcode == 0x6) 
+    {
+      //I'm not doing EVERY element of this, just enough for tuning!
+      int svc = mpdu_byte[8]; //look up what these do!
+			int channelt  = (mpdu_byte[22] << 8) | mpdu_byte[23];
+			int channelr  = (mpdu_byte[24] << 8) | mpdu_byte[25]; //optional!
+      //using source and target address, not source and target id (is this correct?)
+      long int source = (mpdu_byte[3] << 16) |(mpdu_byte[4] << 8) | mpdu_byte[5];
+			long int target = (mpdu_byte[19] << 16) |(mpdu_byte[20] << 8) | mpdu_byte[21];
+			long int freq1 = 0;
+			long int freq2 = 0;
+      fprintf (stderr, "%s",KYEL);
+			fprintf (stderr, "\n Unit to Unit Voice Channel Grant Update - Extended");
+			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Source [%ld][%04lX] Target [%ld][%04lX]", svc, channelt, channelr, source, source, target, target);
+			freq1 = process_channel_to_freq (opts, state, channelt);
+			freq2 = process_channel_to_freq (opts, state, channelr); //optional!
+
+      //add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[0], "Active Ch: %04X TGT: %ld;", channelt, target);
+
+      for (int i = 0; i < state->group_tally; i++)
+      {
+        if (state->group_array[i].groupNumber == target)
+        {
+          fprintf (stderr, " [%s]", state->group_array[i].groupName);
+          strcpy (mode, state->group_array[i].groupMode);
+        }
+      }
+
+      
+			//Skip tuning private calls if group calls are disabled
+			if (opts->trunk_tune_private_calls == 0) goto SKIPCALL;
+
+			//tune if tuning available
+			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
+  		{
+				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
+    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
+    		{
+					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					if (opts->mod_qpsk == 1)
+					{
+						int spacing = state->p25_chan_spac[channelt >> 12];
+						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						{
+							state->samplesPerSymbol = 8;
+							state->symbolCenter = 3;
+						}	
+					}
+					//rigctl
+          if (opts->use_rigctl == 1)
+					{
+						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+      			SetFreq(opts->rigctl_sockfd, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+					}
+					//rtl_udp
+					else if (opts->audio_in_type == 3)
+					{
+						rtl_udp_tune (opts, state, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1;
+					}
+    		}    
+  		}
+    }
+
+    else
+    {
+      //convert mpdu_byte to vPDU format and get indication of what the message was
+      PDU[0] = 0x0C; //P25p1 MB Duid 0x0C
+      PDU[1] = opcode;
+      PDU[2] = MFID;
+      PDU[1] = PDU[1] ^ 0xC0; //flip bits to make it compatible with MAC_PDUs explicit format
+
+      //without any extra bytes filled in, we can atleast see what the MBT is supposed to be
+      //Hopefully, no 0 value things will cause issues -- call grants, iden_up, etc!
+      // fprintf (stderr, "%s",KYEL);
+      // process_MAC_VPDU(opts, state, 0, PDU);
+      // fprintf (stderr, "%s",KNRM);
+    }
+  }
+
+  SKIPCALL: ; //do nothing
+
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, "\n P25 MBF Payload \n  ");
+    for (i = 0; i < 36; i++)
+    {
+      fprintf (stderr, "[%02X]", mpdu_byte[i]);
+      if (i == 11 || i == 23) fprintf (stderr, "\n  ");
+
+    }
+    fprintf (stderr, " CRC EXT %08X CMP %08X", CRCExtracted, CRCComputed);
+    fprintf (stderr, "%s ", KNRM);
+    fprintf (stderr, "\n "); 
+
+    //Header 
+    if (err[0] != 0) 
+    {
+      fprintf (stderr, "%s",KRED);
+      fprintf (stderr, " (HDR CRC16 ERR)");
+      fprintf (stderr, "%s",KCYN);
+    }
+    //Completed MBF 
+    if (err[1] != 0) 
+    {
+      fprintf (stderr, "%s",KRED);
+      fprintf (stderr, " (MBF CRC32 ERR)");
+      fprintf (stderr, "%s",KCYN);
+    }
+
+  }
+
+  fprintf (stderr, "%s ", KNRM);
+  fprintf (stderr, "\n"); 
+}
--- a/src/p25p1_tdu.c
+++ b/src/p25p1_tdu.c
@@ -33,4 +33,8 @@ processTDU (dsd_opts* opts, dsd_state* state)
        status = getDibit (opts, state) + '0';
        // TODO: do something useful with the status bits...
    }
+    
+    //reset some strings -- since its a tdu, blank out any call strings, only want during actual call
+    sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+    sprintf (state->call_string[1], "%s", "                     "); //21 spaces
 }
--- a/src/p25p1_tdulc.c
+++ b/src/p25p1_tdulc.c
@@ -390,11 +390,60 @@ processTDULC (dsd_opts* opts, dsd_state* state)
  lcinfo[53]  = dodeca_data[0][ 9] + '0';
  lcinfo[54]  = dodeca_data[0][10] + '0';
  lcinfo[55]  = dodeca_data[0][11] + '0';
-  /*
-  if (state->carrier == 1) //only update when carrier is present, otherwise, garbage values may be collected
+
+  int j;
+  uint8_t LCW_bytes[9];
+  uint8_t LCW_bits[72];
+  memset (LCW_bytes, 0, sizeof(LCW_bytes));
+  memset (LCW_bits, 0, sizeof(LCW_bits));
+
+  //load array above into byte form first
+  LCW_bytes[0] = (uint8_t) ConvertBitIntoBytes(&lcformat[0], 8);
+  LCW_bytes[1] = (uint8_t) ConvertBitIntoBytes(&mfid[0], 8);
+  for (i = 0; i < 7; i++) LCW_bytes[i+2] = (uint8_t) ConvertBitIntoBytes(&lcinfo[i*8], 8);
+
+  //load as bit array next (easier to process data in bit form)
+  for(i = 0, j = 0; i < 9; i++, j+=8)
  {
-    state->payload_mfid = strtol (mfid, NULL, 2); //wonder if this is accurate info or not
+    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    LCW_bits[j + 1] = (LCW_bytes[i] >> 6) & 0x01;
+    LCW_bits[j + 2] = (LCW_bytes[i] >> 5) & 0x01;
+    LCW_bits[j + 3] = (LCW_bytes[i] >> 4) & 0x01;
+    LCW_bits[j + 4] = (LCW_bytes[i] >> 3) & 0x01;
+    LCW_bits[j + 5] = (LCW_bytes[i] >> 2) & 0x01;
+    LCW_bits[j + 6] = (LCW_bytes[i] >> 1) & 0x01;
+    LCW_bits[j + 7] = (LCW_bytes[i] >> 0) & 0x01;
  }
-  */
-  processP25lcw (opts, state, lcformat, mfid, lcinfo);
+ 
+  //send to new P25 LCW function
+  if (irrecoverable_errors == 0)
+  {
+    fprintf (stderr, "%s", KYEL);
+    p25_lcw (opts, state, LCW_bits, 0);
+    fprintf (stderr, "%s", KNRM);
+  }
+  else
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW FEC ERR ");
+    fprintf (stderr, "%s\n", KNRM);
+  }
+
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, " P25 LCW Payload ");
+    for (i = 0; i < 9; i++)
+    {
+      fprintf (stderr, "[%02X]", LCW_bytes[i]);
+    }
+    
+    
+    fprintf (stderr, "%s\n", KNRM);
+  }
+
+  //reset some strings -- since its a tdu, blank out any call strings, only want during actual call
+  sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+
 }
--- a/src/p25p1_tsbk.c
+++ b/src/p25p1_tsbk.c
@@ -8,82 +8,29 @@

 #include "dsd.h"

-int block_convolution (int payload[196], uint8_t decoded[12])
-{
-  int ec = -1; //initialize error value
-
-  uint8_t deinterleaved_bits[196];
-  uint8_t trellis_bytes[12];
-  uint8_t m_data[14];
-  uint8_t temp[210]; //temp bit position buffer for convolution
-
-  //initialize our deinterleaved bits and bytes with zeroes
-  for (int i = 0; i < 196; i++) deinterleaved_bits[i] = 0;
-  for (int i = 0; i < 210; i++) temp[i] = 0;
-  for (int i = 0; i < 12; i++)  trellis_bytes[i] = 0;
-  for (int i = 0; i < 14; i++)  m_data[i] = 0;
-
-  //convolution decoder 
-  uint8_t s0;
-  uint8_t s1;
-
-  //initialize our decoded byte buffer with zeroes
-  for (int i = 0; i < 12; i++) decoded[i] = 0;
-
-  static const uint16_t deinterleave_tsbk[] = {
-  0,  1,  2,  3,  52, 53, 54, 55, 100,101,102,103, 148,149,150,151,
-  4,  5,  6,  7,  56, 57, 58, 59, 104,105,106,107, 152,153,154,155,
-  8,  9, 10, 11,  60, 61, 62, 63, 108,109,110,111, 156,157,158,159,
-  12, 13, 14, 15,  64, 65, 66, 67, 112,113,114,115, 160,161,162,163,
-  16, 17, 18, 19,  68, 69, 70, 71, 116,117,118,119, 164,165,166,167,
-  20, 21, 22, 23,  72, 73, 74, 75, 120,121,122,123, 168,169,170,171,
-  24, 25, 26, 27,  76, 77, 78, 79, 124,125,126,127, 172,173,174,175,
-  28, 29, 30, 31,  80, 81, 82, 83, 128,129,130,131, 176,177,178,179,
-  32, 33, 34, 35,  84, 85, 86, 87, 132,133,134,135, 180,181,182,183,
-  36, 37, 38, 39,  88, 89, 90, 91, 136,137,138,139, 184,185,186,187,
-  40, 41, 42, 43,  92, 93, 94, 95, 140,141,142,143, 188,189,190,191,
-  44, 45, 46, 47,  96, 97, 98, 99, 144,145,146,147, 192,193,194,195,
-  48, 49, 50, 51 };
-
-  //get the deinterleaved bits
-  for (int i = 0; i < 196; i++) deinterleaved_bits[deinterleave_tsbk[i]] = payload[i];
-
-  //shift into proper position for the convolutional decoder
-  for (int i = 0; i < 196; i++) temp[i] = deinterleaved_bits[i] << 1; 
-
-  CNXDNConvolution_start();
-  for (int i = 0U; i < 98U; i++) //102U
-  {
-    s0 = temp[(2*i)];
-    s1 = temp[(2*i)+1];
-
-    CNXDNConvolution_decode(s0, s1);
-  }
-
-  CNXDNConvolution_chainback(m_data, 96U); //98U
-
-  //debug print
-  fprintf (stderr, "\n Convolution Chainback - ");
-  for (int i = 0; i < 14; i++) fprintf (stderr, "[%02X]", m_data[i]);
-
-  //transfer m_data to decoded bytes -- when sorted out, can probably send decoded straight to chainback, and save the code
-  // for (int i = 0; i < 12; i++) decoded[i] = m_data[i];
-
-  ec = 0; //unknown if a method exists to returns errors from the convolutional decoder, just rely on CRC check for now
-
-  return ec;
-}
-
 void processTSBK(dsd_opts * opts, dsd_state * state)
 {
  
-  int tsbkbit[196] = {0}; //tsbk bit array, 196 trellis encoded bits
-  int tsbk_dibit[98] = {0};
+  int tsbkbit[196]; //tsbk bit array, 196 trellis encoded bits
+  int tsbk_dibit[98];
+
+  memset (tsbkbit, 0, sizeof(tsbkbit));
+  memset (tsbk_dibit, 0, sizeof(tsbk_dibit));

  int dibit = 0;
-  uint8_t tsbk_byte[12] = {0}; //12 byte return from bd_bridge (block_deinterleave)
-  unsigned long long int PDU[24] = {0}; //24 byte PDU to send to the tsbk_byte vPDU handler, should be same formats (mostly)
-  int tsbk_decoded_bits[190] = {0}; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+
+  uint8_t tsbk_byte[12]; //12 byte return from bd_bridge (block_deinterleave)
+  memset (tsbk_byte, 0, sizeof(tsbk_byte));
+
+  unsigned long long int PDU[24]; //24 byte PDU to send to the tsbk_byte vPDU handler, should be same formats (mostly)
+  memset (PDU, 0, sizeof(PDU));
+
+  int tsbk_decoded_bits[190]; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+  memset (tsbk_decoded_bits, 0, sizeof(tsbk_decoded_bits));
+
+  int flushing_bits[196]; //for flushing the trellis state machine
+  memset (flushing_bits, 0, sizeof(flushing_bits));
+  
  int i, j, k, b, x, y;
  int ec = -2; //error value returned from (block_deinterleave)
  int err = -2; //error value returned from crc16_lb_bridge
@@ -121,8 +68,13 @@ void processTSBK(dsd_opts * opts, dsd_state * state)

    }

-    //test with the nxdn convolutional decoder
-    // ec = block_convolution (tsbkbit, tsbk_byte);
+    //flushing the trellis state machine
+    if (j == 0)
+    {
+      bd_bridge(flushing_bits, tsbk_byte);
+      //reset tsbk_byte afterwards
+      memset (tsbk_byte, 0, sizeof(tsbk_byte));
+    }

    //send tsbkbit to block_deinterleave and return tsbk_byte
    ec = bd_bridge(tsbkbit, tsbk_byte);
@@ -178,7 +130,9 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
    //Don't run NET_STS out of this, or will set wrong NAC/CC //&& PDU[1] != 0x49 && PDU[1] != 0x45
    //0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus) (mfid 90)
    // if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )
-    if ( (MFID < 0x2 || MFID == 0xA4 || MFID == 0x90) && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )  
+    //running with A4 and 90 causing some false positives when sending to vPDU, issuing bad call grants to nowhere!
+    // if ( (MFID < 0x2 || MFID == 0xA4 || MFID == 0x90) && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )  
+    if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B ) 
    {
      fprintf (stderr, "%s",KYEL);
      process_MAC_VPDU(opts, state, 0, PDU);
@@ -188,7 +142,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
    //set our WACN and SYSID here now that we have valid ec and crc/checksum
    else if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B) 
    {
-      long int wacn = (tsbk_byte[3] << 12) | (tsbk_byte[4] << 4) | (tsbk_byte[5] >> 4);;
+      long int wacn = (tsbk_byte[3] << 12) | (tsbk_byte[4] << 4) | (tsbk_byte[5] >> 4);
      int sysid = ((tsbk_byte[5] & 0xF) << 8) | tsbk_byte[6];
      int channel = (tsbk_byte[7] << 8) | tsbk_byte[8];
      fprintf (stderr, "%s",KYEL);
--- a/src/p25p2_vpdu.c
+++ b/src/p25p2_vpdu.c
@@ -84,7 +84,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 	for (int i = 0; i < 2; i++) 
 	{

-		//MFID90 Voice Grants, A3, A4, and A5
+		//MFID90 Voice Grants, A3, A4, and A5 <--I bet A4 here was triggering a phantom call when TSBK sent PDUs here
 		//MFID90 Group Regroup Channel Grant - Implicit
 		if (MAC[1+len_a] == 0xA3 && MAC[2+len_a] == 0x90)
 		{
@@ -96,6 +96,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Group [%d][%04X]", channel, sgroup, sgroup);
 			freq = process_channel_to_freq (opts, state, channel);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X SG: %d;", channel, sgroup);
+
 			for (int i = 0; i < state->group_tally; i++)
      {
        if (state->group_array[i].groupNumber == sgroup)
@@ -114,16 +117,27 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
    		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// //testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channel >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+					
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -164,6 +178,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Group [%d][%04X]", channel, sgroup, sgroup);
 			freq = process_channel_to_freq (opts, state, channel);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X SG: %d", channel, sgroup);
+
 			for (int i = 0; i < state->group_tally; i++)
      {
        if (state->group_array[i].groupNumber == sgroup)
@@ -183,14 +200,24 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
    		{
 					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channel >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
 					
          if (opts->use_rigctl == 1)
@@ -239,6 +266,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  Channel 2 [%04X] Group 2 [%d][%04X]", channel2, group2, group2);
 			freq2 = process_channel_to_freq (opts, state, channel2);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X SG: %d; Ch: %04X SG: %d;", channel1, group1, channel2, group2);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;

@@ -284,15 +314,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
 						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						// if (opts->mod_qpsk == 1) 
+						// {
+						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
+						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						// 	{
+						// 		state->samplesPerSymbol = 8;
+						// 		state->symbolCenter = 3;
+						// 	}	
+						// }
+
+						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
+						if (opts->mod_qpsk == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -343,6 +384,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  SVC [%02X] CHAN [%04X] Group [%d] Source [%d]", svc, channel, group, source);
 			freq = process_channel_to_freq (opts, state, channel);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X TG: %d;", channel, group);
+
 			for (int i = 0; i < state->group_tally; i++)
      {
        if (state->group_array[i].groupNumber == group)
@@ -362,15 +406,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
    		{
 					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channel >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -403,7 +458,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}

 		//Unit-to-Unit Voice Service Channel Grant (UU_V_CH_GRANT), or Grant Update (same format)
-		if (MAC[1+len_a] == 0x44 || MAC[1+len_a] == 0x46)
+		if (MAC[1+len_a] == 0x44 || MAC[1+len_a] == 0x46) //double check these opcodes
 		{
 			int channel = (MAC[2+len_a] << 8) | MAC[3+len_a];
 			int target  = (MAC[4+len_a] << 16) | (MAC[5+len_a] << 8) | MAC[6+len_a];
@@ -415,6 +470,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Source [%d] Target [%d]", channel, source, target);
 			freq = process_channel_to_freq (opts, state, channel);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X TGT: %d;", channel, target);
+
 			//Skip tuning private calls if private calls is disabled
      if (opts->trunk_tune_private_calls == 0) goto SKIPCALL; 

@@ -435,15 +493,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
    		{
 					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channel >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -497,6 +566,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			freq1t = process_channel_to_freq (opts, state, channelt2);
 			freq1r = process_channel_to_freq (opts, state, channelr2);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X TG: %d; Ch: %04X TG: %d;", channelt1, group1, channelt2, group2);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;

@@ -539,14 +611,24 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency
 					{
 						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+						// if (opts->mod_qpsk == 1)
+						// {
+						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
+						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						// 	{
+						// 		state->samplesPerSymbol = 8;
+						// 		state->symbolCenter = 3;
+						// 	}	
+						// }
+
+						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 						if (opts->mod_qpsk == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
 						
 						if (opts->use_rigctl == 1)
@@ -581,7 +663,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}

 		//Group Voice Channel Grant Update Multiple - Implicit
-		if (MAC[1+len_a] == 0x05) //wonder if this is MAC_SIGNAL only? Too long for a TSBK
+		if (MAC[1+len_a] == 0x05)
 		{
 			int so1 = MAC[2+len_a];
 			int channel1  = (MAC[3+len_a] << 8) | MAC[4+len_a];
@@ -604,6 +686,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  Channel 3 [%04X] Group 3 [%d][%04X]", channel3, group3, group3);
 			freq3 = process_channel_to_freq (opts, state, channel3);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X TG: %d; Ch: %04X TG: %d; Ch: %04X TG: %d;", channel1, group1, channel2, group2, channel3, group3);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;

@@ -651,15 +736,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
 						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						// if (opts->mod_qpsk == 1) 
+						// {
+						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
+						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						// 	{
+						// 		state->samplesPerSymbol = 8;
+						// 		state->symbolCenter = 3;
+						// 	}	
+						// }
+
+						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
+						if (opts->mod_qpsk == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -710,6 +806,9 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  Channel 2 [%04X] Group 2 [%d][%04X]", channel2, group2, group2);
 			freq2 = process_channel_to_freq (opts, state, channel2);

+			//add active channel to string for ncurses display
+			sprintf (state->dmr_lrrp_gps[slot], "Active Ch: %04X TG: %d; Ch: %04X TG: %d;", channel1, group1, channel2, group2);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;

@@ -753,15 +852,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
 						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						// if (opts->mod_qpsk == 1) 
+						// {
+						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
+						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						// 	{
+						// 		state->samplesPerSymbol = 8;
+						// 		state->symbolCenter = 3;
+						// 	}	
+						// }
+
+						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
+						if (opts->mod_qpsk == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -810,11 +920,13 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc, channelt, channelr, group, group);
 			freq1 = process_channel_to_freq (opts, state, channelt);
 			freq2 = process_channel_to_freq (opts, state, channelr);
-			if (slot == 0)
-			{
-				state->lasttg = group;
-			}
-			else state->lasttgR = group;
+
+			//don't set the tg here, one multiple grant updates, will mess up the TG value on current call
+			// if (slot == 0)
+			// {
+			// 	state->lasttg = group;
+			// }
+			// else state->lasttgR = group;

 			for (int i = 0; i < state->group_tally; i++)
      {
@@ -835,15 +947,26 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
    		{
 					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channelt >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						int spacing = state->p25_chan_spac[channelt >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channelt >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -999,18 +1122,31 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon

 		}

-		//identifier update VHF/UHF
-		if (MAC[1+len_a] == 0x74)
+		//identifier update VHF/UHF 
+		if (MAC[1+len_a] == 0x74) 
 		{
 			state->p25_chan_iden = MAC[2+len_a] >> 4;
 			int iden = state->p25_chan_iden;
-
-			state->p25_chan_type[iden] = 1;
 			int bw_vu = (MAC[2+len_a] & 0xF);
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
 			state->p25_base_freq[iden] = (MAC[6+len_a] << 24) | (MAC[7+len_a] << 16) | (MAC[8+len_a] << 8) | (MAC[9+len_a] << 0);

+			//this is causing more issues -- need a different way to check on this
+			// if (state->p25_chan_spac[iden] == 0x64) //tdma
+			// {
+			// 	state->p25_chan_type[iden] = 4; //
+			// 	state->p25_chan_tdma[iden] = 1; //
+			// }
+			// else //fdma
+			// {
+			// 	state->p25_chan_type[iden] = 1; //
+			// 	state->p25_chan_tdma[iden] = 0; //
+			// }
+
+			state->p25_chan_type[iden] = 1; //set as old values for now
+			state->p25_chan_tdma[iden] = 0; //set as old values for now
+
 			fprintf (stderr, "\n Identifier Update UHF/VHF\n");
 			fprintf (stderr, "  Channel Identifier [%01X] BW [%01X] Transmit Offset [%04X]\n  Channel Spacing [%03X] Base Frequency [%08lX] [%09ld]",
 			                    state->p25_chan_iden, bw_vu, state->p25_trans_off[iden], state->p25_chan_spac[iden], state->p25_base_freq[iden], state->p25_base_freq[iden] * 5);
@@ -1023,6 +1159,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int iden = state->p25_chan_iden;

 			state->p25_chan_type[iden] = 1;
+			state->p25_chan_tdma[iden] = 0;
 			int bw = ((MAC[2+len_a] & 0xF) << 5) | ((MAC[3+len_a] & 0xF8) >> 2);
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
@@ -1038,6 +1175,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		{
 			state->p25_chan_iden = MAC[2+len_a] >> 4;
 			int iden = state->p25_chan_iden;
+			state->p25_chan_tdma[iden] = 1;
 			state->p25_chan_type[iden] = MAC[2+len_a] & 0xF;
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
@@ -1053,6 +1191,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		{
 			state->p25_chan_iden = MAC[3+len_a] >> 4;
 			int iden = state->p25_chan_iden;
+			state->p25_chan_tdma[iden] = 1;
 			state->p25_chan_type[iden] = MAC[3+len_a] & 0xF;
 			state->p25_trans_off[iden] = (MAC[4+len_a] << 6) | (MAC[5+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[5+len_a] & 0x3) << 8) | MAC[6+len_a];
@@ -1223,7 +1362,25 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int src = (MAC[5+len_a] << 16) | (MAC[6+len_a] << 8) | MAC[7+len_a];

 			fprintf (stderr, "\n VCH %d - TG %d SRC %d ", slot, gr, src);
-			fprintf (stderr, "Group Voice");
+
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+			if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+			if (opts->payload == 1) //hide behind payload due to len
+			{
+				if (svc & 0x20) fprintf (stderr, " Duplex");
+				if (svc & 0x10) fprintf (stderr, " Packet");
+				else fprintf (stderr, " Circuit");
+				if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+				fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+			}
+
+			fprintf (stderr, " Group Voice");
+
+			sprintf (state->call_string[slot], "   Group ");
+			if (svc & 0x80) strcat (state->call_string[slot], " Emergency  ");
+			else if (svc & 0x40) strcat (state->call_string[slot], " Encrypted  ");
+			else strcat (state->call_string[slot], "            ");

 			if (slot == 0)
 			{
@@ -1244,7 +1401,25 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int src = (MAC[6+len_a] << 16) | (MAC[7+len_a] << 8) | MAC[8+len_a];

 			fprintf (stderr, "\n VCH %d - TG %d SRC %d ", slot, gr, src);
-			fprintf (stderr, "Unit to Unit Voice");
+
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+			if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+			if (opts->payload == 1) //hide behind payload due to len
+			{
+				if (svc & 0x20) fprintf (stderr, " Duplex");
+				if (svc & 0x10) fprintf (stderr, " Packet");
+				else fprintf (stderr, " Circuit");
+				if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+				fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+			}
+
+			fprintf (stderr, " Unit to Unit Voice");
+
+			sprintf (state->call_string[slot], " Private ");
+			if (svc & 0x80) strcat (state->call_string[slot], " Emergency  ");
+			else if (svc & 0x40) strcat (state->call_string[slot], " Encrypted  ");
+			else strcat (state->call_string[slot], "            ");

 			if (slot == 0)
 			{
@@ -1316,17 +1491,21 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		if (MAC[1+len_a] == 0x7C) 
 		{
 			int lra = MAC[2+len_a];
+			int cfva = MAC[3+len_a] >> 4;
 			int lsysid = ((MAC[3+len_a] & 0xF) << 8) | MAC[4+len_a];
 			int rfssid = MAC[5+len_a];
 			int siteid = MAC[6+len_a];
 			int channelt = (MAC[7+len_a] << 8) | MAC[8+len_a];
 			int sysclass = MAC[9+len_a];
-			if (1 == 1) //state->p2_is_lcch == 1
-			{
-				fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
-				fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] SSC [%02X]", lra, rfssid, lsysid, siteid, channelt, sysclass);
-				process_channel_to_freq (opts, state, channelt);
-			}
+			fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
+			fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] SSC [%02X]\n  ", lra, rfssid, lsysid, siteid, channelt, sysclass);
+			if (cfva & 0x8) fprintf (stderr, " Conventional");
+			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+			else fprintf (stderr, " Last Known");
+			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+			process_channel_to_freq (opts, state, channelt);
+

 		}

@@ -1334,19 +1513,23 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		if (MAC[1+len_a] == 0xFC) 
 		{
 			int lra = MAC[2+len_a];
+			int cfva = MAC[3+len_a] >> 4; 
 			int lsysid = ((MAC[3+len_a] & 0xF) << 8) | MAC[4+len_a];
 			int rfssid = MAC[5+len_a];
 			int siteid = MAC[6+len_a];
 			int channelt = (MAC[7+len_a] << 8) | MAC[8+len_a];
 			int channelr = (MAC[9+len_a] << 8) | MAC[10+len_a];
-			int sysclass = MAC[9+len_a];
-			if (1 == 1) //state->p2_is_lcch == 1
-			{
-				fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
-				fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]", lra, rfssid, lsysid, siteid, channelt, channelr, sysclass);
-				process_channel_to_freq (opts, state, channelt);
-				process_channel_to_freq (opts, state, channelr);
-			}
+			int sysclass = MAC[11+len_a];  //need to re-check this 
+			fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
+			fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]\n  ", lra, rfssid, lsysid, siteid, channelt, channelr, sysclass);
+			if (cfva & 0x8) fprintf (stderr, " Conventional");
+			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+			else fprintf (stderr, " Last Known");
+			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+			process_channel_to_freq (opts, state, channelt);
+			process_channel_to_freq (opts, state, channelr);
+

 		}

--- a/src/x2tdma_voice.c
+++ b/src/x2tdma_voice.c
@@ -630,7 +630,7 @@ processX2TDMAvoice (dsd_opts * opts, dsd_state * state)
    {
      if ((eeei == 0) && (aiei == 0))
        {
-          processP25lcw (opts, state, lcformat, mfid, lcinfo);
+          // processP25lcw (opts, state, lcformat, mfid, lcinfo);
        }
      if (opts->p25enc == 1)
        {
Author	SHA1	Message	Date
lwvmobile	fe1fa79f70	More XPT Tweaks and Notes;	2023-03-09 19:12:57 -05:00
lwvmobile	f2f29f2287	Line Space OCD;	2023-03-09 18:40:36 -05:00
lwvmobile	3181e58b19	Lite to Aero Rebrand;	2023-03-08 02:25:51 -05:00
lwvmobile	6204aec2a5	P25 P1 LCW re-write and updates;	2023-03-08 02:25:29 -05:00
lwvmobile	267180ed0e	NCurses LO Return to CC;	2023-03-08 02:04:56 -05:00
lwvmobile	8d9cbb3720	XPT Trunking Tweak;	2023-03-08 02:04:09 -05:00
lwvmobile	8af6d2e185	P25 P1 QPSK MSIZE/SSIZE Tweak;	2023-03-08 02:03:01 -05:00
lwvmobile	abeb92ff8a	Fix trunk_hangtime lf to f; Ncurses Fixes;	2023-03-06 03:07:27 -05:00
lwvmobile	be47075611	Fix Fast Scanner and NCurses Display (again)	2023-03-05 05:54:23 -05:00
lwvmobile	1640b58ae4	Fix unintended bug in iden_up_vu;	2023-03-04 20:54:52 -05:00
lwvmobile	7a34d531b1	Literature Update	2023-03-04 19:28:58 -05:00
lwvmobile	0af814c72f	P25 TSBK PDU Fix; vPDU PDU Fixes; Scanner Freq Fix	2023-03-04 19:26:44 -05:00
lwvmobile	1477190dea	Fast Scan Ncurses Tweak; Update Literature;	2023-03-03 15:38:39 -05:00
lwvmobile	b0cd1881bb	P25 - P1 MBF Format Addition; TSBK/vPDU Tweaks;	2023-03-03 15:15:42 -05:00
lwvmobile	44ad75ec17	NXDN Trunking Tweaks and Misc Tweaks;	2023-03-02 22:13:49 -05:00
lwvmobile	1ce487dc13	Trunking -- Faster CC Hunt;	2023-03-01 18:32:29 -05:00
lwvmobile	ed9a96fdc8	Experimental -- Fast Scanner Feature;	2023-03-01 17:56:10 -05:00
lwvmobile	c677efda49	P25 - Remove Test Code; NXDN - Remove Freq Calc;	2023-03-01 17:49:52 -05:00
lwvmobile	fea4f97b89	DMR - XPT Tweaks; Data Header Tweaks;	2023-02-25 16:08:55 -05:00
lwvmobile	f2e3834e0a	FID 0x10 - FLCO 0x14, 0x15, 0x16, 0x17, 0x18;	2023-02-24 20:51:47 -05:00
lwvmobile	b8b62ef69a	Disable remaining setmod_bw as safety precaution;	2023-02-24 20:46:33 -05:00
lwvmobile	4a8a4a088a	NXDN Trunking Tweak - Snap Back to CC on Disc;	2023-02-24 18:41:02 -05:00
lwvmobile	9308c5b251	Fix P_Protect CSBK GI indicator;	2023-02-24 18:39:56 -05:00
lwvmobile	cdfe9435d3	Fix NCurses **tera key display when loaded;	2023-02-24 18:39:01 -05:00