[Tinyos-2-commits] CVS: tinyos-2.x/tos/chips/tsl2561 HalTsl2561Advanced.nc, NONE, 1.1.2.1 HalTsl2561ControlP.nc, NONE, 1.1.2.1 HalTsl2561ReaderP.nc, NONE, 1.1.2.1 HplTSL2561LogicP.nc, 1.1.2.1, 1.1.2.2 HplTSL256x.nc, 1.1.2.1, 1.1.2.2

[Philip Buonadonna]

Update of /cvsroot/tinyos/tinyos-2.x/tos/chips/tsl2561
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv7441

Modified Files:
      Tag: tinyos-2_0_devel-BRANCH
	HplTSL2561LogicP.nc HplTSL256x.nc 
Added Files:
      Tag: tinyos-2_0_devel-BRANCH
	HalTsl2561Advanced.nc HalTsl2561ControlP.nc 
	HalTsl2561ReaderP.nc 
Log Message:
Updated support for Taos TSL256x sensor chips

--- NEW FILE: HalTsl2561Advanced.nc ---
/* $Id: HalTsl2561Advanced.nc,v 1.1.2.1 2006/07/06 23:19:47 philipb Exp $ */
/*
 * Copyright (c) 2005 Arch Rock Corporation 
 * All rights reserved. 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *	Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *	Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *  
 *   Neither the name of the Arch Rock Corporation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE ARCHED
 * ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
/**
 *
 * @author Kaisen Lin
 * @author Phil Buonadonna
 */

interface HalTsl2561Advanced {
  command error_t setGain(bool gainHigh);
  event void setGainDone(error_t error);
  command error_t setIntegration(uint8_t val);
  event void setIntegrationDone(error_t error);
  command error_t setPersistence(uint8_t val);
  event void setPersistenceDone(error_t error);
  command error_t setTLow(uint16_t val);
  event void setTLowDone(error_t error);
  command error_t setTHigh(uint16_t val);
  event void setTHighDone(error_t error);
  command error_t enableAlert(bool enable);
  event void enableAlertDone(error_t error);
  event void alertThreshold();
}

--- NEW FILE: HalTsl2561ControlP.nc ---
/* $Id: HalTsl2561ControlP.nc,v 1.1.2.1 2006/07/06 23:19:47 philipb Exp $ */
/*
 * Copyright (c) 2005 Arch Rock Corporation 
 * All rights reserved. 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *	Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *	Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *  
 *   Neither the name of the Arch Rock Corporation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE ARCHED
 * ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
/**
 *
 * @author Kaisen Lin
 * @author Phil Buonadonna
 */

#include "TSL256x.h"

module HalTsl2561ControlP {
  provides interface HalTsl2561Advanced;

  uses interface Resource;
  uses interface HplTSL256x;
}

