From: klueska Date: Fri, 13 Jun 2008 19:33:39 +0000 (+0000) Subject: Added blocking adc support for atm128. Also moved BlockingAdcImplP component to... X-Git-Tag: release_tinyos_2_1_0_0~308 X-Git-Url: https://oss.titaniummirror.com/gitweb/?p=tinyos-2.x.git;a=commitdiff_plain;h=38b96f2291d22f7c5acad0d2019af4604b607d68 Added blocking adc support for atm128. Also moved BlockingAdcImplP component to the main system directory since its a general translation from split-phase adc operations to blocking ones --- diff --git a/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc new file mode 100644 index 00000000..9afdaafe --- /dev/null +++ b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2008 Stanford University. + * 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 Stanford University 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 STANFORD + * UNIVERSITY 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 Kevin Klues + */ + +#include "thread.h" + +configuration BlockingAdcP { + provides { + interface BlockingRead as BlockingRead[uint8_t client]; + interface BlockingReadStream as BlockingReadStream[uint8_t streamClient]; + } + uses { + //For BlockingRead + interface Atm128AdcConfig as Config[uint8_t client]; + interface Resource as ResourceRead[uint8_t client]; + + //For BlockingReadStream + interface Atm128AdcConfig as ConfigReadStream[uint8_t streamClient]; + interface Resource as ResourceReadStream[uint8_t streamClient]; + } +} +implementation { + components MainC; + components WireAdcP; + components WireAdcStreamP; + components BlockingAdcImplP; + + MainC.SoftwareInit -> BlockingAdcImplP; + + //For BlockingRead + BlockingRead = BlockingAdcImplP; + BlockingAdcImplP.Read -> WireAdcP; + Config = WireAdcP; + ResourceRead = WireAdcP; + + //For BlockingReadStream + BlockingReadStream = BlockingAdcImplP; + BlockingAdcImplP.ReadStream -> WireAdcStreamP; + ConfigReadStream = WireAdcStreamP; + ResourceReadStream = WireAdcStreamP; + + components SystemCallC; + components SystemCallQueueC; + BlockingAdcImplP.SystemCallQueue -> SystemCallQueueC; + BlockingAdcImplP.SystemCall -> SystemCallC; +} + + diff --git a/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadClientC.nc b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadClientC.nc new file mode 100644 index 00000000..ae4b76f7 --- /dev/null +++ b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadClientC.nc @@ -0,0 +1,41 @@ +/* $Id$ + * Copyright (c) 2005 Intel Corporation + * All rights reserved. + * + * This file is distributed under the terms in the attached INTEL-LICENSE + * file. If you do not find these files, copies can be found by writing to + * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300, Berkeley, CA, + * 94704. Attention: Intel License Inquiry. + */ +/** + * Provide, as per TEP101, arbitrated access via a Read interface to the + * Atmega128 ADC. Users of this component must link it to an + * implementation of Atm128AdcConfig which provides the ADC parameters + * (channel, etc). + * + * @author David Gay + * @author Kevin Klues + */ + +#include "Adc.h" + +generic configuration BlockingAdcReadClientC() { + provides interface BlockingRead; + uses { + interface Atm128AdcConfig; + interface ResourceConfigure; + } +} +implementation { + components Atm128AdcC, BlockingAdcP; + + enum { + ID = unique(UQ_ADC_READ), + HAL_ID = unique(UQ_ATM128ADC_RESOURCE) + }; + + BlockingRead = BlockingAdcP.BlockingRead[ID]; + Atm128AdcConfig = BlockingAdcP.Config[ID]; + BlockingAdcP.ReadResource[ID] -> Atm128AdcC.Resource[HAL_ID]; + ResourceConfigure = Atm128AdcC.ResourceConfigure[HAL_ID]; +} diff --git a/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadStreamClientC.nc b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadStreamClientC.nc new file mode 100644 index 00000000..214092bf --- /dev/null +++ b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcReadStreamClientC.nc @@ -0,0 +1,41 @@ +/* $Id$ + * Copyright (c) 2005 Intel Corporation + * All rights reserved. + * + * This file is distributed under the terms in the attached INTEL-LICENSE + * file. If you do not find these files, copies can be found by writing to + * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300, Berkeley, CA, + * 94704. Attention: Intel License Inquiry. + */ +/** + * Provide, as per TEP101, arbitrated access via a ReadStream interface to + * the Atmega128 ADC. Users of this component must link it to an + * implementation of Atm128AdcConfig which provides the ADC parameters + * (channel, etc). + * + * @author David Gay + * @author Kevin Klues + */ + +#include "Adc.h" + +generic configuration BlockingAdcReadStreamClientC() { + provides interface BlockingReadStream; + uses { + interface Atm128AdcConfig; + interface ResourceConfigure; + } +} +implementation { + components BlockingAdcP, Atm128AdcC; + + enum { + ID = unique(UQ_ADC_READSTREAM), + HAL_ID = unique(UQ_ATM128ADC_RESOURCE) + }; + + BlockingReadStream = BlockingAdcP.BlockingReadStream[ID]; + Atm128AdcConfig = BlockingAdcP.ConfigReadStream[ID]; + BlockingAdcP.ReadStreamResource[ID] -> Atm128AdcC.Resource[HAL_ID]; + ResourceConfigure = Atm128AdcC.ResourceConfigure[HAL_ID]; +} diff --git a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcImplP.nc b/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcImplP.nc deleted file mode 100644 index 17040e58..00000000 --- a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcImplP.nc +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) 2008 Stanford University. - * 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 Stanford University 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 STANFORD - * UNIVERSITY 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 Kevin Klues - */ - -module BlockingAdcImplP { - provides { - interface Init; - interface BlockingRead as BlockingRead[uint8_t client]; - interface BlockingReadStream as BlockingReadStream[uint8_t streamClient]; - } - uses { - interface Read as Read[uint8_t client]; - interface ReadStream as ReadStream[uint8_t streamClient]; - - interface SystemCall; - interface SystemCallQueue; - } -} -implementation { - - typedef struct read_params { - uint16_t* val; - error_t error; - } read_params_t; - - typedef struct readstream_params { - uint32_t* usPeriod; - uint16_t* buf; - uint16_t* count; - error_t error; - } readstream_params_t; - - syscall_queue_t read_queue; - syscall_queue_t readstream_queue; - - command error_t Init.init() { - call SystemCallQueue.init(&read_queue); - call SystemCallQueue.init(&readstream_queue); - return SUCCESS; - } - - /**************************** Read ********************************/ - void readTask(syscall_t* s) { - read_params_t* p = s->params; - p->error = call Read.read[s->id](); - if(p->error != SUCCESS) { - call SystemCall.finish(s); - } - } - - command error_t BlockingRead.read[uint8_t id](uint16_t* val) { - syscall_t s; - read_params_t p; - atomic { - if(call SystemCallQueue.find(&read_queue, id) != NULL) - return EBUSY; - call SystemCallQueue.enqueue(&read_queue, &s); - } - - p.val = val; - call SystemCall.start(&readTask, &s, id, &p); - - atomic { - call SystemCallQueue.remove(&read_queue, &s); - return p.error; - } - } - - event void Read.readDone[uint8_t id]( error_t result, uint16_t val ) { - syscall_t* s = call SystemCallQueue.find(&read_queue, id); - read_params_t* p = s->params; - *(p->val) = val; - p->error = result; - call SystemCall.finish(s); - } - - /**************************** ReadStream ********************************/ - void readStreamTask(syscall_t* s) { - readstream_params_t* p = s->params; - p->error = call ReadStream.postBuffer[s->id](p->buf, *(p->count)); - if(p->error == SUCCESS) - p->error = call ReadStream.read[s->id](*(p->usPeriod)); - if(p->error != SUCCESS) - call SystemCall.finish(s); - } - - command error_t BlockingReadStream.read[uint8_t id](uint32_t* usPeriod, uint16_t* buf, uint16_t count) { - syscall_t s; - readstream_params_t p; - atomic { - if(call SystemCallQueue.find(&readstream_queue, id) != NULL) - return EBUSY; - call SystemCallQueue.enqueue(&readstream_queue, &s); - } - - p.usPeriod = usPeriod; - p.buf = buf; - p.count = &count; - call SystemCall.start(&readTask, &s, id, &p); - - atomic { - call SystemCallQueue.remove(&readstream_queue, &s); - return p.error; - } - } - - event void ReadStream.bufferDone[uint8_t id](error_t result, - uint16_t* buf, uint16_t count) { - //Should never get here!!!!!! - } - - event void ReadStream.readDone[uint8_t id](error_t result, uint32_t usPeriod) { - syscall_t* s = call SystemCallQueue.find(&read_queue, id); - readstream_params_t* p = s->params; - *(p->usPeriod) = usPeriod; - p->error = result; - call SystemCall.finish(s); - } -} diff --git a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcReadClientC.nc b/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcReadClientC.nc index 0a62fa45..19cc7e09 100644 --- a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcReadClientC.nc +++ b/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcReadClientC.nc @@ -37,7 +37,8 @@ generic configuration BlockingAdcReadClientC() { provides interface BlockingRead; uses interface AdcConfigure; -} implementation { +} +implementation { components BlockingAdcP, #ifdef REF_VOLT_AUTO_CONFIGURE // if the client configuration requires a stable diff --git a/tos/lib/tosthreads/system/BlockingAdcImplP.nc b/tos/lib/tosthreads/system/BlockingAdcImplP.nc new file mode 100644 index 00000000..17040e58 --- /dev/null +++ b/tos/lib/tosthreads/system/BlockingAdcImplP.nc @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2008 Stanford University. + * 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 Stanford University 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 STANFORD + * UNIVERSITY 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 Kevin Klues + */ + +module BlockingAdcImplP { + provides { + interface Init; + interface BlockingRead as BlockingRead[uint8_t client]; + interface BlockingReadStream as BlockingReadStream[uint8_t streamClient]; + } + uses { + interface Read as Read[uint8_t client]; + interface ReadStream as ReadStream[uint8_t streamClient]; + + interface SystemCall; + interface SystemCallQueue; + } +} +implementation { + + typedef struct read_params { + uint16_t* val; + error_t error; + } read_params_t; + + typedef struct readstream_params { + uint32_t* usPeriod; + uint16_t* buf; + uint16_t* count; + error_t error; + } readstream_params_t; + + syscall_queue_t read_queue; + syscall_queue_t readstream_queue; + + command error_t Init.init() { + call SystemCallQueue.init(&read_queue); + call SystemCallQueue.init(&readstream_queue); + return SUCCESS; + } + + /**************************** Read ********************************/ + void readTask(syscall_t* s) { + read_params_t* p = s->params; + p->error = call Read.read[s->id](); + if(p->error != SUCCESS) { + call SystemCall.finish(s); + } + } + + command error_t BlockingRead.read[uint8_t id](uint16_t* val) { + syscall_t s; + read_params_t p; + atomic { + if(call SystemCallQueue.find(&read_queue, id) != NULL) + return EBUSY; + call SystemCallQueue.enqueue(&read_queue, &s); + } + + p.val = val; + call SystemCall.start(&readTask, &s, id, &p); + + atomic { + call SystemCallQueue.remove(&read_queue, &s); + return p.error; + } + } + + event void Read.readDone[uint8_t id]( error_t result, uint16_t val ) { + syscall_t* s = call SystemCallQueue.find(&read_queue, id); + read_params_t* p = s->params; + *(p->val) = val; + p->error = result; + call SystemCall.finish(s); + } + + /**************************** ReadStream ********************************/ + void readStreamTask(syscall_t* s) { + readstream_params_t* p = s->params; + p->error = call ReadStream.postBuffer[s->id](p->buf, *(p->count)); + if(p->error == SUCCESS) + p->error = call ReadStream.read[s->id](*(p->usPeriod)); + if(p->error != SUCCESS) + call SystemCall.finish(s); + } + + command error_t BlockingReadStream.read[uint8_t id](uint32_t* usPeriod, uint16_t* buf, uint16_t count) { + syscall_t s; + readstream_params_t p; + atomic { + if(call SystemCallQueue.find(&readstream_queue, id) != NULL) + return EBUSY; + call SystemCallQueue.enqueue(&readstream_queue, &s); + } + + p.usPeriod = usPeriod; + p.buf = buf; + p.count = &count; + call SystemCall.start(&readTask, &s, id, &p); + + atomic { + call SystemCallQueue.remove(&readstream_queue, &s); + return p.error; + } + } + + event void ReadStream.bufferDone[uint8_t id](error_t result, + uint16_t* buf, uint16_t count) { + //Should never get here!!!!!! + } + + event void ReadStream.readDone[uint8_t id](error_t result, uint32_t usPeriod) { + syscall_t* s = call SystemCallQueue.find(&read_queue, id); + readstream_params_t* p = s->params; + *(p->usPeriod) = usPeriod; + p->error = result; + call SystemCall.finish(s); + } +}