From c40dd6b5338735f7274cc8c2c455eeb5fa861c58 Mon Sep 17 00:00:00 2001 From: klueska Date: Fri, 13 Jun 2008 21:40:36 +0000 Subject: [PATCH] Renamed some components and added a blocking version of the SineSensor --- .../chips/atm128/adc/BlockingAdcP.nc | 20 ++-- .../chips/msp430/adc12/BlockingAdcP.nc | 20 ++-- .../universal/BlockingSineSensorC.nc | 49 ++++++++++ .../universal/BlockingSineSensorP.nc | 50 ++++++++++ tos/lib/tosthreads/system/BlockingReadP.nc | 96 +++++++++++++++++++ ...kingAdcImplP.nc => BlockingReadStreamP.nc} | 50 +--------- 6 files changed, 222 insertions(+), 63 deletions(-) create mode 100644 tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorC.nc create mode 100644 tos/lib/tosthreads/sensorboards/universal/BlockingSineSensorP.nc create mode 100644 tos/lib/tosthreads/system/BlockingReadP.nc rename tos/lib/tosthreads/system/{BlockingAdcImplP.nc => BlockingReadStreamP.nc} (71%) 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/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/BlockingAdcImplP.nc b/tos/lib/tosthreads/system/BlockingReadStreamP.nc similarity index 71% rename from tos/lib/tosthreads/system/BlockingAdcImplP.nc rename to tos/lib/tosthreads/system/BlockingReadStreamP.nc index 17040e58..616c5e75 100644 --- a/tos/lib/tosthreads/system/BlockingAdcImplP.nc +++ b/tos/lib/tosthreads/system/BlockingReadStreamP.nc @@ -33,14 +33,12 @@ * @author Kevin Klues */ -module BlockingAdcImplP { +generic module BlockingReadStreamP() { 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; @@ -49,11 +47,6 @@ module BlockingAdcImplP { } implementation { - typedef struct read_params { - uint16_t* val; - error_t error; - } read_params_t; - typedef struct readstream_params { uint32_t* usPeriod; uint16_t* buf; @@ -61,50 +54,13 @@ implementation { 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; @@ -127,7 +83,7 @@ implementation { p.usPeriod = usPeriod; p.buf = buf; p.count = &count; - call SystemCall.start(&readTask, &s, id, &p); + call SystemCall.start(&readStreamTask, &s, id, &p); atomic { call SystemCallQueue.remove(&readstream_queue, &s); @@ -141,7 +97,7 @@ implementation { } event void ReadStream.readDone[uint8_t id](error_t result, uint32_t usPeriod) { - syscall_t* s = call SystemCallQueue.find(&read_queue, id); + syscall_t* s = call SystemCallQueue.find(&readstream_queue, id); readstream_params_t* p = s->params; *(p->usPeriod) = usPeriod; p->error = result; -- 2.39.2