From: klueska Date: Fri, 13 Jun 2008 21:40:36 +0000 (+0000) Subject: Renamed some components and added a blocking version of the SineSensor X-Git-Tag: release_tinyos_2_1_0_0~307 X-Git-Url: https://oss.titaniummirror.com/gitweb/?p=tinyos-2.x.git;a=commitdiff_plain;h=c40dd6b5338735f7274cc8c2c455eeb5fa861c58 Renamed some components and added a blocking version of the SineSensor --- diff --git a/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc index 9afdaafe..c67bd620 100644 --- a/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc +++ b/tos/lib/tosthreads/chips/atm128/adc/BlockingAdcP.nc @@ -54,26 +54,30 @@ implementation { components MainC; components WireAdcP; components WireAdcStreamP; - components BlockingAdcImplP; + components new BlockingReadP(); + components new BlockingReadStreamP(); - MainC.SoftwareInit -> BlockingAdcImplP; + MainC.SoftwareInit -> BlockingReadP; + MainC.SoftwareInit -> BlockingReadStreamP; //For BlockingRead - BlockingRead = BlockingAdcImplP; - BlockingAdcImplP.Read -> WireAdcP; + BlockingRead = BlockingReadP; + BlockingReadP.Read -> WireAdcP; Config = WireAdcP; ResourceRead = WireAdcP; //For BlockingReadStream - BlockingReadStream = BlockingAdcImplP; - BlockingAdcImplP.ReadStream -> WireAdcStreamP; + BlockingReadStream = BlockingReadStreamP; + BlockingReadStreamP.ReadStream -> WireAdcStreamP; ConfigReadStream = WireAdcStreamP; ResourceReadStream = WireAdcStreamP; components SystemCallC; components SystemCallQueueC; - BlockingAdcImplP.SystemCallQueue -> SystemCallQueueC; - BlockingAdcImplP.SystemCall -> SystemCallC; + BlockingReadP.SystemCallQueue -> SystemCallQueueC; + BlockingReadP.SystemCall -> SystemCallC; + BlockingReadStreamP.SystemCallQueue -> SystemCallQueueC; + BlockingReadStreamP.SystemCall -> SystemCallC; } diff --git a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcP.nc b/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcP.nc index e88a9960..ce22d965 100644 --- a/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcP.nc +++ b/tos/lib/tosthreads/chips/msp430/adc12/BlockingAdcP.nc @@ -56,28 +56,32 @@ implementation { components MainC; components AdcP; components WireAdcStreamP; - components BlockingAdcImplP; + components new BlockingReadP(); + components new BlockingReadStreamP(); - MainC.SoftwareInit -> BlockingAdcImplP; + MainC.SoftwareInit -> BlockingReadP; + MainC.SoftwareInit -> BlockingReadStreamP; //For BlockingRead - BlockingRead = BlockingAdcImplP; + BlockingRead = BlockingReadP; Config = AdcP.Config; SingleChannel = AdcP.SingleChannel; ResourceRead = AdcP.ResourceRead; - BlockingAdcImplP.Read -> AdcP.Read; + BlockingReadP.Read -> AdcP.Read; //For BlockingReadStream - BlockingReadStream = BlockingAdcImplP; + BlockingReadStream = BlockingReadStreamP; ConfigReadStream = WireAdcStreamP; SingleChannelReadStream = WireAdcStreamP; ResourceReadStream = WireAdcStreamP; - BlockingAdcImplP.ReadStream -> WireAdcStreamP; + BlockingReadStreamP.ReadStream -> WireAdcStreamP; components SystemCallC; components SystemCallQueueC; - BlockingAdcImplP.SystemCallQueue -> SystemCallQueueC; - BlockingAdcImplP.SystemCall -> SystemCallC; + BlockingReadP.SystemCallQueue -> SystemCallQueueC; + BlockingReadP.SystemCall -> SystemCallC; + BlockingReadStreamP.SystemCallQueue -> SystemCallQueueC; + BlockingReadStreamP.SystemCall -> SystemCallC; } diff --git a/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorC.nc b/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorC.nc new file mode 100644 index 00000000..5d9dbfa1 --- /dev/null +++ b/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorC.nc @@ -0,0 +1,49 @@ +/* + * 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 + */ + +generic configuration BlockingSineSensorC() { + provides interface Init; + provides interface BlockingRead; +} +implementation { + components BlockingSineSensorP; + components new SineSensorC(); + + enum { ID = unique("Sine.Sensor") }; + + Init = SineSensorC; + BlockingRead = BlockingSineSensorP.BlockingRead[ID]; + BlockingSineSensorP.Read[ID] -> SineSensorC; +} diff --git a/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorP.nc b/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorP.nc new file mode 100644 index 00000000..0c3118b2 --- /dev/null +++ b/tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorP.nc @@ -0,0 +1,50 @@ +/* + * 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 + */ + +configuration BlockingSineSensorP { + provides interface BlockingRead[uint8_t id]; + uses interface Read[uint8_t id]; +} +implementation { + components new BlockingReadP(); + + BlockingRead = BlockingReadP; + Read = BlockingReadP; + + components SystemCallC; + components SystemCallQueueC; + BlockingReadP.SystemCallQueue -> SystemCallQueueC; + BlockingReadP.SystemCall -> SystemCallC; +} diff --git a/tos/lib/tosthreads/system/BlockingAdcImplP.nc b/tos/lib/tosthreads/system/BlockingAdcImplP.nc deleted file mode 100644 index 17040e58..00000000 --- a/tos/lib/tosthreads/system/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/system/BlockingReadP.nc b/tos/lib/tosthreads/system/BlockingReadP.nc new file mode 100644 index 00000000..be16b882 --- /dev/null +++ b/tos/lib/tosthreads/system/BlockingReadP.nc @@ -0,0 +1,96 @@ +/* + * 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 + */ + +generic module BlockingReadP() { + provides { + interface Init; + interface BlockingRead as BlockingRead[uint8_t client]; + } + uses { + interface Read as Read[uint8_t client]; + + interface SystemCall; + interface SystemCallQueue; + } +} +implementation { + + typedef struct read_params { + uint16_t* val; + error_t error; + } read_params_t; + + syscall_queue_t read_queue; + + command error_t Init.init() { + call SystemCallQueue.init(&read_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); + } +} diff --git a/tos/lib/tosthreads/system/BlockingReadStreamP.nc b/tos/lib/tosthreads/system/BlockingReadStreamP.nc new file mode 100644 index 00000000..616c5e75 --- /dev/null +++ b/tos/lib/tosthreads/system/BlockingReadStreamP.nc @@ -0,0 +1,106 @@ +/* + * 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 + */ + +generic module BlockingReadStreamP() { + provides { + interface Init; + interface BlockingReadStream as BlockingReadStream[uint8_t streamClient]; + } + uses { + interface ReadStream as ReadStream[uint8_t streamClient]; + + interface SystemCall; + interface SystemCallQueue; + } +} +implementation { + + typedef struct readstream_params { + uint32_t* usPeriod; + uint16_t* buf; + uint16_t* count; + error_t error; + } readstream_params_t; + + syscall_queue_t readstream_queue; + + command error_t Init.init() { + call SystemCallQueue.init(&readstream_queue); + return SUCCESS; + } + + /**************************** 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(&readStreamTask, &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(&readstream_queue, id); + readstream_params_t* p = s->params; + *(p->usPeriod) = usPeriod; + p->error = result; + call SystemCall.finish(s); + } +}