]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
Merged with master 54/head
authorMartin Holst Swende <martin@swende.se>
Sat, 31 Jan 2015 17:21:38 +0000 (18:21 +0100)
committerMartin Holst Swende <martin@swende.se>
Sat, 31 Jan 2015 17:21:38 +0000 (18:21 +0100)
1  2 
armsrc/Makefile
armsrc/appmain.c
armsrc/apps.h
armsrc/lfops.c
armsrc/lfsampling.c
client/cmddata.c
client/cmdlf.c
client/graph.h

diff --cc armsrc/Makefile
Simple merge
index 32b7e5924ad5e74edd1cab73ac4fd259feba64af,791ad4f861bcdb64e5003fdfe17087b66cb47502..cb1b9f73fee185ddf706e2e6720a348bb517799d
@@@ -906,13 -912,13 +913,13 @@@ void UsbPacketReceived(uint8_t *packet
                case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K:
  
                        LED_B_ON();
+                       uint8_t *BigBuf = BigBuf_get_addr();
                        for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
                                size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
-                               cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
+                               cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,traceLen,BigBuf+c->arg[0]+i,len);
                        }
                        // Trigger a finish downloading signal with an ACK frame
-                       // We put a 1 in arg[0] to alert the host we're also sending sample_config
-                       cmd_send(CMD_ACK,1,0,0,getSamplingConfig(),sizeof(sample_config));
 -                      cmd_send(CMD_ACK,0,0,traceLen,0,0);
++                      cmd_send(CMD_ACK,1,0,traceLen,getSamplingConfig(),sizeof(sample_config));
                        LED_B_OFF();
                        break;
  
diff --cc armsrc/apps.h
index 89440bfecedd288634b1d1504c62c85e42226c4e,5ef876232ceb2230596e93e7428f8507866ca765..58a2a62196bd0cb2b96fe2259d7e962c8527ec77
@@@ -81,9 -43,11 +43,8 @@@ int AvgAdc(int ch)
  void ToSendStuffBit(int b);
  void ToSendReset(void);
  void ListenReaderField(int limit);
 -void AcquireRawAdcSamples125k(int at134khz);
 -void SnoopLFRawAdcSamples(int divisor, int trigger_threshold);
 -void DoAcquisition125k(int trigger_threshold);
  extern int ToSendMax;
  extern uint8_t ToSend[];
- extern uint32_t BigBuf[];
  
  /// fpga.h
  void FpgaSendCommand(uint16_t cmd, uint16_t v);