implementation {
  enum {
    S_IDLE = 0,
    S_GAIN,
    S_INTEG,
    S_PERSIST,
    S_TLOW,
    S_THIGH,
    S_ENALERT,
  };
  uint8_t state = S_IDLE;
  error_t clientResult;

  uint8_t timingRegisterShadow = 0x02;
  uint8_t iControlRegisterShadow = 0x0;
  
  task void complete_Alert() {
    signal HalTsl2561Advanced.alertThreshold();
  }

  task void complete_Task() {
    switch(state) {
    case S_GAIN:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.setGainDone(clientResult);
      break;
    case S_INTEG:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.setIntegrationDone(clientResult);
      break;
    case S_PERSIST:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.setPersistenceDone(clientResult);
      break;
    case S_TLOW:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.setTLowDone(clientResult);
      break;
    case S_THIGH:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.setTHighDone(clientResult);
      break;
    case S_ENALERT:
      state = S_IDLE;
      call Resource.release();
      signal HalTsl2561Advanced.enableAlertDone(clientResult);
      break;
    default:
      break;
    }    
  }

  command error_t HalTsl2561Advanced.setGain(bool gainHigh) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_GAIN;
    if(gainHigh)
      timingRegisterShadow |= TSL256X_TIMING_GAIN;
    else
      timingRegisterShadow &= ~TSL256X_TIMING_GAIN;

    call HplTSL256x.setTIMING(timingRegisterShadow);
    return SUCCESS;
  }

  command error_t HalTsl2561Advanced.setIntegration(uint8_t val) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_INTEG;
    timingRegisterShadow |= TSL256X_TIMING_MANUAL;
    timingRegisterShadow |= TSL256X_TIMING_INTEG(val);

    call HplTSL256x.setTIMING(timingRegisterShadow);
    return SUCCESS;
  }

  command error_t HalTsl2561Advanced.setPersistence(uint8_t val) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_PERSIST;
    iControlRegisterShadow |= TSL256X_INTERRUPT_PERSIST(val);

    call HplTSL256x.setINTERRUPT(iControlRegisterShadow);
    return SUCCESS;
  }

  command error_t HalTsl2561Advanced.setTLow(uint16_t val) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_TLOW;

    call HplTSL256x.setTHRESHLOW(val);
    return SUCCESS;
  }

  command error_t HalTsl2561Advanced.setTHigh(uint16_t val) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_THIGH;

    call HplTSL256x.setTHRESHHIGH(val);
    return SUCCESS;
  }

  command error_t HalTsl2561Advanced.enableAlert(bool enable) {
    error_t status;
    if(state != S_IDLE)
      return FAIL;
    status = call Resource.immediateRequest();
    if(status != SUCCESS)
      return status;
    state = S_ENALERT;
    iControlRegisterShadow &= ~TSL256X_INTERRUPT_INTR(3); // strip off interrupt select
    if(enable)
      iControlRegisterShadow |= TSL256X_INTERRUPT_INTR(1);

    call HplTSL256x.setINTERRUPT(iControlRegisterShadow);
    return SUCCESS;
  }

  event void Resource.granted() {
    // using immediate requests only
  }

  async event void HplTSL256x.setTIMINGDone(error_t error) {
    clientResult = error;
    post complete_Task();
  }
  async event void HplTSL256x.setINTERRUPTDone(error_t error) {
    clientResult = error;
    post complete_Task();
  }
  async event void HplTSL256x.setTHRESHLOWDone(error_t error) {
    clientResult = error;
    post complete_Task();
  }
  async event void HplTSL256x.setTHRESHHIGHDone(error_t error) {
    clientResult = error;
    post complete_Task();
  }
  async event void HplTSL256x.alertThreshold() { post complete_Alert(); }

  // stubs
  async event void HplTSL256x.getIDDone(error_t error, uint8_t idval) {}

  // intentionally left empty
  async event void HplTSL256x.setCONTROLDone(error_t error) {}
  async event void HplTSL256x.measureCh0Done(error_t error, uint16_t val) {}
  async event void HplTSL256x.measureCh1Done(error_t error, uint16_t val) {}

  // default stuff
  /*
  default event void HalTsl2561Advanced.setGainDone(error_t error) {}
  default event void HalTsl2561Advanced.setIntegrationDone(error_t error) {}
  default event void HalTsl2561Advanced.setPersistenceDone(error_t error) {}
  default event void HalTsl2561Advanced.setTLowDone(error_t error) {}
  default event void HalTsl2561Advanced.setTHighDone(error_t error) {}
  default event void HalTsl2561Advanced.enableAlertDone(error_t error) {}
  default event void HalTsl2561Advanced.alertThreshold() {}
  */
}

--- NEW FILE: HalTsl2561ReaderP.nc ---
/* $Id: HalTsl2561ReaderP.nc,v 1.1.2.1 2006/07/06 23:19:47 philipb Exp $ */
/*
 * Copyright (c) 2005 Arch Rock Corporation 
 * All rights reserved. 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *	Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *	Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *  
 *   Neither the name of the Arch Rock Corporation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE ARCHED
 * ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
/**
 *
 * @author Kaisen Lin
 * @author Phil Buonadonna
 */

// someone better power this up via SplitControl

generic module HalTsl2561ReaderP() {
  provides interface Read<uint16_t> as BroadbandPhoto;
  provides interface Read<uint16_t> as IRPhoto;

  uses interface Resource as BroadbandResource;
  uses interface Resource as IRResource;
  uses interface HplTSL256x;

}

