msp430adc12m.nc

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

          res = MSP430ADC12_FAIL;
          break;
        case MSP430ADC12_DELAYED:
          // VREF is unstable, simulate reserve call and
          // start conversion in RefVolt.isStable later
          req |= (RESERVED | VREF_WAIT);
          res = MSP430ADC12_DELAYED;               
          vrefWait = TRUE;
          // fall through
        case MSP430ADC12_SUCCESS: 
          {
            int8_t i, memctlsUsed = length;
            uint16_t mask = 1;
            adc12memctl_t lastMemctl = adc12settings[num16].memctl;
            uint16_t ctl0 = ADC12CTL0_TIMER_TRIGGERED;
            adc12ctl1_t ctl1 = {adc12busy:0, conseq:1, 
                                adc12ssel:adc12settings[num16].clockSourceSHT, 
                                adc12div:adc12settings[num16].clockDivSHT, issh:0, shp:1, 
                                shs:1, cstartadd:0};
            if (length > 16){
              ctl1.conseq = 3; // repeat sequence mode
              memctlsUsed = 16;
            }
            bufPtr = dataDest;
            bufLength = length;
            bufOffset = 0;     
            
            // initialize ADC registers
            call HPLADC12.disableConversion();            
            if (jiffies == 0){
              ctl0 = ADC12CTL0_AUTO_TRIGGERED;
              ctl1.shs = 0;  // ADC12SC starts the conversion
            }
            for (i=0; i<memctlsUsed-1; i++)
              call HPLADC12.setMemControl(i, adc12settings[num16].memctl);
            lastMemctl.eos = 1;  
            call HPLADC12.setMemControl(i, lastMemctl);
            call HPLADC12.setSHT(adc12settings[num16].sampleHoldTime);
            call HPLADC12.setIEFlags(mask << i);
            call HPLADC12.setControl0_IgnoreRef(*(adc12ctl0_t*) &ctl0);
            
            if (req & SINGLE_CHANNEL){
                ctl1.conseq = 0; // single channel single conversion
                cmode = SINGLE_CHANNEL;
            } else if (req & REPEAT_SINGLE_CHANNEL){
                ctl1.conseq = 2; // repeat single channel
                cmode = REPEAT_SINGLE_CHANNEL;
            } else if (req & REPEAT_SEQUENCE_OF_CHANNELS){
                ctl1.conseq = 3; // repeat sequence of channels
                cmode = REPEAT_SEQUENCE_OF_CHANNELS;
            }
            call HPLADC12.setControl1(ctl1);
            
            if (req & RESERVED){
              // reserve ADC now
              reserved = req;
              if (jiffies != 0){
                prepareTimerA(jiffies, adc12settings[num16].clockSourceSAMPCON,
                                adc12settings[num16].clockDivSAMPCON);
                reserved |= TIMER_USED;
              }
            } else {
               // trigger first conversion now
               call HPLADC12.startConversion();
               if (jiffies != 0){
                 prepareTimerA(jiffies, adc12settings[num16].clockSourceSAMPCON,
                               adc12settings[num16].clockDivSAMPCON);
                 startTimerA(); // go!
               }
            }
            res = MSP430ADC12_SUCCESS;
            break;
          }
      } // of switch
    }
    return res;
  }

  
  result_t unreserve(uint8_t num)
  {
    if (reserved & RESERVED && owner == num){
      cmode = reserved = ADC_IDLE;
      return SUCCESS;
    }
    return FAIL;
  }
  
  async command msp430ADCresult_t ADCSingle.getData[uint8_t num]()
  {
    return newRequest(SINGLE_CHANNEL, num, 0, 1, 0);
  }

  async command msp430ADCresult_t ADCSingle.getDataRepeat[uint8_t num](uint16_t jiffies)
  {
    return newRequest(REPEAT_SINGLE_CHANNEL, num, 0, 1, jiffies);
  }

  async command result_t ADCSingle.reserve[uint8_t num]()
  {
    if (newRequest(RESERVED | SINGLE_CHANNEL, num, 0, 1, 0) == MSP430ADC12_SUCCESS)
      return SUCCESS;
    return FAIL;
  }

  async command result_t ADCSingle.reserveRepeat[uint8_t num](uint16_t jiffies)
  {
    if (newRequest(RESERVED | REPEAT_SINGLE_CHANNEL, num, 0, 1, jiffies) == 
        MSP430ADC12_SUCCESS)
      return SUCCESS;
    return FAIL;
  }

  async command result_t ADCSingle.unreserve[uint8_t num]()
  {
    return unreserve(num);
  }
  
  async command msp430ADCresult_t ADCMultiple.getData[uint8_t num](uint16_t *buf, 
                                             uint16_t length, uint16_t jiffies)
  {
    return newRequest(SEQUENCE_OF_CHANNELS, num, buf, length, jiffies);
  }
  
  async command msp430ADCresult_t ADCMultiple.getDataRepeat[uint8_t num](uint16_t *buf, 
                                             uint8_t length, uint16_t jiffies) 
  {
    return newRequest(REPEAT_SEQUENCE_OF_CHANNELS, num, buf, length, jiffies);
  }

  async command result_t ADCMultiple.reserve[uint8_t num](uint16_t *buf, 
                                      uint16_t length, uint16_t jiffies)
  {
    if (newRequest(SEQUENCE_OF_CHANNELS | RESERVED, num, buf, length, jiffies)
        == MSP430ADC12_SUCCESS)
      return SUCCESS;
    return FAIL;
  }
  
  async command result_t ADCMultiple.reserveRepeat[uint8_t num](uint16_t *buf,
                                            uint16_t length, uint16_t jiffies)
  {
    if (newRequest(REPEAT_SEQUENCE_OF_CHANNELS | RESERVED, num, buf, length, jiffies)
        == MSP430ADC12_SUCCESS)
      return SUCCESS;
    return FAIL;
  }
  
  async command result_t  ADCMultiple.unreserve[uint8_t num]()
  {
    return unreserve(num);
  }
     
  async event void TimerA.overflow(){}
  async event void CompareA0.fired(){}
  async event void CompareA1.fired(){}

  default async event result_t ADCSingle.dataReady[uint8_t num](uint16_t data)
  {
    return FAIL;
  }
  default async event uint16_t* ADCMultiple.dataReady[uint8_t num](uint16_t *buf,
                                                          uint16_t length)
  {
    return (uint16_t*) 0;
  }

  event void RefVolt.isStable(RefVolt_t vref)
  {
    if (vrefWait){
      call HPLADC12.startConversion();
      if (reserved & TIMER_USED)
        startTimerA(); // go!
      reserved = ADC_IDLE;
      vrefWait = FALSE;
    }
  }
    
  void stopConversion()
  {
    call TimerA.setMode(MSP430TIMER_STOP_MODE);
    call HPLADC12.stopConversion();
    call HPLADC12.setIEFlags(0);
    call HPLADC12.resetIFGs();
    if (adc12settings[owner].gotRefVolt)
      releaseRefVolt(owner);
    cmode = ADC_IDLE;  // enable access to ADC, owner now invalid
  }
  
  async event void HPLADC12.converted(uint8_t number){
    switch (cmode) 
    { 
       case SINGLE_CHANNEL:
            {
              volatile uint8_t ownerTmp = owner;
              stopConversion();
              signal ADCSingle.dataReady[ownerTmp](call HPLADC12.getMem(0));
            }
            break;
       case REPEAT_SINGLE_CHANNEL:
            if (signal ADCSingle.dataReady[owner](call HPLADC12.getMem(0)) == FAIL)
              stopConversion();
            break;
        case SEQUENCE_OF_CHANNELS:
            {
              uint16_t i = 0, length = (bufLength - bufOffset > 16) ? 16 : bufLength - bufOffset;
              do {
                *bufPtr++ = call HPLADC12.getMem(i);
              } while (++i < length);
               
              bufOffset += length;
              
              if (bufLength - bufOffset > 15)
                return;
              else if (bufLength - bufOffset > 0){
                adc12memctl_t memctl = call HPLADC12.getMemControl(0);
                memctl.eos = 1;
                call HPLADC12.setMemControl(bufLength - bufOffset, memctl);
              } else {
                stopConversion();
                signal ADCMultiple.dataReady[owner](bufPtr - bufLength, bufLength);
              }
            }
            break;
        case REPEAT_SEQUENCE_OF_CHANNELS:
            {
              uint8_t i = 0;
              do {
                *bufPtr++ = call HPLADC12.getMem(i);
              } while (++i < bufLength);
              if ((bufPtr = signal ADCMultiple.dataReady[owner](bufPtr-bufLength,
                        bufLength)) == 0)
                stopConversion();
              break;
            }
        default:
            {
              //volatile uint16_t data = call HPLADC12.getMem(number);
              call HPLADC12.resetIFGs();
            }
            break;
      } // switch
  }
  
  async event void HPLADC12.memOverflow(){}
  async event void HPLADC12.timeOverflow(){}

}