From dba7b3ba714b04c28070ed1119453aeef90b2776 Mon Sep 17 00:00:00 2001 From: klueska Date: Mon, 16 Jun 2008 18:38:28 +0000 Subject: [PATCH] Added collection stuff for tosthreads --- apps/tosthreads/apps/TestCollection/Makefile | 7 + .../TestCollection/MultihopOscilloscope.h | 36 ++++++ .../apps/TestCollection/TestCollectionAppC.nc | 60 +++++++++ .../apps/TestCollection/TestCollectionC.nc | 120 ++++++++++++++++++ support/make/threads.extra | 1 + tos/lib/tosthreads/interfaces/BlockingSend.nc | 32 +++++ .../lib/net/BlockingCollectionControlC.nc | 42 ++++++ .../lib/net/BlockingCollectionControlP.nc | 47 +++++++ .../lib/net/BlockingCollectionReceiverC.nc | 40 ++++++ .../lib/net/BlockingCollectionReceiverP.nc | 53 ++++++++ .../lib/net/BlockingCollectionSenderC.nc | 42 ++++++ .../lib/net/BlockingCollectionSenderImplP.nc | 111 ++++++++++++++++ .../lib/net/BlockingCollectionSenderP.nc | 52 ++++++++ .../lib/net/BlockingCollectionSnooperC.nc | 37 ++++++ .../lib/net/BlockingCollectionSnooperP.nc | 53 ++++++++ 15 files changed, 733 insertions(+) create mode 100644 apps/tosthreads/apps/TestCollection/Makefile create mode 100644 apps/tosthreads/apps/TestCollection/MultihopOscilloscope.h create mode 100644 apps/tosthreads/apps/TestCollection/TestCollectionAppC.nc create mode 100644 apps/tosthreads/apps/TestCollection/TestCollectionC.nc create mode 100644 tos/lib/tosthreads/interfaces/BlockingSend.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionControlC.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionControlP.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionReceiverC.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionReceiverP.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionSenderC.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionSenderP.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionSnooperC.nc create mode 100644 tos/lib/tosthreads/lib/net/BlockingCollectionSnooperP.nc diff --git a/apps/tosthreads/apps/TestCollection/Makefile b/apps/tosthreads/apps/TestCollection/Makefile new file mode 100644 index 00000000..90b778a5 --- /dev/null +++ b/apps/tosthreads/apps/TestCollection/Makefile @@ -0,0 +1,7 @@ +COMPONENT=TestCollectionAppC + +CFLAGS += -I$(TOSDIR)/lib/tosthreads/sensorboards/universal +CFLAGS += -I$(TOSDIR)/lib/tosthreads/lib/net/ +CFLAGS += -I$(TOSDIR)/lib/net/ -I$(TOSDIR)/lib/net/ctp -I$(TOSDIR)/lib/net/4bitle + +include $(MAKERULES) diff --git a/apps/tosthreads/apps/TestCollection/MultihopOscilloscope.h b/apps/tosthreads/apps/TestCollection/MultihopOscilloscope.h new file mode 100644 index 00000000..5f040539 --- /dev/null +++ b/apps/tosthreads/apps/TestCollection/MultihopOscilloscope.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2006 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. + */ + +/** + * @author David Gay + * @author Kyle Jamieson + */ + +#ifndef MULTIHOP_OSCILLOSCOPE_H +#define MULTIHOP_OSCILLOSCOPE_H + +enum { + /* Number of readings per message. If you increase this, you may have to + increase the message_t size. */ + NREADINGS = 5, + /* Default sampling period. */ + DEFAULT_INTERVAL = 1024, + AM_OSCILLOSCOPE = 0x93 +}; + +typedef nx_struct oscilloscope { + nx_uint16_t version; /* Version of the interval. */ + nx_uint16_t interval; /* Samping period. */ + nx_uint16_t id; /* Mote id of sending mote. */ + nx_uint16_t count; /* The readings are samples count * NREADINGS onwards */ + nx_uint16_t readings[NREADINGS]; +} oscilloscope_t; + +#endif diff --git a/apps/tosthreads/apps/TestCollection/TestCollectionAppC.nc b/apps/tosthreads/apps/TestCollection/TestCollectionAppC.nc new file mode 100644 index 00000000..d6dab922 --- /dev/null +++ b/apps/tosthreads/apps/TestCollection/TestCollectionAppC.nc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +#include "MultihopOscilloscope.h" + +configuration TestCollectionAppC {} + +implementation { + components TestCollectionC, + new BlockingSineSensorC(), + LedsC, + BlockingActiveMessageC, + BlockingCollectionControlC, + new BlockingCollectionSenderC(AM_OSCILLOSCOPE), + new BlockingCollectionReceiverC(AM_OSCILLOSCOPE), + new ThreadC(800) as MainThread, + MainC, + BlockingSerialActiveMessageC, + new BlockingSerialAMSenderC(AM_OSCILLOSCOPE); + + TestCollectionC.MainThread -> MainThread; + TestCollectionC.Boot -> MainC; + TestCollectionC.BlockingRead -> BlockingSineSensorC; + TestCollectionC.Leds -> LedsC; + TestCollectionC.BlockingRead -> BlockingSineSensorC; + + TestCollectionC.RadioStdControl -> BlockingActiveMessageC; + + TestCollectionC.RoutingControl -> BlockingCollectionControlC; + TestCollectionC.RootControl -> BlockingCollectionControlC; + TestCollectionC.Packet -> BlockingCollectionSenderC; + TestCollectionC.BlockingSend -> BlockingCollectionSenderC; + TestCollectionC.BlockingReceive -> BlockingCollectionReceiverC; + + TestCollectionC.SerialStdControl -> BlockingSerialActiveMessageC; + TestCollectionC.SerialBlockingSend -> BlockingSerialAMSenderC; +} diff --git a/apps/tosthreads/apps/TestCollection/TestCollectionC.nc b/apps/tosthreads/apps/TestCollection/TestCollectionC.nc new file mode 100644 index 00000000..e401fc05 --- /dev/null +++ b/apps/tosthreads/apps/TestCollection/TestCollectionC.nc @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +#include "MultihopOscilloscope.h" + +module TestCollectionC { + uses { + interface Boot; + interface Thread as MainThread; + interface BlockingRead; + interface BlockingStdControl as RadioStdControl; + interface Packet; + interface BlockingSend; + interface BlockingReceive; + interface BlockingStdControl as RoutingControl; + interface RootControl; + interface Leds; + interface BlockingStdControl as SerialStdControl; + interface BlockingAMSend as SerialBlockingSend; + } +} + +implementation { + static void fatal_problem(); + + oscilloscope_t local; + uint8_t reading = 0; /* 0 to NREADINGS */ + message_t sendbuf; + message_t recvbuf; + + void fatal_problem(); + void report_problem(); + void report_sent(); + void report_received(); + + event void Boot.booted() { + local.interval = DEFAULT_INTERVAL; + local.id = TOS_NODE_ID; + local.version = 0; + + call MainThread.start(NULL); + } + + event void MainThread.run(void* arg) { + while (call RadioStdControl.start() != SUCCESS); + while (call RoutingControl.start() != SUCCESS); + + if (local.id % 500 == 0) { + while (call SerialStdControl.start() != SUCCESS); + call RootControl.setRoot(); + for (;;) { + if (call BlockingReceive.receive(&recvbuf, 0) == SUCCESS) { + call SerialBlockingSend.send(AM_BROADCAST_ADDR, &recvbuf, sizeof(local)); + report_received(); + } + } + } else { + uint16_t var; + + for (;;) { + if (reading == NREADINGS) { + oscilloscope_t *o = o; + o = (oscilloscope_t *)call BlockingSend.getPayload(&sendbuf, sizeof(oscilloscope_t)); + if (o == NULL) { + fatal_problem(); + return; + } + memcpy(o, &local, sizeof(local)); + if (call BlockingSend.send(&sendbuf, sizeof(local)) == SUCCESS) { + report_sent(); + } else { + report_problem(); + } + + reading = 0; + } + + if (call BlockingRead.read(&var) == SUCCESS) { + local.readings[reading++] = var; + } + + call MainThread.sleep(local.interval); + } + } + } + + // Use LEDs to report various status issues. + void fatal_problem() { + call Leds.led0On(); + call Leds.led1On(); + call Leds.led2On(); + } + + void report_problem() { call Leds.led0Toggle(); } + void report_sent() { call Leds.led1Toggle(); } + void report_received() { call Leds.led2Toggle(); } +} diff --git a/support/make/threads.extra b/support/make/threads.extra index 1c316534..f81ce07e 100644 --- a/support/make/threads.extra +++ b/support/make/threads.extra @@ -22,6 +22,7 @@ THREADS_MSP430_INCLUDE_DIRS += -I$(THREADS_MSP430_DIR)/adc12 #Atm128 specific include directories on tested platforms THREADS_ATM128_DIR = $(TOS_THREADS_DIR)/chips/atm128 THREADS_ATM128_INCLUDE_DIRS = -I$(THREADS_ATM128_DIR) +THREADS_ATM128_INCLUDE_DIRS += -I$(THREADS_ATM128_DIR)/adc #Atm1281 specific include directories on tested platforms THREADS_ATM1281_DIR = $(TOS_THREADS_DIR)/chips/atm1281 diff --git a/tos/lib/tosthreads/interfaces/BlockingSend.nc b/tos/lib/tosthreads/interfaces/BlockingSend.nc new file mode 100644 index 00000000..5db04502 --- /dev/null +++ b/tos/lib/tosthreads/interfaces/BlockingSend.nc @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +interface BlockingSend { + command error_t send(message_t* msg, uint8_t len); + command error_t cancel(message_t* msg); + command uint8_t maxPayloadLength(); + command void* getPayload(message_t* msg, uint8_t len); +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionControlC.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionControlC.nc new file mode 100644 index 00000000..e7b21822 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionControlC.nc @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +configuration BlockingCollectionControlC { + provides { + interface BlockingStdControl as RoutingControl; + interface RootControl; + } +} + +implementation { + components BlockingCollectionControlP, + CollectionC as Collector; + + RoutingControl = BlockingCollectionControlP.BlockingStdControl; + RootControl = Collector; + + BlockingCollectionControlP.RoutingControl -> Collector.StdControl; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionControlP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionControlP.nc new file mode 100644 index 00000000..b2d920af --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionControlP.nc @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +module BlockingCollectionControlP { + provides { + interface BlockingStdControl; + } + + uses { + interface StdControl as RoutingControl; + } +} + +implementation { + command error_t BlockingStdControl.start() + { + return call RoutingControl.start(); + } + + command error_t BlockingStdControl.stop() + { + return call RoutingControl.stop(); + } +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverC.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverC.nc new file mode 100644 index 00000000..7067354b --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverC.nc @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +generic configuration BlockingCollectionReceiverC (collection_id_t id) { + provides { + interface BlockingReceive; + interface Packet; + } +} + +implementation { + components BlockingCollectionReceiverP, + CollectionC as Collector; + + BlockingReceive = BlockingCollectionReceiverP.BlockingReceive[id]; + Packet = Collector; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverP.nc new file mode 100644 index 00000000..5214d865 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionReceiverP.nc @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +configuration BlockingCollectionReceiverP { + provides { + interface BlockingReceive[collection_id_t id]; + interface BlockingReceive as BlockingReceiveAny; + } +} + +implementation { + components new BlockingAMReceiverImplP() as BlockingCollectionReceiverImplP, + CollectionC as Collector, + ThreadTimersC, + MainC, + SystemCallC, + SystemCallQueueC, + TinyThreadSchedulerC; + + MainC.SoftwareInit -> BlockingCollectionReceiverImplP; + BlockingReceive = BlockingCollectionReceiverImplP; + BlockingReceiveAny = BlockingCollectionReceiverImplP; + + BlockingCollectionReceiverImplP.Receive -> Collector.Receive; + BlockingCollectionReceiverImplP.Timer -> ThreadTimersC; + BlockingCollectionReceiverImplP.SystemCallQueue -> SystemCallQueueC; + BlockingCollectionReceiverImplP.SystemCall -> SystemCallC; + BlockingCollectionReceiverImplP.ThreadScheduler -> TinyThreadSchedulerC; + BlockingCollectionReceiverImplP.Packet -> Collector; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderC.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderC.nc new file mode 100644 index 00000000..d2bea248 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderC.nc @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +#include + +generic configuration BlockingCollectionSenderC (collection_id_t collectid) { + provides { + interface BlockingSend; + interface Packet; + } +} + +implementation { + components new BlockingCollectionSenderP(collectid, unique(UQ_CTP_CLIENT)), + CollectionC as Collector; + + BlockingSend = BlockingCollectionSenderP; + Packet = Collector; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc new file mode 100644 index 00000000..3b321582 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +module BlockingCollectionSenderImplP { + provides { + interface BlockingSend[uint8_t client]; + interface Init; + } + + uses { + interface Send[uint8_t client]; + interface SystemCall; + interface Mutex; + interface Packet; + interface Leds; + } +} + +implementation { + typedef struct params { + message_t *msg; + uint8_t len; + error_t error; + } params_t; + + syscall_t* send_call; + mutex_t my_mutex; + + command error_t Init.init() + { + call Mutex.init(&my_mutex); + return SUCCESS; + } + + void sendTask(syscall_t *s) + { + params_t* p = s->params; + + p->error = call Send.send[s->id](p->msg, p->len); + if(p->error != SUCCESS) { + call SystemCall.finish(s); + } + } + + command error_t BlockingSend.send[uint8_t client](message_t *msg, uint8_t len) + { + syscall_t s; + params_t p; + call Mutex.lock(&my_mutex); + send_call = &s; + + p.msg = msg; + p.len = len; + + call SystemCall.start(&sendTask, &s, client, &p); + + atomic { + call Mutex.unlock(&my_mutex); + return p.error; + } + } + + event void Send.sendDone[uint8_t client](message_t* m, error_t error) + { + if (client == send_call->id) { + params_t* p; + + p = send_call->params; + p->error = error; + call SystemCall.finish(send_call); + } + } + + command error_t BlockingSend.cancel[uint8_t client](message_t* msg) + { + return call Send.cancel[client](msg); + } + + command uint8_t BlockingSend.maxPayloadLength[uint8_t client]() + { + return call Send.maxPayloadLength[client](); + } + + command void* BlockingSend.getPayload[uint8_t client](message_t* msg, uint8_t len) + { + return call Send.getPayload[client](msg, len); + } +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderP.nc new file mode 100644 index 00000000..f6c498ec --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderP.nc @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +generic configuration BlockingCollectionSenderP (collection_id_t collectid, uint8_t clientid) { + provides { + interface BlockingSend; + } +} + +implementation { + components BlockingCollectionSenderImplP, + CollectionC as Collector, + new CollectionIdP(collectid), + MutexC, + SystemCallC, + MainC, + LedsC; + + MainC.SoftwareInit -> BlockingCollectionSenderImplP; + BlockingSend = BlockingCollectionSenderImplP.BlockingSend[clientid]; + + BlockingCollectionSenderImplP.Mutex -> MutexC; + BlockingCollectionSenderImplP.SystemCall -> SystemCallC; + BlockingCollectionSenderImplP.Send -> Collector; + BlockingCollectionSenderImplP.Packet -> Collector; + BlockingCollectionSenderImplP.Leds -> LedsC; + + Collector.CollectionId[clientid] -> CollectionIdP; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperC.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperC.nc new file mode 100644 index 00000000..3cca7814 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperC.nc @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +generic configuration BlockingCollectionSnooperC (collection_id_t id) { + provides { + interface BlockingReceive as BlockingSnoop; + } +} + +implementation { + components BlockingCollectionSnooperP; + + BlockingSnoop = BlockingCollectionSnooperP.BlockingSnoop[id]; +} diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperP.nc new file mode 100644 index 00000000..31380a73 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/BlockingCollectionSnooperP.nc @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2008 Johns Hopkins University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without written + * agreement is hereby granted, provided that the above copyright + * notice, the (updated) modification history and the author appear in + * all copies of this source code. + * + * 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 COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, + * OR PROFITS) 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 Chieh-Jan Mike Liang + */ + +configuration BlockingCollectionSnooperP { + provides { + interface BlockingReceive as BlockingSnoop[collection_id_t id]; + interface BlockingReceive as BlockingSnoopAny; + } +} + +implementation { + components new BlockingAMReceiverImplP() as BlockingCollectionReceiverImplP, + CollectionC as Collector, + ThreadTimersC, + MainC, + SystemCallC, + SystemCallQueueC, + TinyThreadSchedulerC; + + MainC.SoftwareInit -> BlockingCollectionReceiverImplP; + BlockingSnoop = BlockingCollectionReceiverImplP; + BlockingSnoopAny = BlockingCollectionReceiverImplP; + + BlockingCollectionReceiverImplP.Receive -> Collector.Snoop; + BlockingCollectionReceiverImplP.Timer -> ThreadTimersC; + BlockingCollectionReceiverImplP.SystemCallQueue -> SystemCallQueueC; + BlockingCollectionReceiverImplP.SystemCall -> SystemCallC; + BlockingCollectionReceiverImplP.ThreadScheduler -> TinyThreadSchedulerC; + BlockingCollectionReceiverImplP.Packet -> Collector; +} -- 2.39.2