Changeset 9743

Show
Ignore:
Timestamp:
10/07/08 22:11:42
Author:
eb
Message:

s/which_dboard/which_side/g etc

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/usrp_basic.cc

    r9742 r9743  
    11/* -*- c++ -*- */ 
    22/* 
    3  * Copyright 2003,2004 Free Software Foundation, Inc. 
     3 * Copyright 2003,2004,2008 Free Software Foundation, Inc. 
    44 *  
    55 * This file is part of GNU Radio 
    …… 
    251251 
    252252bool 
    253 usrp_basic::set_adc_offset (int which, int offset) 
    254 { 
    255   if (which < 0 || which > 3) 
    256     return false; 
    257  
    258   return _write_fpga_reg (FR_ADC_OFFSET_0 + which, offset); 
    259 } 
    260  
    261 bool 
    262 usrp_basic::set_dac_offset (int which, int offset, int offset_pin) 
    263 { 
    264   if (which < 0 || which > 3) 
    265     return false; 
    266  
    267   int which_codec = which >> 1; 
    268   int tx_a = (which & 0x1) == 0; 
     253usrp_basic::set_adc_offset (int which_adc, int offset) 
     254{ 
     255  if (which_adc < 0 || which_adc > 3) 
     256    return false; 
     257 
     258  return _write_fpga_reg (FR_ADC_OFFSET_0 + which_adc, offset); 
     259} 
     260 
     261bool 
     262usrp_basic::set_dac_offset (int which_dac, int offset, int offset_pin) 
     263{ 
     264  if (which_dac < 0 || which_dac > 3) 
     265    return false; 
     266 
     267  int which_codec = which_dac >> 1; 
     268  int tx_a = (which_dac & 0x1) == 0; 
    269269  int lo = ((offset & 0x3) << 6) | (offset_pin & 0x1); 
    270270  int hi = (offset >> 2); 
    …… 
    283283 
    284284bool 
    285 usrp_basic::set_adc_buffer_bypass (int which, bool bypass) 
    286 { 
    287   if (which < 0 || which > 3) 
    288     return false; 
    289  
    290   int codec = which >> 1; 
    291   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B; 
     285usrp_basic::set_adc_buffer_bypass (int which_adc, bool bypass) 
     286{ 
     287  if (which_adc < 0 || which_adc > 3) 
     288    return false; 
     289 
     290  int codec = which_adc >> 1; 
     291  int reg = (which_adc & 1) == 0 ? REG_RX_A : REG_RX_B; 
    292292 
    293293  unsigned char cur_rx; 
    …… 
    303303  if (bypass){ 
    304304    cur_rx |= RX_X_BYPASS_INPUT_BUFFER; 
    305     cur_pwr_dn |= ((which & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B; 
     305    cur_pwr_dn |= ((which_adc & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B; 
    306306  } 
    307307  else { 
    308308    cur_rx &= ~RX_X_BYPASS_INPUT_BUFFER; 
    309     cur_pwr_dn &= ~(((which & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B); 
     309    cur_pwr_dn &= ~(((which_adc & 1) == 0) ? RX_PWR_DN_BUF_A : RX_PWR_DN_BUF_B); 
    310310  } 
    311311 
    …… 
    414414 
    415415bool 
    416 usrp_basic::_set_led (int which, bool on) 
    417 { 
    418   return usrp_set_led (d_udh, which, on); 
     416usrp_basic::_set_led (int which_led, bool on) 
     417{ 
     418  return usrp_set_led (d_udh, which_led, on); 
    419419} 
    420420 
    …… 
    658658 
    659659bool 
    660 usrp_basic_rx::set_pga (int which, double gain) 
    661 { 
    662   if (which < 0 || which > 3) 
     660usrp_basic_rx::set_pga (int which_amp, double gain) 
     661{ 
     662  if (which_amp < 0 || which_amp > 3) 
    663663    return false; 
    664664 
    …… 
    666666  gain = std::min (pga_max (), gain); 
    667667 
    668   int codec = which >> 1; 
    669   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B; 
     668  int codec = which_amp >> 1; 
     669  int reg = (which_amp & 1) == 0 ? REG_RX_A : REG_RX_B; 
    670670 
    671671  // read current value to get input buffer bypass flag. 
    …… 
    681681 
    682682double 
    683 usrp_basic_rx::pga (int which) const 
    684 { 
    685   if (which < 0 || which > 3) 
     683usrp_basic_rx::pga (int which_amp) const 
     684{ 
     685  if (which_amp < 0 || which_amp > 3) 
    686686    return READ_FAILED; 
    687687 
    688   int codec = which >> 1; 
    689   int reg = (which & 1) == 0 ? REG_RX_A : REG_RX_B; 
     688  int codec = which_amp >> 1; 
     689  int reg = (which_amp & 1) == 0 ? REG_RX_A : REG_RX_B; 
    690690  unsigned char v; 
    691691  bool ok = _read_9862 (codec, reg, &v); 
    …… 
    761761 
    762762bool 
    763 usrp_basic_rx::_write_oe (int which_dboard, int value, int mask) 
    764 { 
    765   if (! (0 <= which_dboard && which_dboard <= 1)) 
    766     return false; 
    767  
    768   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)), 
     763usrp_basic_rx::_write_oe (int which_side, int value, int mask) 
     764{ 
     765  if (! (0 <= which_side && which_side <= 1)) 
     766    return false; 
     767 
     768  return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_side)), 
    769769                          (mask << 16) | (value & 0xffff)); 
    770770} 
    771771 
    772772bool 
    773 usrp_basic_rx::write_io (int which_dboard, int value, int mask) 
    774 { 
    775   if (! (0 <= which_dboard && which_dboard <= 1)) 
    776     return false; 
    777  
    778   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)), 
     773usrp_basic_rx::write_io (int which_side, int value, int mask) 
     774{ 
     775  if (! (0 <= which_side && which_side <= 1)) 
     776    return false; 
     777 
     778  return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_side)), 
    779779                          (mask << 16) | (value & 0xffff)); 
    780780} 
    781781 
    782782bool 
    783 usrp_basic_rx::read_io (int which_dboard, int *value) 
    784 { 
    785   if (! (0 <= which_dboard && which_dboard <= 1)) 
     783usrp_basic_rx::read_io (int which_side, int *value) 
     784{ 
     785  if (! (0 <= which_side && which_side <= 1)) 
    786786    return false; 
    787787 
    788788  int t; 
    789   int reg = which_dboard + 1; // FIXME, *very* magic number (fix in serial_io.v) 
     789  int reg = which_side + 1;   // FIXME, *very* magic number (fix in serial_io.v) 
    790790  bool ok = _read_fpga_reg (reg, &t); 
    791791  if (!ok) 
    …… 
    797797 
    798798int 
    799 usrp_basic_rx::read_io (int which_dboard) 
     799usrp_basic_rx::read_io (int which_side) 
    800800{ 
    801801  int   value; 
    802   if (!read_io (which_dboard, &value)) 
     802  if (!read_io (which_side, &value)) 
    803803    return READ_FAILED; 
    804804  return value; 
    …… 
    806806 
    807807bool 
    808 usrp_basic_rx::write_aux_dac (int which_dboard, int which_dac, int value) 
    809 { 
    810   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard), 
     808usrp_basic_rx::write_aux_dac (int which_side, int which_dac, int value) 
     809{ 
     810  return usrp_basic::write_aux_dac (dboard_to_slot (which_side), 
    811811                                    which_dac, value); 
    812812} 
    813813 
    814814bool 
    815 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc, int *value) 
    816 { 
    817   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), 
     815usrp_basic_rx::read_aux_adc (int which_side, int which_adc, int *value) 
     816{ 
     817  return usrp_basic::read_aux_adc (dboard_to_slot (which_side), 
    818818                                   which_adc, value); 
    819819} 
    820820 
    821821int 
    822 usrp_basic_rx::read_aux_adc (int which_dboard, int which_adc) 
    823 { 
    824   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc); 
     822usrp_basic_rx::read_aux_adc (int which_side, int which_adc) 
     823{ 
     824  return usrp_basic::read_aux_adc (dboard_to_slot (which_side), which_adc); 
    825825} 
    826826 
    …… 
    10961096 
    10971097bool 
    1098 usrp_basic_tx::set_pga (int which, double gain) 
    1099 { 
    1100   if (which < 0 || which > 3) 
     1098usrp_basic_tx::set_pga (int which_amp, double gain) 
     1099{ 
     1100  if (which_amp < 0 || which_amp > 3) 
    11011101    return false; 
    11021102 
    …… 
    11041104  gain = std::min (pga_max (), gain); 
    11051105 
    1106   int codec = which >> 1;     // 0 and 1 are same, as are 2 and 3 
     1106  int codec = which_amp >> 1; // 0 and 1 are same, as are 2 and 3 
    11071107 
    11081108  int int_gain = (int) rint ((gain - pga_min ()) / pga_db_per_step()); 
    …… 
    11121112 
    11131113double 
    1114 usrp_basic_tx::pga (int which) const 
    1115 { 
    1116   if (which < 0 || which > 3) 
     1114usrp_basic_tx::pga (int which_amp) const 
     1115{ 
     1116  if (which_amp < 0 || which_amp > 3) 
    11171117    return READ_FAILED; 
    11181118 
    1119   int codec = which >> 1; 
     1119  int codec = which_amp >> 1; 
    11201120  unsigned char v; 
    11211121  bool ok = _read_9862 (codec, REG_TX_PGA, &v); 
    …… 
    11751175 
    11761176bool 
    1177 usrp_basic_tx::_write_oe (int which_dboard, int value, int mask) 
    1178 { 
    1179   if (! (0 <= which_dboard && which_dboard <= 1)) 
    1180     return false; 
    1181  
    1182   return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_dboard)), 
     1177usrp_basic_tx::_write_oe (int which_side, int value, int mask) 
     1178{ 
     1179  if (! (0 <= which_side && which_side <= 1)) 
     1180    return false; 
     1181 
     1182  return _write_fpga_reg (slot_id_to_oe_reg (dboard_to_slot (which_side)), 
    11831183                          (mask << 16) | (value & 0xffff)); 
    11841184} 
    11851185 
    11861186bool 
    1187 usrp_basic_tx::write_io (int which_dboard, int value, int mask) 
    1188 { 
    1189   if (! (0 <= which_dboard && which_dboard <= 1)) 
    1190     return false; 
    1191  
    1192   return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_dboard)), 
     1187usrp_basic_tx::write_io (int which_side, int value, int mask) 
     1188{ 
     1189  if (! (0 <= which_side && which_side <= 1)) 
     1190    return false; 
     1191 
     1192  return _write_fpga_reg (slot_id_to_io_reg (dboard_to_slot (which_side)), 
    11931193                          (mask << 16) | (value & 0xffff)); 
    11941194} 
    11951195 
    11961196bool 
    1197 usrp_basic_tx::read_io (int which_dboard, int *value) 
    1198 { 
    1199   if (! (0 <= which_dboard && which_dboard <= 1)) 
     1197usrp_basic_tx::read_io (int which_side, int *value) 
     1198{ 
     1199  if (! (0 <= which_side && which_side <= 1)) 
    12001200    return false; 
    12011201 
    12021202  int t; 
    1203   int reg = which_dboard + 1; // FIXME, *very* magic number (fix in serial_io.v) 
     1203  int reg = which_side + 1;   // FIXME, *very* magic number (fix in serial_io.v) 
    12041204  bool ok = _read_fpga_reg (reg, &t); 
    12051205  if (!ok) 
    …… 
    12111211 
    12121212int 
    1213 usrp_basic_tx::read_io (int which_dboard) 
     1213usrp_basic_tx::read_io (int which_side) 
    12141214{ 
    12151215  int   value; 
    1216   if (!read_io (which_dboard, &value)) 
     1216  if (!read_io (which_side, &value)) 
    12171217    return READ_FAILED; 
    12181218  return value; 
    …… 
    12201220 
    12211221bool 
    1222 usrp_basic_tx::write_aux_dac (int which_dboard, int which_dac, int value) 
    1223 { 
    1224   return usrp_basic::write_aux_dac (dboard_to_slot (which_dboard), 
     1222usrp_basic_tx::write_aux_dac (int which_side, int which_dac, int value) 
     1223{ 
     1224  return usrp_basic::write_aux_dac (dboard_to_slot (which_side), 
    12251225                                    which_dac, value); 
    12261226} 
    12271227 
    12281228bool 
    1229 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc, int *value) 
    1230 { 
    1231   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), 
     1229usrp_basic_tx::read_aux_adc (int which_side, int which_adc, int *value) 
     1230{ 
     1231  return usrp_basic::read_aux_adc (dboard_to_slot (which_side), 
    12321232                                   which_adc, value); 
    12331233} 
    12341234 
    12351235int 
    1236 usrp_basic_tx::read_aux_adc (int which_dboard, int which_adc) 
    1237 { 
    1238   return usrp_basic::read_aux_adc (dboard_to_slot (which_dboard), which_adc); 
     1236usrp_basic_tx::read_aux_adc (int which_side, int which_adc) 
     1237{ 
     1238  return usrp_basic::read_aux_adc (dboard_to_slot (which_side), which_adc); 
    12391239} 
    12401240 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/usrp_basic.h

    r9742 r9743  
    11/* -*- c++ -*- */ 
    22/* 
    3  * Copyright 2003,2004 Free Software Foundation, Inc. 
     3 * Copyright 2003,2004,2008 Free Software Foundation, Inc. 
    44 *  
    55 * This file is part of GNU Radio 
    …… 
    173173   * \param offset      16-bit value to subtract from raw ADC input. 
    174174   */ 
    175   bool set_adc_offset (int which, int offset); 
     175  bool set_adc_offset (int which_adc, int offset); 
    176176 
    177177  /*! 
    …… 
    182182   *                                  If 1 offset applied to +ve differential pin. 
    183183   */ 
    184   bool set_dac_offset (int which, int offset, int offset_pin); 
     184  bool set_dac_offset (int which_dac, int offset, int offset_pin); 
    185185 
    186186  /*! 
    …… 
    190190   *                    directly to switched cap SHA input of RxPGA. 
    191191   */ 
    192   bool set_adc_buffer_bypass (int which, bool bypass); 
     192  bool set_adc_buffer_bypass (int which_adc, bool bypass); 
    193193 
    194194 
    …… 
    205205  // 
    206206 
    207   bool _set_led (int which, bool on); 
     207  bool _set_led (int which_led, bool on); 
    208208 
    209209  /*! 
    …… 
    400400   * \brief Return daughterboard ID for given Rx daughterboard slot [0,1]. 
    401401   * 
    402    * \param which_dboard      [0,1] which Rx daughterboard 
     402   * \param which_side        [0,1] which Rx daughterboard 
    403403   * 
    404404   * \return daughterboard id >= 0 if successful 
    …… 
    406406   * \return -2 if invalid EEPROM on daughterboard 
    407407   */ 
    408   int daughterboard_id (int which_dboard) const { return d_dbid[which_dboard & 0x1]; } 
     408  int daughterboard_id (int which_side) const { return d_dbid[which_side & 0x1]; } 
    409409 
    410410  // ---------------------------------------------------------------- 
    …… 
    413413   * \brief Set Programmable Gain Amplifier (PGA) 
    414414   * 
    415    * \param which     which A/D [0,3] 
     415   * \param which_amp which A/D [0,3] 
    416416   * \param gain_in_db  gain value (linear in dB) 
    417417   * 
    …… 
    422422   * \sa pga_min(), pga_max(), pga_db_per_step() 
    423423   */ 
    424   bool set_pga (int which, double gain_in_db); 
     424  bool set_pga (int which_amp, double gain_in_db); 
    425425 
    426426  /*! 
    427427   * \brief Return programmable gain amplifier gain setting in dB. 
    428428   * 
    429    * \param which     which A/D [0,3] 
    430    */ 
    431   double pga (int which) const; 
     429   * \param which_amp which A/D [0,3] 
     430   */ 
     431  double pga (int which_amp) const; 
    432432 
    433433  /*! 
    …… 
    449449   * \brief Write direction register (output enables) for pins that go to daughterboard. 
    450450   * 
    451    * \param which_dboard      [0,1] which d'board 
    452    * \param value              value to write into register 
    453    * \param mask               which bits of value to write into reg 
     451   * \param which_side        [0,1] which d'board 
     452   * \param value       value to write into register 
     453   * \param mask        which bits of value to write into reg 
    454454   * 
    455455   * Each d'board has 16-bits of general purpose i/o. 
    …… 
    461461   * kill your USRP motherboard and/or daughterboard. 
    462462   */ 
    463   bool _write_oe (int which_dboard, int value, int mask); 
     463  bool _write_oe (int which_side, int value, int mask); 
    464464 
    465465  /*! 
    466466   * \brief Write daughterboard i/o pin value 
    467467   * 
    468    * \param which_dboard      [0,1] which d'board 
    469    * \param value              value to write into register 
    470    * \param mask               which bits of value to write into reg 
    471    */ 
    472   bool write_io (int which_dboard, int value, int mask); 
     468   * \param which_side        [0,1] which d'board 
     469   * \param value       value to write into register 
     470   * \param mask        which bits of value to write into reg 
     471   */ 
     472  bool write_io (int which_side, int value, int mask); 
    473473 
    474474  /*! 
    475475   * \brief Read daughterboard i/o pin value 
    476476   * 
    477    * \param which_dboard      [0,1] which d'board 
    478    * \param value              output 
    479    */ 
    480   bool read_io (int which_dboard, int *value); 
     477   * \param which_side        [0,1] which d'board 
     478   * \param value       output 
     479   */ 
     480  bool read_io (int which_side, int *value); 
    481481 
    482482  /*! 
    483483   * \brief Read daughterboard i/o pin value 
    484484   * 
    485    * \param which_dboard      [0,1] which d'board 
     485   * \param which_side        [0,1] which d'board 
    486486   * \returns register value if successful, else READ_FAILED 
    487487   */ 
    488   int read_io (int which_dboard); 
     488  int read_io (int which_side); 
    489489 
    490490  /*! 
    491491   * \brief Write auxiliary digital to analog converter. 
    492492   * 
    493    * \param which_dboard      [0,1] which d'board 
    494    *                           N.B., SLOT_TX_A and SLOT_RX_A share the same AUX DAC's. 
    495    *                           SLOT_TX_B and SLOT_RX_B share the same AUX DAC's. 
    496    * \param which_dac          [2,3] TX slots must use only 2 and 3. 
    497    * \param value              [0,4095] 
    498    * \returns true iff successful 
    499    */ 
    500   bool write_aux_dac (int which_board, int which_dac, int value); 
     493   * \param which_side        [0,1] which d'board 
     494   *                    N.B., SLOT_TX_A and SLOT_RX_A share the same AUX DAC's. 
     495   *                    SLOT_TX_B and SLOT_RX_B share the same AUX DAC's. 
     496   * \param which_dac   [2,3] TX slots must use only 2 and 3. 
     497   * \param value       [0,4095] 
     498   * \returns true iff successful 
     499   */ 
     500  bool write_aux_dac (int which_side, int which_dac, int value); 
    501501 
    502502  /*! 
    503503   * \brief Read auxiliary analog to digital converter. 
    504504   * 
    505    * \param which_dboard      [0,1] which d'board 
    506    * \param which_adc          [0,1] 
    507    * \param value              return 12-bit value [0,4095] 
    508    * \returns true iff successful 
    509    */ 
    510   bool read_aux_adc (int which_dboard, int which_adc, int *value); 
     505   * \param which_side        [0,1] which d'board 
     506   * \param which_adc   [0,1] 
     507   * \param value       return 12-bit value [0,4095] 
     508   * \returns true iff successful 
     509   */ 
     510  bool read_aux_adc (int which_side, int which_adc, int *value); 
    511511 
    512512  /*! 
    513513   * \brief Read auxiliary analog to digital converter. 
    514514   * 
    515    * \param which_dboard      [0,1] which d'board 
     515   * \param which_side        [0,1] which d'board 
    516516   * \param which_adc           [0,1] 
    517517   * \returns value in the range [0,4095] if successful, else READ_FAILED. 
    518518   */ 
    519   int read_aux_adc (int which_dboard, int which_adc); 
     519  int read_aux_adc (int which_side, int which_adc); 
    520520 
    521521  /*! 
    …… 
    649649   * \return -2 if invalid EEPROM on daughterboard 
    650650   */ 
    651   int daughterboard_id (int which_dboard) const { return d_dbid[which_dboard & 0x1]; } 
     651  int daughterboard_id (int which_side) const { return d_dbid[which_side & 0x1]; } 
    652652 
    653653  // ---------------------------------------------------------------- 
    …… 
    656656   * \brief Set Programmable Gain Amplifier (PGA) 
    657657   * 
    658    * \param which     which D/A [0,3] 
     658   * \param which_amp which D/A [0,3] 
    659659   * \param gain_in_db  gain value (linear in dB) 
    660660   * 
    …… 
    667667   * \sa pga_min(), pga_max(), pga_db_per_step() 
    668668   */ 
    669   bool set_pga (int which, double gain_in_db); 
     669  bool set_pga (int which_amp, double gain_in_db); 
    670670 
    671671  /*! 
    672672   * \brief Return programmable gain amplifier gain in dB. 
    673673   * 
    674    * \param which     which D/A [0,3] 
    675    */ 
    676   double pga (int which) const; 
     674   * \param which_amp which D/A [0,3] 
     675   */ 
     676  double pga (int which_amp) const; 
    677677 
    678678  /*! 
    …… 
    694694   * \brief Write direction register (output enables) for pins that go to daughterboard. 
    695695   * 
    696    * \param which_dboard      [0,1] which d'board 
    697    * \param value              value to write into register 
    698    * \param mask               which bits of value to write into reg 
     696   * \param which_side        [0,1] which d'board 
     697   * \param value       value to write into register 
     698   * \param mask        which bits of value to write into reg 
    699699   * 
    700700   * Each d'board has 16-bits of general purpose i/o. 
    …… 
    706706   * kill your USRP motherboard and/or daughterboard. 
    707707   */ 
    708   bool _write_oe (int which_dboard, int value, int mask); 
     708  bool _write_oe (int which_side, int value, int mask); 
    709709 
    710710  /*! 
    711711   * \brief Write daughterboard i/o pin value 
    712712   * 
    713    * \param which_dboard      [0,1] which d'board 
     713   * \param which_side        [0,1] which d'board 
    714714   * \param value               value to write into register 
    715715   * \param mask                which bits of value to write into reg 
    716716   */ 
    717   bool write_io (int which_dboard, int value, int mask); 
     717  bool write_io (int which_side, int value, int mask); 
    718718 
    719719  /*! 
    720720   * \brief Read daughterboard i/o pin value 
    721721   * 
    722    * \param which_dboard      [0,1] which d'board 
     722   * \param which_side        [0,1] which d'board 
    723723   * \param value               return value 
    724724   */ 
    725   bool read_io (int which_dboard, int *value); 
     725  bool read_io (int which_side, int *value); 
    726726 
    727727  /*! 
    728728   * \brief Read daughterboard i/o pin value 
    729729   * 
    730    * \param which_dboard      [0,1] which d'board 
     730   * \param which_side        [0,1] which d'board 
    731731   * \returns register value if successful, else READ_FAILED 
    732732   */ 
    733   int read_io (int which_dboard); 
     733  int read_io (int which_side); 
    734734 
    735735  /*! 
    736736   * \brief Write auxiliary digital to analog converter. 
    737737   * 
    738    * \param which_dboard      [0,1] which d'board 
    739    *                           N.B., SLOT_TX_A and SLOT_RX_A share the same AUX DAC's. 
    740    *                           SLOT_TX_B and SLOT_RX_B share the same AUX DAC's. 
    741    * \param which_dac          [2,3] TX slots must use only 2 and 3. 
    742    * \param value              [0,4095] 
    743    * \returns true iff successful 
    744    */ 
    745   bool write_aux_dac (int which_board, int which_dac, int value); 
     738   * \param which_side        [0,1] which d'board 
     739   *                    N.B., SLOT_TX_A and SLOT_RX_A share the same AUX DAC's. 
     740   *                    SLOT_TX_B and SLOT_RX_B share the same AUX DAC's. 
     741   * \param which_dac   [2,3] TX slots must use only 2 and 3. 
     742   * \param value       [0,4095] 
     743   * \returns true iff successful 
     744   */ 
     745  bool write_aux_dac (int which_side, int which_dac, int value); 
    746746 
    747747  /*! 
    748748   * \brief Read auxiliary analog to digital converter. 
    749749   * 
    750    * \param which_dboard      [0,1] which d'board 
    751    * \param which_adc          [0,1] 
    752    * \param value              return 12-bit value [0,4095] 
    753    * \returns true iff successful 
    754    */ 
    755   bool read_aux_adc (int which_dboard, int which_adc, int *value); 
     750   * \param which_side        [0,1] which d'board 
     751   * \param which_adc   [0,1] 
     752   * \param value       return 12-bit value [0,4095] 
     753   * \returns true iff successful 
     754   */ 
     755  bool read_aux_adc (int which_side, int which_adc, int *value); 
    756756 
    757757  /*! 
    758758   * \brief Read auxiliary analog to digital converter. 
    759759   * 
    760    * \param which_dboard      [0,1] which d'board 
    761    * \param which_adc          [0,1] 
     760   * \param which_side        [0,1] which d'board 
     761   * \param which_adc   [0,1] 
    762762   * \returns value in the range [0,4095] if successful, else READ_FAILED. 
    763763   */ 
    764   int read_aux_adc (int which_dboard, int which_adc); 
     764  int read_aux_adc (int which_side, int which_adc); 
    765765 
    766766  /*!