diff --cc armsrc/lfops.c
index 43af4eed4d39048359fbab6f8ab6a4631dc7a1a7,7b6fa97a71d51d73231d8251d8b9ff04b5c07be2..479da77204ebc3fc357b5c569afbc3b0aab2f2bc
@@@ -560,13 -645,12 +561,12 @@@ void CmdHIDdemodFSK(int findone, int *h
          WDT_HIT();
          if (ledcontrol) LED_A_ON();
  
 -        DoAcquisition125k_internal(-1,true);
 -        // FSK demodulator
 +              DoAcquisition_default(-1,true);
 +              // FSK demodulator
-               size = HIDdemodFSK(dest, sizeof(BigBuf), &hi2, &hi, &lo);
-         WDT_HIT();
-               if (size>0 && lo>0){
+         size = sizeOfBigBuff;  //variable size will change after demod so re initialize it before use
+               idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo);
+         
+               if (idx>0 && lo>0){
              // final loop, go over previously decoded manchester data and decode into usable tag ID
              // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
              if (hi2 != 0){ //extra large HID tags
@@@ -648,8 -734,8 +650,8 @@@ void CmdEM410xdemod(int findone, int *h
          WDT_HIT();
          if (ledcontrol) LED_A_ON();
  
 -        DoAcquisition125k_internal(-1,true);
 -        size  = BigBuf_max_traceLen();
 +              DoAcquisition_default(-1,true);
-               size  = sizeof(BigBuf);
++              size  = BigBuf_max_traceLen();
          //Dbprintf("DEBUG: Buffer got");
                //askdemod and manchester decode
                errCnt = askmandemod(dest, &size, &clk, &invert);
@@@ -699,10 -787,10 +703,10 @@@ void CmdIOdemodFSK(int findone, int *hi
      while(!BUTTON_PRESS()) {
          WDT_HIT();
          if (ledcontrol) LED_A_ON();
 -        DoAcquisition125k_internal(-1,true);
 -        //fskdemod and get start index
 +              DoAcquisition_default(-1,true);
 +              //fskdemod and get start index
          WDT_HIT();
-         idx = IOdemodFSK(dest,sizeof(BigBuf));
+         idx = IOdemodFSK(dest, BigBuf_max_traceLen());
          if (idx>0){
              //valid tag found
  
index 6314ac7461218e82e74fcf26b54a0c4b1cd7b987,0000000000000000000000000000000000000000..348549ef5e08df2981ff0b2cec2255523e03bbc8
mode 100644,000000..100644
--- /dev/null
@@@ -1,251 -1,0 +1,252 @@@
-       uint8_t *dest = (uint8_t *)BigBuf;
-       int bufsize = BIGBUF_SIZE;
 +//-----------------------------------------------------------------------------
 +// This code is licensed to you under the terms of the GNU GPL, version 2 or,
 +// at your option, any later version. See the LICENSE.txt file for the text of
 +// the license.
 +//-----------------------------------------------------------------------------
 +// Miscellaneous routines for low frequency sampling.
 +//-----------------------------------------------------------------------------
 +
 +#include "proxmark3.h"
 +#include "apps.h"
 +#include "util.h"
 +#include "string.h"
 +
 +#include "lfsampling.h"
 +
 +sample_config config = { 1, 8, 1, 88, 0 } ;
 +
 +void printConfig()
 +{
 +      Dbprintf("Sampling config: ");
 +      Dbprintf("  [q] divisor:           %d ", config.divisor);
 +      Dbprintf("  [b] bps:               %d ", config.bits_per_sample);
 +      Dbprintf("  [d] decimation:        %d ", config.decimation);
 +      Dbprintf("  [a] averaging:         %d ", config.averaging);
 +      Dbprintf("  [t] trigger threshold: %d ", config.trigger_threshold);
 +}
 +
 +
 +/**
 + * Called from the USB-handler to set the sampling configuration
 + * The sampling config is used for std reading and snooping.
 + *
 + * Other functions may read samples and ignore the sampling config,
 + * such as functions to read the UID from a prox tag or similar.
 + *
 + * Values set to '0' implies no change (except for averaging)
 + * @brief setSamplingConfig
 + * @param sc
 + */
 +void setSamplingConfig(sample_config *sc)
 +{
 +      if(sc->divisor != 0) config.divisor = sc->divisor;
 +      if(sc->bits_per_sample!= 0) config.bits_per_sample= sc->bits_per_sample;
 +      if(sc->decimation!= 0) config.decimation= sc->decimation;
 +      if(sc->trigger_threshold != -1) config.trigger_threshold= sc->trigger_threshold;
 +
 +      config.averaging= sc->averaging;
 +      if(config.bits_per_sample > 8)  config.bits_per_sample = 8;
 +      if(config.decimation < 1)       config.decimation = 1;
 +
 +      printConfig();
 +}
 +
 +sample_config* getSamplingConfig()
 +{
 +      return &config;
 +}
 +
 +typedef struct {
 +      uint8_t * buffer;
 +      uint32_t numbits;
 +      uint32_t position;
 +} BitstreamOut;
 +
 +
 +/**
 + * @brief Pushes bit onto the stream
 + * @param stream
 + * @param bit
 + */
 +void pushBit( BitstreamOut* stream, uint8_t bit)
 +{
 +      int bytepos = stream->position >> 3; // divide by 8
 +      int bitpos = stream->position & 7;
 +      *(stream->buffer+bytepos) |= (bit > 0) <<  (7 - bitpos);
 +      stream->position++;
 +      stream->numbits++;
 +}
 +
 +/**
 +* Setup the FPGA to listen for samples. This method downloads the FPGA bitstream
 +* if not already loaded, sets divisor and starts up the antenna.
 +* @param divisor : 1, 88> 255 or negative ==> 134.8 KHz
 +*                                0 or 95 ==> 125 KHz
 +*
 +**/
 +void LFSetupFPGAForADC(int divisor, bool lf_field)
 +{
 +      FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 +      if ( (divisor == 1) || (divisor < 0) || (divisor > 255) )
 +              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
 +      else if (divisor == 0)
 +              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
 +      else
 +              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor);
 +
 +      FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | (lf_field ? FPGA_LF_ADC_READER_FIELD : 0));
 +
 +      // Connect the A/D to the peak-detected low-frequency path.
 +      SetAdcMuxFor(GPIO_MUXSEL_LOPKD);
 +      // Give it a bit of time for the resonant antenna to settle.
 +      SpinDelay(50);
 +      // Now set up the SSC to get the ADC samples that are now streaming at us.
 +      FpgaSetupSsc();
 +}
 +
 +
 +/**
 + * Does the sample acquisition. If threshold is specified, the actual sampling
 + * is not commenced until the threshold has been reached.
 + * This method implements decimation and quantization in order to
 + * be able to provide longer sample traces.
 + * Uses the following global settings:
 + * @param decimation - how much should the signal be decimated. A decimation of N means we keep 1 in N samples, etc.
 + * @param bits_per_sample - bits per sample. Max 8, min 1 bit per sample.
 + * @param averaging If set to true, decimation will use averaging, so that if e.g. decimation is 3, the sample
 + * value that will be used is the average value of the three samples.
 + * @param trigger_threshold - a threshold. The sampling won't commence until this threshold has been reached. Set
 + * to -1 to ignore threshold.
 + * @param silent - is true, now outputs are made. If false, dbprints the status
 + * @return the number of bits occupied by the samples.
 + */
 +
 +uint32_t DoAcquisition(uint8_t decimation, uint32_t bits_per_sample, bool averaging, int trigger_threshold,bool silent)
 +{
 +      //.
++      uint8_t *dest = BigBuf_get_addr();
++    int bufsize = BigBuf_max_traceLen();
++
 +      memset(dest, 0, bufsize);
 +
 +      if(bits_per_sample < 1) bits_per_sample = 1;
 +      if(bits_per_sample > 8) bits_per_sample = 8;
 +
 +      if(decimation < 1) decimation = 1;
 +
 +      // Use a bit stream to handle the output
 +      BitstreamOut data = { dest , 0, 0};
 +      int sample_counter = 0;
 +      uint8_t sample = 0;
 +      //If we want to do averaging
 +      uint32_t sample_sum =0 ;
 +      uint32_t sample_total_numbers =0 ;
 +      uint32_t sample_total_saved =0 ;
 +
 +      while(!BUTTON_PRESS()) {
 +              WDT_HIT();
 +              if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
 +                      AT91C_BASE_SSC->SSC_THR = 0x43;
 +                      LED_D_ON();
 +              }
 +              if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
 +                      sample = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
 +                      LED_D_OFF();
 +                      if (trigger_threshold > 0 && sample < trigger_threshold)
 +                              continue;
 +
 +                      trigger_threshold = 0;
 +                      sample_total_numbers++;
 +
 +                      if(averaging)
 +                      {
 +                              sample_sum += sample;
 +                      }
 +                      //Check decimation
 +                      if(decimation > 1)
 +                      {
 +                              sample_counter++;
 +                              if(sample_counter < decimation) continue;
 +                              sample_counter = 0;
 +                      }
 +                      //Averaging
 +                      if(averaging && decimation > 1) {
 +                              sample = sample_sum / decimation;
 +                              sample_sum =0;
 +                      }
 +                      //Store the sample
 +                      sample_total_saved ++;
 +                      if(bits_per_sample == 8){
 +                              dest[sample_total_saved-1] = sample;
 +                              data.numbits = sample_total_saved << 3;//Get the return value correct
 +                              if(sample_total_saved >= bufsize) break;
 +                      }
 +                      else{
 +                              pushBit(&data, sample & 0x80);
 +                              if(bits_per_sample > 1) pushBit(&data, sample & 0x40);
 +                              if(bits_per_sample > 2) pushBit(&data, sample & 0x20);
 +                              if(bits_per_sample > 3) pushBit(&data, sample & 0x10);
 +                              if(bits_per_sample > 4) pushBit(&data, sample & 0x08);
 +                              if(bits_per_sample > 5) pushBit(&data, sample & 0x04);
 +                              if(bits_per_sample > 6) pushBit(&data, sample & 0x02);
 +                              //Not needed, 8bps is covered above
 +                              //if(bits_per_sample > 7)       pushBit(&data, sample & 0x01);
 +                              if((data.numbits >> 3) +1  >= bufsize) break;
 +                      }
 +              }
 +      }
 +
 +      if(!silent)
 +      {
 +              Dbprintf("Done, saved %d out of %d seen samples at %d bits/sample",sample_total_saved, sample_total_numbers,bits_per_sample);
 +              Dbprintf("buffer samples: %02x %02x %02x %02x %02x %02x %02x %02x ...",
 +                                      dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 +      }
 +      return data.numbits;
 +}
 +/**
 + * @brief Does sample acquisition, ignoring the config values set in the sample_config.
 + * This method is typically used by tag-specific readers who just wants to read the samples
 + * the normal way
 + * @param trigger_threshold
 + * @param silent
 + * @return number of bits sampled
 + */
 +uint32_t DoAcquisition_default(int trigger_threshold, bool silent)
 +{
 +      return DoAcquisition(1,8,0,trigger_threshold,silent);
 +}
 +uint32_t DoAcquisition_config( bool silent)
 +{
 +      return DoAcquisition(config.decimation
 +                                ,config.bits_per_sample
 +                                ,config.averaging
 +                                ,config.trigger_threshold
 +                                ,silent);
 +}
 +
 +uint32_t ReadLF(bool activeField)
 +{
 +      printConfig();
 +      LFSetupFPGAForADC(config.divisor, activeField);
 +      // Now call the acquisition routine
 +      return DoAcquisition_config(false);
 +}
 +
 +/**
 +* Initializes the FPGA for reader-mode (field on), and acquires the samples.
 +* @return number of bits sampled
 +**/
 +uint32_t SampleLF()
 +{
 +      return ReadLF(true);
 +}
 +/**
 +* Initializes the FPGA for snoop-mode (field off), and acquires the samples.
 +* @return number of bits sampled
 +**/
 +
 +uint32_t SnoopLF()
 +{
 +      return ReadLF(false);
 +}
index 8f73b4007de21700047bc3f903372211e092214f,8c91f0e115ce84c7f6e934861e784d5341943215..0ec73cbb79b542406bf1afd00df403ed12d9f349
  #include "cmdmain.h"
  #include "cmddata.h"
  #include "lfdemod.h"
 +#include "usb_cmd.h"
 +
  uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
+ uint8_t g_debugMode;
  int DemodBufferLen;
  static int CmdHelp(const char *Cmd);
  
@@@ -540,44 -560,28 +562,65 @@@ int CmdDec(const char *Cmd
    RepaintGraphWindow();
    return 0;
  }
 +/**
 + * Undecimate - I'd call it 'interpolate', but we'll save that
 + * name until someone does an actual interpolation command, not just
 + * blindly repeating samples
 + * @param Cmd
 + * @return
 + */
 +int CmdUndec(const char *Cmd)
 +{
 +      if(param_getchar(Cmd, 0) == 'h')
 +      {
 +              PrintAndLog("Usage: data undec [factor]");
 +              PrintAndLog("This function performs un-decimation, by repeating each sample N times");
 +              PrintAndLog("Options:        ");
 +              PrintAndLog("       h            This help");
 +              PrintAndLog("       factor       The number of times to repeat each sample.[default:2]");
 +              PrintAndLog("Example: 'data undec 3'");
 +              return 0;
 +      }
 +
 +      uint8_t factor = param_get8ex(Cmd, 0,2, 10);
 +      //We have memory, don't we?
 +      int swap[MAX_GRAPH_TRACE_LEN] = { 0 };
 +      uint32_t g_index = 0 ,s_index = 0;
 +      while(g_index < GraphTraceLen && s_index < MAX_GRAPH_TRACE_LEN)
 +      {
 +              int count = 0;
 +              for(count = 0; count < factor && s_index+count < MAX_GRAPH_TRACE_LEN; count ++)
 +                      swap[s_index+count] = GraphBuffer[g_index];
 +              s_index+=count;
 +      }
 +
 +      memcpy(GraphBuffer,swap, s_index * sizeof(int));
 +      GraphTraceLen = s_index;
 +      RepaintGraphWindow();
 +      return 0;
 +}
  
+ //by marshmellow
+ //shift graph zero up or down based on input + or -
+ int CmdGraphShiftZero(const char *Cmd)
+ {
+   int shift=0;
+   //set options from parameters entered with the command
+   sscanf(Cmd, "%i", &shift);
+   int shiftedVal=0;
+   for(int i = 0; i<GraphTraceLen; i++){
+     shiftedVal=GraphBuffer[i]+shift;
+     if (shiftedVal>127) 
+       shiftedVal=127;
+     else if (shiftedVal<-127) 
+       shiftedVal=-127;
+     GraphBuffer[i]= shiftedVal;
+   }
+   CmdNorm("");
+   return 0;
+ }
  /* Print our clock rate */
  // uses data from graphbuffer
  int CmdDetectClockRate(const char *Cmd)
@@@ -1116,11 -1485,7 +1547,11 @@@ uint8_t getByte(uint8_t bits_per_sample
  
  int CmdSamples(const char *Cmd)
  {
 -      uint8_t got[BIGBUF_SIZE] = {0x00};
 +      //If we get all but the last byte in bigbuf,
 +      // we don't have to worry about remaining trash
 +      // in the last byte in case the bits-per-sample
 +      // does not line up on byte boundaries
-       uint8_t got[40000-1];
++      uint8_t got[BIGBUF_SIZE-1] = { 0 };
  
        int n = strtol(Cmd, NULL, 0);
        if (n == 0)
diff --cc client/cmdlf.c
Simple merge
diff --cc client/graph.h
index 2c448161c522dab6d6dab20c195e61055e8d9a0f,fe35d4f1c858aba645cf322346dfb7ca78487c02..9817d7762d7575714b994927a2bd7e0e2a452400
@@@ -20,9 -20,10 +20,12 @@@ int GetClock(const char *str, int peak
  int GetNRZpskClock(const char *str, int peak, int verbose);
  void setGraphBuf(uint8_t *buff, size_t size);
  
 -#define MAX_GRAPH_TRACE_LEN (1024*128)
+ bool HasGraphData();
+ void DetectHighLowInGraph(int *high, int *low, bool addFuzz); 
 +// Max graph trace len: 40000 (bigbuf) * 8 (at 1 bit per sample)
 +#define MAX_GRAPH_TRACE_LEN (40000 * 8 )
++
  extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];
  extern int GraphTraceLen;
  #endif
Impressum, Datenschutz