Minor firmware changes.

git-svn-id: https://svn.code.sf.net/p/goodfet/code/trunk@1017 12e2690d-a6be-4b82-a7b7-67c4a43b65c8

diff --git a/firmware/apps/chipcon/chipcon.c b/firmware/apps/chipcon/chipcon.c
index 83bc898..7ce22b2 100644 (file)
--- a/firmware/apps/chipcon/chipcon.c
+++ b/firmware/apps/chipcon/chipcon.c
@@ -59,6 +59,7 @@ app_t const chipcon_app = {
 //This could be more accurate.
 //Does it ever need to be?
 #define CCSPEED 3
+//#define CCSPEED 3
 //#define CCDELAY(x) delay(x)
 #define CCDELAY(x) 
 
@@ -99,7 +100,7 @@ void ccdebuginit(){
   //Port output BUT NOT DIRECTION is set at start.
   SPIOUT|=MOSI+SCK+RST;
   
-  //delay(30); //So the beginning is ready for glitching.
+  delay(30); //So the beginning is ready for glitching.
   
   //Two positive debug clock pulses while !RST is low.
   //Take RST low, pulse twice, then high.
@@ -139,11 +140,11 @@ unsigned char cctrans8(unsigned char byte){
     byte <<= 1;
  
     /* half a clock cycle before leading/rising edge */
-    CCDELAY(CCSPEED/2);
+    CCDELAY(CCSPEED>>2);
     SETCLK;
  
     /* half a clock cycle before trailing/falling edge */
-    CCDELAY(CCSPEED/2);
+    CCDELAY(CCSPEED>>2);
  
     /* read MISO on trailing edge */
     byte |= READMISO;
@@ -262,7 +263,7 @@ void cc_handle_fn( uint8_t const app,
     txdata(app,verb,1);
     break;
   case CC_STEP_REPLACE:
-    txdata(app,NOK,0);//TODO add me
+    txdata(app,NOK,0);//Don't add this; it's non-standard.
     break;
   case CC_GET_CHIP_ID:
     cmddataword[0]=cc_get_chip_id();

diff --git a/shellcode/chipcon/cc1110/specan.c b/shellcode/chipcon/cc1110/specan.c
index fb778f7..a1fddcc 100644 (file)
--- a/shellcode/chipcon/cc1110/specan.c
+++ b/shellcode/chipcon/cc1110/specan.c
@@ -18,11 +18,12 @@
  */
 
 #include <cc1110.h>
+#include "cc1110-ext.h"
 #include "ioCCxx10_bitdef.h"
 #include "specan.h"
 
 /* globals */
-__xdata channel_info chan_table[NUM_CHANNELS];
+__xdata __at 0xff00 channel_info chan_table[NUM_CHANNELS];
 u16 center_freq;
 u16 user_freq;
 u8 band;
@@ -46,85 +47,85 @@ void sleepMillis(int ms) {
 
 
 void radio_setup() {
-       /* IF of 457.031 kHz */
-       FSCTRL1 = 0x12;
-       FSCTRL0 = 0x00;
-
-       /* disable 3 highest DVGA settings */
-       AGCCTRL2 |= AGCCTRL2_MAX_DVGA_GAIN;
-
-       /* frequency synthesizer calibration */
-       FSCAL3 = 0xEA;
-       FSCAL2 = 0x2A;
-       FSCAL1 = 0x00;
-       FSCAL0 = 0x1F;
-
-       /* "various test settings" */
-       TEST2 = 0x88;
-       TEST1 = 0x31;
-       TEST0 = 0x09;
-
-       /* no automatic frequency calibration */
-       MCSM0 = 0;
+  /* IF of 457.031 kHz */
+  FSCTRL1 = 0x12;
+  FSCTRL0 = 0x00;
+
+  /* disable 3 highest DVGA settings */
+  AGCCTRL2 |= AGCCTRL2_MAX_DVGA_GAIN;
+
+  /* frequency synthesizer calibration */
+  FSCAL3 = 0xEA;
+  FSCAL2 = 0x2A;
+  FSCAL1 = 0x00;
+  FSCAL0 = 0x1F;
+
+  /* "various test settings" */
+  TEST2 = 0x88;
+  TEST1 = 0x31;
+  TEST0 = 0x09;
+
+  /* no automatic frequency calibration */
+  MCSM0 = 0;
 }
 
 /* set the channel bandwidth */
 void set_filter() {
-       /* channel spacing should fit within 80% of channel filter bandwidth */
-       switch (width) {
-       case NARROW:
-               MDMCFG4 = 0xEC; /* 67.708333 kHz */
-               break;
-       case ULTRAWIDE:
-               MDMCFG4 = 0x0C; /* 812.5 kHz */
-               break;
-       default:
-               MDMCFG4 = 0x6C; /* 270.833333 kHz */
-               break;
-       }
+  /* channel spacing should fit within 80% of channel filter bandwidth */
+  switch (width) {
+  case NARROW:
+    MDMCFG4 = 0xEC; /* 67.708333 kHz */
+    break;
+  case ULTRAWIDE:
+    MDMCFG4 = 0x0C; /* 812.5 kHz */
+    break;
+  default:
+    MDMCFG4 = 0x6C; /* 270.833333 kHz */
+    break;
+  }
 }
 
 /* set the radio frequency in Hz */
 void set_radio_freq(u32 freq) {
-       /* the frequency setting is in units of 396.728515625 Hz */
-       u32 setting = (u32) (freq * .0025206154);
-       FREQ2 = (setting >> 16) & 0xff;
-       FREQ1 = (setting >> 8) & 0xff;
-       FREQ0 = setting & 0xff;
-
-       if ((band == BAND_300 && freq < MID_300) ||
-                       (band == BAND_400 && freq < MID_400) ||
-                       (band == BAND_900 && freq < MID_900))
-               /* select low VCO */
-               FSCAL2 = 0x0A;
-       else
-               /* select high VCO */
-               FSCAL2 = 0x2A;
+  /* the frequency setting is in units of 396.728515625 Hz */
+  u32 setting = (u32) (freq * .0025206154);
+  FREQ2 = (setting >> 16) & 0xff;
+  FREQ1 = (setting >> 8) & 0xff;
+  FREQ0 = setting & 0xff;
+
+  if ((band == BAND_300 && freq < MID_300) ||
+      (band == BAND_400 && freq < MID_400) ||
+      (band == BAND_900 && freq < MID_900))
+    /* select low VCO */
+    FSCAL2 = 0x0A;
+  else
+    /* select high VCO */
+    FSCAL2 = 0x2A;
 }
 
 /* freq in Hz */
 void calibrate_freq(u32 freq, u8 ch) {
-               set_radio_freq(freq);
+  set_radio_freq(freq);
 
-               RFST = RFST_SCAL;
-               RFST = RFST_SRX;
+  RFST = RFST_SCAL;
+  RFST = RFST_SRX;
 
-               /* wait for calibration */
-               sleepMillis(2);
+  /* wait for calibration */
+  sleepMillis(2);
 
-               /* store frequency/calibration settings */
-               chan_table[ch].freq2 = FREQ2;
-               chan_table[ch].freq1 = FREQ1;
-               chan_table[ch].freq0 = FREQ0;
-               chan_table[ch].fscal3 = FSCAL3;
-               chan_table[ch].fscal2 = FSCAL2;
-               chan_table[ch].fscal1 = FSCAL1;
+  /* store frequency/calibration settings */
+  chan_table[ch].freq2 = FREQ2;
+  chan_table[ch].freq1 = FREQ1;
+  chan_table[ch].freq0 = FREQ0;
+  chan_table[ch].fscal3 = FSCAL3;
+  chan_table[ch].fscal2 = FSCAL2;
+  chan_table[ch].fscal1 = FSCAL1;
 
-               /* get initial RSSI measurement */
-               chan_table[ch].ss = (RSSI ^ 0x80);
-               chan_table[ch].max = 0;
+  /* get initial RSSI measurement */
+  chan_table[ch].ss = (RSSI ^ 0x80);
+  chan_table[ch].max = 0;
 
-               RFST = RFST_SIDLE;
+  RFST = RFST_SIDLE;
 }
 
 #define UPPER(a, b, c)  ((((a) - (b) + ((c) / 2)) / (c)) * (c))
@@ -132,272 +133,275 @@ void calibrate_freq(u32 freq, u8 ch) {
 
 /* set the center frequency in MHz */
 u16 set_center_freq(u16 freq) {
-       u8 new_band;
-       u32 spacing;
-       u32 hz;
-       u32 min_hz;
-       u32 max_hz;
-       u8 margin;
-       u8 step;
-       u16 upper_limit;
-       u16 lower_limit;
-       u16 next_up;
-       u16 next_down;
-       u8 next_band_up;
-       u8 next_band_down;
-
-       switch (width) {
-       case NARROW:
-               margin = NARROW_MARGIN;
-               step = NARROW_STEP;
-               spacing = NARROW_SPACING;
-               break;
-       case ULTRAWIDE:
-               margin = ULTRAWIDE_MARGIN;
-               step = ULTRAWIDE_STEP;
-               spacing = ULTRAWIDE_SPACING;
-
-               /* nearest 20 MHz step */
-               freq = ((freq + 10) / 20) * 20;
-               break;
-       default:
-               margin = WIDE_MARGIN;
-               step = WIDE_STEP;
-               spacing = WIDE_SPACING;
-
-               /* nearest 5 MHz step */
-               freq = ((freq + 2) / 5) * 5;
-               break;
-       }
-
-       /* handle cases near edges of bands */
-       if (freq > EDGE_900) {
-               new_band = BAND_900;
-               upper_limit = UPPER(MAX_900, margin, step);
-               lower_limit = LOWER(MIN_900, margin, step);
-               next_up = LOWER(MIN_300, margin, step);
-               next_down = UPPER(MAX_400, margin, step);
-               next_band_up = BAND_300;
-               next_band_down = BAND_400;
-       } else if (freq > EDGE_400) {
-               new_band = BAND_400;
-               upper_limit = UPPER(MAX_400, margin, step);
-               lower_limit = LOWER(MIN_400, margin, step);
-               next_up = LOWER(MIN_900, margin, step);
-               next_down = UPPER(MAX_300, margin, step);
-               next_band_up = BAND_900;
-               next_band_down = BAND_300;
-       } else {
-               new_band = BAND_300;
-               upper_limit = UPPER(MAX_300, margin, step);
-               lower_limit = LOWER(MIN_300, margin, step);
-               next_up = LOWER(MIN_400, margin, step);
-               next_down = UPPER(MAX_900, margin, step);
-               next_band_up = BAND_400;
-               next_band_down = BAND_900;
-       }
-
-       if (freq > upper_limit) {
-               freq = upper_limit;
-               if (new_band == band) {
-                       new_band = next_band_up;
-                       freq = next_up;
-               }
-       } else if (freq < lower_limit) {
-               freq = lower_limit;
-               if (new_band == band) {
-                       new_band = next_band_down;
-                       freq = next_down;
-               }
-       }
-
-       band = new_band;
-
-       /* doing everything in Hz from here on */
-       switch (band) {
-       case BAND_400:
-               min_hz = MIN_400 * 1000000;
-               max_hz = MAX_400 * 1000000;
-               break;
-       case BAND_300:
-               min_hz = MIN_300 * 1000000;
-               max_hz = MAX_300 * 1000000;
-               break;
-       default:
-               min_hz = MIN_900 * 1000000;
-               max_hz = MAX_900 * 1000000;
-               break;
-       }
-
-       /* calibrate upper channels */
-       hz = freq * 1000000;
-       max_chan = NUM_CHANNELS / 2;
-       while (hz <= max_hz && max_chan < NUM_CHANNELS) {
-               calibrate_freq(hz, max_chan);
-               hz += spacing;
-               max_chan++;
-       }
-
-       /* calibrate lower channels */
-       hz = freq * 1000000 - spacing;
-       min_chan = NUM_CHANNELS / 2;
-       while (hz >= min_hz && min_chan > 0) {
-               min_chan--;
-               calibrate_freq(hz, min_chan);
-               hz -= spacing;
-       }
-
-       center_freq = freq;
-       max_hold = 0;
-
-       return freq;
+  u8 new_band;
+  u32 spacing;
+  u32 hz;
+  u32 min_hz;
+  u32 max_hz;
+  u8 margin;
+  u8 step;
+  u16 upper_limit;
+  u16 lower_limit;
+  u16 next_up;
+  u16 next_down;
+  u8 next_band_up;
+  u8 next_band_down;
+
+  switch (width) {
+  case NARROW:
+    margin = NARROW_MARGIN;
+    step = NARROW_STEP;
+    spacing = NARROW_SPACING;
+    break;
+  case ULTRAWIDE:
+    margin = ULTRAWIDE_MARGIN;
+    step = ULTRAWIDE_STEP;
+    spacing = ULTRAWIDE_SPACING;
+
+    /* nearest 20 MHz step */
+    freq = ((freq + 10) / 20) * 20;
+    break;
+  default:
+    margin = WIDE_MARGIN;
+    step = WIDE_STEP;
+    spacing = WIDE_SPACING;
+
+    /* nearest 5 MHz step */
+    freq = ((freq + 2) / 5) * 5;
+    break;
+  }
+
+  /* handle cases near edges of bands */
+  if (freq > EDGE_900) {
+    new_band = BAND_900;
+    upper_limit = UPPER(MAX_900, margin, step);
+    lower_limit = LOWER(MIN_900, margin, step);
+    next_up = LOWER(MIN_300, margin, step);
+    next_down = UPPER(MAX_400, margin, step);
+    next_band_up = BAND_300;
+    next_band_down = BAND_400;
+  } else if (freq > EDGE_400) {
+    new_band = BAND_400;
+    upper_limit = UPPER(MAX_400, margin, step);
+    lower_limit = LOWER(MIN_400, margin, step);
+    next_up = LOWER(MIN_900, margin, step);
+    next_down = UPPER(MAX_300, margin, step);
+    next_band_up = BAND_900;
+    next_band_down = BAND_300;
+  } else {
+    new_band = BAND_300;
+    upper_limit = UPPER(MAX_300, margin, step);
+    lower_limit = LOWER(MIN_300, margin, step);
+    next_up = LOWER(MIN_400, margin, step);
+    next_down = UPPER(MAX_900, margin, step);
+    next_band_up = BAND_400;
+    next_band_down = BAND_900;
+  }
+
+  if (freq > upper_limit) {
+    freq = upper_limit;
+    if (new_band == band) {
+      new_band = next_band_up;
+      freq = next_up;
+    }
+  } else if (freq < lower_limit) {
+    freq = lower_limit;
+    if (new_band == band) {
+      new_band = next_band_down;
+      freq = next_down;
+    }
+  }
+
+  band = new_band;
+
+  /* doing everything in Hz from here on */
+  switch (band) {
+  case BAND_400:
+    min_hz = MIN_400 * 1000000;
+    max_hz = MAX_400 * 1000000;
+    break;
+  case BAND_300:
+    min_hz = MIN_300 * 1000000;
+    max_hz = MAX_300 * 1000000;
+    break;
+  default:
+    min_hz = MIN_900 * 1000000;
+    max_hz = MAX_900 * 1000000;
+    break;
+  }
+
+  /* calibrate upper channels */
+  hz = freq * 1000000;
+  max_chan = NUM_CHANNELS / 2;
+  while (hz <= max_hz && max_chan < NUM_CHANNELS) {
+    calibrate_freq(hz, max_chan);
+    hz += spacing;
+    max_chan++;
+  }
+
+  /* calibrate lower channels */
+  hz = freq * 1000000 - spacing;
+  min_chan = NUM_CHANNELS / 2;
+  while (hz >= min_hz && min_chan > 0) {
+    min_chan--;
+    calibrate_freq(hz, min_chan);
+    hz -= spacing;
+  }
+
+  center_freq = freq;
+  max_hold = 0;
+
+  return freq;
 }
 
 /* tune the radio using stored calibration */
 void tune(u8 ch) {
-       FREQ2 = chan_table[ch].freq2;
-       FREQ1 = chan_table[ch].freq1;
-       FREQ0 = chan_table[ch].freq0;
+  FREQ2 = chan_table[ch].freq2;
+  FREQ1 = chan_table[ch].freq1;
+  FREQ0 = chan_table[ch].freq0;
 
-       FSCAL3 = chan_table[ch].fscal3;
-       FSCAL2 = chan_table[ch].fscal2;
-       FSCAL1 = chan_table[ch].fscal1;
+  FSCAL3 = chan_table[ch].fscal3;
+  FSCAL2 = chan_table[ch].fscal2;
+  FSCAL1 = chan_table[ch].fscal1;
 }
 
 void set_width(u8 w) {
-       width = w;
-       set_filter();
-       set_center_freq(center_freq);
+  width = w;
+  set_filter();
+  set_center_freq(center_freq);
 }
 
 void poll_keyboard() {
   /*
-       u8 vstep;
-       u8 hstep;
-
-       vstep = (height == TALL) ? TALL_STEP : SHORT_STEP;
-
-       switch (width) {
-       case NARROW:
-               hstep = NARROW_STEP;
-               break;
-       case ULTRAWIDE:
-               hstep = ULTRAWIDE_STEP;
-               break;
-       default:
-               hstep = WIDE_STEP;
-               break;
-       }
-
-       switch (getkey()) {
-       case 'W':
-               set_width(WIDE);
-               break;
-       case 'N':
-               set_width(NARROW);
-               break;
-       case 'U':
-               set_width(ULTRAWIDE);
-               break;
-        case KMNU:
-               switch (width) {
-               case WIDE:
-                       set_width(NARROW);
-                       break;
-               case NARROW:
-                       set_width(ULTRAWIDE);
-                       break;
-               default:
-                       set_width(WIDE);
-                       break;
-               }
-               break;
-       case 'T':
-               height = TALL;
-               break;
-       case 'S':
-               height = SHORT;
-               break;
-       case KBYE:
-               height = !height;
-               break;
-       case '>':
-               user_freq += hstep;
-               break;
-       case '<':
-               user_freq -= hstep;
-               break;
-       case '^':
-       case 'Q':
-               vscroll = MIN(vscroll + vstep, MAX_VSCROLL);
-               break;
-       case KDWN:
-       case 'A':
-               vscroll = MAX(vscroll - vstep, MIN_VSCROLL);
-               break;
-       case 'M':
-               max_hold = !max_hold;
-               break;
-       case KPWR:
-               sleepy = 1;
-               break;
-       default:
-               break;
-       }
+    u8 vstep;
+    u8 hstep;
+
+    vstep = (height == TALL) ? TALL_STEP : SHORT_STEP;
+
+    switch (width) {
+    case NARROW:
+    hstep = NARROW_STEP;
+    break;
+    case ULTRAWIDE:
+    hstep = ULTRAWIDE_STEP;
+    break;
+    default:
+    hstep = WIDE_STEP;
+    break;
+    }
+
+    switch (getkey()) {
+    case 'W':
+    set_width(WIDE);
+    break;
+    case 'N':
+    set_width(NARROW);
+    break;
+    case 'U':
+    set_width(ULTRAWIDE);
+    break;
+    case KMNU:
+    switch (width) {
+    case WIDE:
+    set_width(NARROW);
+    break;
+    case NARROW:
+    set_width(ULTRAWIDE);
+    break;
+    default:
+    set_width(WIDE);
+    break;
+    }
+    break;
+    case 'T':
+    height = TALL;
+    break;
+    case 'S':
+    height = SHORT;
+    break;
+    case KBYE:
+    height = !height;
+    break;
+    case '>':
+    user_freq += hstep;
+    break;
+    case '<':
+    user_freq -= hstep;
+    break;
+    case '^':
+    case 'Q':
+    vscroll = MIN(vscroll + vstep, MAX_VSCROLL);
+    break;
+    case KDWN:
+    case 'A':
+    vscroll = MAX(vscroll - vstep, MIN_VSCROLL);
+    break;
+    case 'M':
+    max_hold = !max_hold;
+    break;
+    case KPWR:
+    sleepy = 1;
+    break;
+    default:
+    break;
+    }
   */
 }
 
 void main(void) {
-       u8 ch;
-       u16 i;
-
-reset:
-       center_freq = DEFAULT_FREQ;
-       user_freq = DEFAULT_FREQ;
-       band = BAND_900;
-       width = WIDE;
-       max_hold = 0;
-       height = 0;
-       sleepy = 0;
-       vscroll = 0;
-       min_chan = 0;
-       max_chan = NUM_CHANNELS - 1;
+  u8 ch;
+  u16 i;
+  
+ reset:
+  center_freq = DEFAULT_FREQ;
+  user_freq = DEFAULT_FREQ;
+  band = BAND_900;
+  width = WIDE;
+  max_hold = 0;
+  height = 0;
+  sleepy = 0;
+  vscroll = 0;
+  min_chan = 0;
+  max_chan = NUM_CHANNELS - 1;
        
-       //presumed to be done by GoodFET.
-       //xtalClock(); 
-       //setIOPorts();
-       radio_setup();
-       set_width(WIDE);
-
-       while (1) {
-               for (ch = min_chan; ch < max_chan; ch++) {
-                       /* tune radio and start RX */
-                       tune(ch);
-                       RFST = RFST_SRX;
-
-                       /* delay while waiting for RSSI measurement */
-                       sleepMillis(10);
-                       
-                       /* measurement needs a bit more time in narrow mode */
-                       if (width == NARROW)
-                               for (i = 350; i-- ;);
-
-                       /* read RSSI */
-                       chan_table[ch].ss = (RSSI ^ 0x80);
-                       if (max_hold)
-                               chan_table[ch].max = MAX(chan_table[ch].ss,
-                                               chan_table[ch].max);
-                       else
-                               chan_table[ch].max = 0;
-
-                       /* end RX */
-                       RFST = RFST_SIDLE;
-               }
-
-               poll_keyboard();
+  //presumed to be done by GoodFET.
+  //xtalClock(); 
+  //setIOPorts();
+  radio_setup();
+  set_width(WIDE);
+       
+  
 
+  while (1) {
+    for (ch = min_chan; ch < max_chan; ch++) {
+      /* tune radio and start RX */
+      tune(ch);
+      RFST = RFST_SRX;
 
-               if (user_freq != center_freq)
-                       user_freq = set_center_freq(user_freq);
-       }
+      /* delay while waiting for RSSI measurement */
+      sleepMillis(10);
+                       
+      /* measurement needs a bit more time in narrow mode */
+      if (width == NARROW)
+       for (i = 350; i-- ;);
+
+      /* read RSSI */
+      chan_table[ch].ss = (RSSI ^ 0x80);
+      if (max_hold)
+       chan_table[ch].max = MAX(chan_table[ch].ss,
+                                chan_table[ch].max);
+      else
+       chan_table[ch].max = 0;
+
+      /* end RX */
+      RFST = RFST_SIDLE;
+    }
+
+    //poll_keyboard();
+    chan_table[0].ss=0x00;
+    HALT;
+
+    if (user_freq != center_freq)
+      user_freq = set_center_freq(user_freq);
+  }
 }

diff --git a/shellcode/chipcon/cc1110/specan.h b/shellcode/chipcon/cc1110/specan.h
index 5910901..28d6e6b 100644 (file)
--- a/shellcode/chipcon/cc1110/specan.h
+++ b/shellcode/chipcon/cc1110/specan.h
@@ -25,7 +25,8 @@
  * There is one channel per column of the display.  The radio is tuned to one
  * channel at a time and RSSI is displayed for that channel.
  */
-#define NUM_CHANNELS 132
+//#define NUM_CHANNELS 132
+#define NUM_CHANNELS 10
 
 /*
  * wide mode (default): 44 MHz on screen, 333 kHz per channel