implementation {
  enum {
    S_OFF = 0,
    S_READY,
    S_READ_BB,
    S_READ_IR,
  };
  norace uint8_t m_state = S_READY;
  error_t m_error;
  uint16_t m_val;

  task void signalDone_task() {
    switch(m_state) {
    case S_READ_BB:
      m_state = S_READY;
      call BroadbandResource.release();
      signal BroadbandPhoto.readDone(m_error, m_val);
      break;
    case S_READ_IR:
      m_state = S_READY;
      call IRResource.release();
      signal IRPhoto.readDone(m_error, m_val);
      break;
    default:
      m_state = S_READY;
      break;
    }
  }

  command error_t BroadbandPhoto.read() {
    error_t status;
    if(m_state != S_READY)
      return FAIL;
    status = call BroadbandResource.request();
    return status;
  }

  command error_t IRPhoto.read() {
    error_t status;
    if(m_state != S_READY)
      return FAIL;
    status = call IRResource.request();
    return status;
  }

  event void BroadbandResource.granted() {
    error_t result;
    result = call HplTSL256x.measureCh0();
    if(result != SUCCESS) {
      call BroadbandResource.release();
      signal BroadbandPhoto.readDone(result, 0);
    }
  }

  event void IRResource.granted() {
    error_t result;
    result = call HplTSL256x.measureCh1();
    if(result != SUCCESS) {
      call IRResource.release();
      signal IRPhoto.readDone(result, 0);
    }
  }
  
  async event void HplTSL256x.measureCh0Done(error_t error, uint16_t val) {
    m_state = S_READ_BB;
    m_error = error;
    m_val = val;
    post signalDone_task();
  }

  async event void HplTSL256x.measureCh1Done(error_t error, uint16_t val) {
    m_state = S_READ_IR;
    m_error = error;
    m_val = val;
    post signalDone_task();
  }

  async event void HplTSL256x.setCONTROLDone(error_t error) {}
  async event void HplTSL256x.setTIMINGDone(error_t error) {}
  async event void HplTSL256x.setTHRESHLOWDone(error_t error) {}
  async event void HplTSL256x.setTHRESHHIGHDone(error_t error) {}
  async event void HplTSL256x.setINTERRUPTDone(error_t error) {}
  async event void HplTSL256x.getIDDone(error_t error, uint8_t idval) {}
  async event void HplTSL256x.alertThreshold() {}

}

Index: HplTSL2561LogicP.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-2.x/tos/chips/tsl2561/Attic/HplTSL2561LogicP.nc,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -C2 -d -r1.1.2.1 -r1.1.2.2
*** HplTSL2561LogicP.nc	25 May 2006 22:55:48 -0000	1.1.2.1
--- HplTSL2561LogicP.nc	6 Jul 2006 23:19:47 -0000	1.1.2.2
***************
*** 41,44 ****
--- 41,45 ----
  
  #include "TSL256x.h"
+ #include "I2C.h"
  
  generic module HplTSL2561LogicP(uint16_t devAddr)
***************
*** 48,53 ****
    provides interface HplTSL256x;
  
!   uses interface I2CPacketAdv;
    uses interface GpioInterrupt as InterruptAlert;
  }
  
--- 49,56 ----
    provides interface HplTSL256x;
  
!   uses interface I2CPacket<TI2CBasicAddr>;
    uses interface GpioInterrupt as InterruptAlert;
+ 
+   uses interface GeneralIO as InterruptPin;
  }
  
***************
*** 67,73 ****
--- 70,79 ----
      STATE_SETINTERRUPT,
      STATE_READID,
+     STATE_CLRINTERRUPTS,
      STATE_ERROR
    };
  
+   bool interruptBit; // determine if I2C write was to clear an interrupt
+ 
    uint8_t mI2CBuffer[4];
    uint8_t mState;
***************
*** 75,79 ****
  
    static error_t doWriteReg(uint8_t nextState, uint8_t reg, uint8_t val) {
!     error_r error = SUCCESS;
  
      atomic {
--- 81,85 ----
  
    static error_t doWriteReg(uint8_t nextState, uint8_t reg, uint8_t val) {
!     error_t error = SUCCESS;
  
      atomic {
***************
*** 91,95 ****
      mI2CBuffer[1] = val;
  
!     error = call I2CPacket.writePacket(devAddr,2,mI2CBuffer,STOP_FLAG);
      
      if (error) 
--- 97,101 ----
      mI2CBuffer[1] = val;
  
!     error = call I2CPacket.write(I2C_START | I2C_STOP,devAddr,2,mI2CBuffer);
      
      if (error) 
***************
*** 110,125 ****
        }
      }
!     if error
        return error;
  
      mI2CBuffer[0] = (TSL256X_COMMAND_CMD | TSL256X_COMMAND_ADDRESS(reg));
  
!     error = call I2CPacket.writePacket(devAddr,1,mI2CBuffer,0);
  
      if (error)
!       atomic mState = STATE_IDLE:
  
      return error;
  
  
    task void StartDone() {
--- 116,142 ----
        }
      }
!     if (error)
        return error;
  
      mI2CBuffer[0] = (TSL256X_COMMAND_CMD | TSL256X_COMMAND_ADDRESS(reg));
  
!     error = call I2CPacket.write(I2C_START,devAddr,1,mI2CBuffer);
  
      if (error)
!       atomic mState = STATE_IDLE;
  
      return error;
+   }
  
+   static error_t clearInterrupt() {
+     error_t error;
+     mI2CBuffer[0] = (TSL256X_COMMAND_CMD | TSL256X_COMMAND_CLEAR);
+     error = call I2CPacket.write(I2C_START | I2C_STOP, devAddr, 1, mI2CBuffer);
+     
+     if (error == SUCCESS)
+       interruptBit = TRUE;
+       
+     return error;
+   }
  
    task void StartDone() {
***************
*** 136,140 ****
  
    command error_t Init.init() {
!     mState = STATE_STOPPED:
    }
  
--- 153,161 ----
  
    command error_t Init.init() {
!     call InterruptPin.makeInput();
!     call InterruptAlert.enableFallingEdge();
!     mState = STATE_STOPPED;
!     interruptBit = FALSE;
!     return SUCCESS;
    }
  
***************
*** 150,161 ****
      }
      
!     if error
        return error;
  
!     return doWriteReg(STATE_STARTING,TSL256X_PTR_CONTROL,(TSL256X_CONTROL_POWER_ON),0);
    }
  
    command error_t SplitControl.stop() {
!     return doWriteReg(STATE_STOPPING,TSL256X_PTR_CONTROL,(TSL256X_CONTROL_POWER_OFF),0);
    }
  
--- 171,182 ----
      }
      
!     if (error)
        return error;
  
!     return doWriteReg(STATE_STARTING,TSL256X_PTR_CONTROL,(TSL256X_CONTROL_POWER_ON));
    }
  
    command error_t SplitControl.stop() {
!     return doWriteReg(STATE_STOPPING,TSL256X_PTR_CONTROL,(TSL256X_CONTROL_POWER_OFF));
    }
  
***************
*** 185,189 ****
    }
  
!   command error_t Taos.TSL256x.setINTERRUPT(uint8_t val) {
      return doWriteReg(STATE_SETINTERRUPT,TSL256X_PTR_INTERRUPT,val);
    }
--- 206,210 ----
    }
  
!   command error_t HplTSL256x.setINTERRUPT(uint8_t val) {
      return doWriteReg(STATE_SETINTERRUPT,TSL256X_PTR_INTERRUPT,val);
    }
***************
*** 193,197 ****
    }
  
!   async event void I2CPacket.readDone(uint16_t chipAddr, uint8_t len, uint8_t *buf, error_t i2c_error) {
      uint16_t tempVal;
      error_t error = i2c_error;
--- 214,218 ----
    }
  
!   async event void I2CPacket.readDone(error_t i2c_error, uint16_t chipAddr, uint8_t len, uint8_t *buf) {
      uint16_t tempVal;
      error_t error = i2c_error;
***************
*** 221,230 ****
    }
  
!   async event void I2CPacket.writeDone(uint16_t chipAddr, uint8_t len, uint8_t *buf, error_t i2c_error) {
      error_t error = i2c_error;
! 
      switch (mState) {
      case STATE_STARTING:
        mSSError = error;
        mState = STATE_IDLE;
        post StartDone();
--- 242,266 ----
    }
  
!   async event void I2CPacket.writeDone(error_t i2c_error, uint16_t chipAddr, uint8_t len, uint8_t *buf) {
      error_t error = i2c_error;
!     /*
!     if(interruptBit) {
!       interruptBit = FALSE;
!       return;
!     }
!     */
      switch (mState) {
      case STATE_STARTING:
        mSSError = error;
+       //---
+       /* 
+       mState = STATE_CLRINTERRUPTS;
+       interruptBit = TRUE;
+       clearInterrupt();
+       break;
+     case STATE_CLRINTERRUPTS:
+       mSSError = error;
+       */
+       //---
        mState = STATE_IDLE;
        post StartDone();
***************
*** 236,245 ****
        break;
      case STATE_READCH0:
!       if (error) {
! 	signal cal HplTaos.TSL
!       error = call I2CPacket.readPacket(devAddr,2,mI2CBuffer,STOP_FLAG);
        break;
      case STATE_READCH1:
!       error = call I2CPacket.readPacket(devAddr,2,mI2CBuffer,STOP_FLAG);
        break;
      case STATE_SETCONTROL:
--- 272,279 ----
        break;
      case STATE_READCH0:
!       error = call I2CPacket.read(I2C_START | I2C_STOP,devAddr,2,mI2CBuffer);
        break;
      case STATE_READCH1:
!       error = call I2CPacket.read(I2C_START | I2C_STOP,devAddr,2,mI2CBuffer);
        break;
      case STATE_SETCONTROL:
***************
*** 247,253 ****
        signal HplTSL256x.setCONTROLDone(error);
        break;
      case STATE_SETHIGH:
        mState = STATE_IDLE;
!       signal HplTSL256x.setTHRESHIGHDone(error);
        break;
      case STATE_SETLOW:
--- 281,295 ----
        signal HplTSL256x.setCONTROLDone(error);
        break;
+     case STATE_SETTIMING:
+       mState = STATE_IDLE;
+       signal HplTSL256x.setTIMINGDone(error);
+       break;
+     case STATE_SETINTERRUPT:
+       mState = STATE_IDLE;
+       signal HplTSL256x.setINTERRUPTDone(error);
+       break;
      case STATE_SETHIGH:
        mState = STATE_IDLE;
!       signal HplTSL256x.setTHRESHHIGHDone(error);
        break;
      case STATE_SETLOW:
***************
*** 256,263 ****
        break;
      case STATE_READID:
!       error = call I2CPacket.readPacket(devAddr,1,mI2CBuffer,STOP_FLAG);
        break;
      default:
!       mState = STATE_IDLE:
  	break;
      }
--- 298,305 ----
        break;
      case STATE_READID:
!       error = call I2CPacket.read(I2C_STOP,devAddr,1,mI2CBuffer);
        break;
      default:
!       mState = STATE_IDLE;
  	break;
      }
***************
*** 268,272 ****
--- 310,321 ----
      // This alert is decoupled from whatever state the TSL2561 is in. 
      // Upper layers must handle dealing with this alert appropriately.
+     
      signal HplTSL256x.alertThreshold();
+ 
+     // need to clear interrupt, this is dangerous...
+     // if you get interrupted while someone is reading...
+     // ... the I2C bus may become inconsistent?
+     clearInterrupt();
+     
      return;
    }
***************
*** 274,286 ****
    default event void SplitControl.startDone( error_t error ) { return; }
    default event void SplitControl.stopDone( error_t error ) { return; }
!   default event void HplTSL256x.measureCh0Done( error_t error, uint16_t val ){ return; }
!   default event void HplTSL256x.measureCh1Done( error_t error, uint16_t val ){ return; }
!   default event void HplTSL256x.setCONTROLDone( error_t error ){ return; }
!   default event void HplTSL256x.setTIMINGDone(error_t error){ return; }
!   default event void HplTSL256x.setTHRESHLOWDone(error_t error){ return;} 
!   default event void HplTSL256x.setTHRESHHIGHDone(error_t error){ return; }
!   default event void HplTSL256x.setINTERRUPTDone(error_t error){ return;} 
!   default event void HplTSL256x.getIDDone(error_t error, uint8_t idval){ return; }
!   default event void HplTSL256x.alertThreshold(){ return; }
  
  }
--- 323,335 ----
    default event void SplitControl.startDone( error_t error ) { return; }
    default event void SplitControl.stopDone( error_t error ) { return; }
!   default async event void HplTSL256x.measureCh0Done( error_t error, uint16_t val ){ return; }
!   default async event void HplTSL256x.measureCh1Done( error_t error, uint16_t val ){ return; }
!   default async event void HplTSL256x.setCONTROLDone( error_t error ){ return; }
!   default async event void HplTSL256x.setTIMINGDone(error_t error){ return; }
!   default async event void HplTSL256x.setTHRESHLOWDone(error_t error){ return;} 
!   default async event void HplTSL256x.setTHRESHHIGHDone(error_t error){ return; }
!   default async event void HplTSL256x.setINTERRUPTDone(error_t error){ return;} 
!   default async event void HplTSL256x.getIDDone(error_t error, uint8_t idval){ return; }
!   default async event void HplTSL256x.alertThreshold(){ return; }
  
  }

Index: HplTSL256x.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-2.x/tos/chips/tsl2561/Attic/HplTSL256x.nc,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -C2 -d -r1.1.2.1 -r1.1.2.2
*** HplTSL256x.nc	25 May 2006 22:55:48 -0000	1.1.2.1
--- HplTSL256x.nc	6 Jul 2006 23:19:48 -0000	1.1.2.2
***************
*** 54,58 ****
  
    command error_t setTHRESHLOW(uint16_t val);
!   async event setTHRESHLOWDone(error_t error);
  
    command error_t setTHRESHHIGH(uint16_t val);
--- 54,58 ----
  
    command error_t setTHRESHLOW(uint16_t val);
!   async event void setTHRESHLOWDone(error_t error);
  
    command error_t setTHRESHHIGH(uint16_t val);