}
}
implementation {
- components ThreadP;
- DynamicThread = ThreadP;
- ThreadNotification = ThreadP.DynamicThreadNotification;
+ components DynamicThreadP;
+ components TinyThreadSchedulerC;
+ components BitArrayUtilsC;
+ components ThreadSleepC;
+ components TosMallocC;
+
+ DynamicThread = DynamicThreadP;
+ ThreadNotification = DynamicThreadP.ThreadNotification;
+
+ DynamicThreadP.ThreadSleep -> ThreadSleepC;
+ DynamicThreadP.ThreadScheduler -> TinyThreadSchedulerC;
+ DynamicThreadP.BitArrayUtils -> BitArrayUtilsC;
+ DynamicThreadP.Malloc -> TosMallocC;
+
+ components ThreadMapC;
+ ThreadMapC.DynamicThreadInfo -> DynamicThreadP;
+ DynamicThreadP.ThreadCleanup -> ThreadMapC.DynamicThreadCleanup;
+
+ components LedsC;
+ DynamicThreadP.Leds -> LedsC;
}
}
async event void ThreadCleanup.cleanup[uint8_t id]() {
+ call Leds.led2Toggle();
signal ThreadNotification.aboutToDestroy[id]();
atomic {
uint8_t adjusted_id = id-TOSTHREAD_NUM_STATIC_THREADS;
components TinyTaskSchedulerC;
components TinyThreadSchedulerC;
- components ThreadP;
+ components StaticThreadC;
// Export the SoftwareInit and Boot for applications
SoftwareInit = TinyOSMainP.SoftwareInit;
TinyTaskSchedulerC.ThreadScheduler -> TinyThreadSchedulerC;
//Wire up the TinyOS code to its thread
- ThreadP.StaticThreadInfo[TOSTHREAD_TOS_THREAD_ID] -> TinyOSMainP;
+ StaticThreadC.ThreadInfo[TOSTHREAD_TOS_THREAD_ID] -> TinyOSMainP;
TinyOSMainP.TinyOSBoot -> TinyThreadSchedulerC;
//Wire up the thread scheduler to start running
--- /dev/null
+/*
+ * 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 (klueska@cs.stanford.edu)
+ */
+
+configuration StaticThreadC {
+ provides {
+ interface Thread[uint8_t id];
+ interface ThreadNotification[uint8_t id];
+ }
+ uses {
+ interface ThreadInfo[uint8_t id];
+ interface ThreadFunction[uint8_t id];
+ interface ThreadCleanup[uint8_t id];
+ }
+}
+implementation {
+ components StaticThreadP;
+ components ThreadMapC;
+
+ Thread = StaticThreadP;
+ ThreadNotification = StaticThreadP;
+ ThreadCleanup = StaticThreadP;
+
+ StaticThreadP.ThreadInfo = ThreadInfo;
+ ThreadMapC.StaticThreadInfo = ThreadInfo;
+ StaticThreadP.ThreadFunction = ThreadFunction;
+
+ components ThreadSleepC;
+ components TinyThreadSchedulerC;
+ StaticThreadP.ThreadSleep -> ThreadSleepC;
+ StaticThreadP.ThreadScheduler -> TinyThreadSchedulerC;
+}
+
components MainC;
components new ThreadInfoP(stack_size, THREAD_ID);
- components ThreadP;
- components StaticThreadP;
+ components StaticThreadC;
+ components ThreadMapC;
MainC.SoftwareInit -> ThreadInfoP;
- Thread = ThreadP.StaticThread[THREAD_ID];
- ThreadNotification = ThreadP.StaticThreadNotification[THREAD_ID];
+ Thread = StaticThreadC.Thread[THREAD_ID];
+ ThreadNotification = StaticThreadC.ThreadNotification[THREAD_ID];
ThreadInfo = ThreadInfoP;
- ThreadP.StaticThreadInfo[THREAD_ID] -> ThreadInfoP;
- ThreadP.StaticThreadFunction[THREAD_ID] -> ThreadInfoP;
- StaticThreadP.ThreadCleanup[THREAD_ID] -> ThreadP.StaticThreadCleanup[THREAD_ID];
+
+ StaticThreadC.ThreadFunction[THREAD_ID] -> ThreadInfoP;
+ StaticThreadC.ThreadCleanup[THREAD_ID] -> ThreadMapC.StaticThreadCleanup[THREAD_ID];
+ StaticThreadC.ThreadInfo[THREAD_ID] -> ThreadInfoP;
components LedsC;
ThreadInfoP.Leds -> LedsC;
--- /dev/null
+/*
+ * 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 (klueska@cs.stanford.edu)
+ */
+
+configuration ThreadMapC {
+ provides {
+ interface ThreadCleanup as StaticThreadCleanup[uint8_t id];
+ interface ThreadCleanup as DynamicThreadCleanup[uint8_t id];
+ }
+ uses {
+ interface ThreadInfo as StaticThreadInfo[uint8_t id];
+ interface ThreadInfo as DynamicThreadInfo[uint8_t id];
+ }
+}
+implementation {
+ components TinyThreadSchedulerC;
+ components ThreadMapP;
+
+ TinyThreadSchedulerC.ThreadInfo -> ThreadMapP;
+ ThreadMapP.StaticThreadInfo = StaticThreadInfo;
+ ThreadMapP.DynamicThreadInfo = DynamicThreadInfo;
+
+ ThreadMapP.ThreadCleanup -> TinyThreadSchedulerC;
+ DynamicThreadCleanup = ThreadMapP.DynamicThreadCleanup;
+ StaticThreadCleanup = ThreadMapP.StaticThreadCleanup;
+}
+
--- /dev/null
+/*
+ * 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 <klueska@cs.stanford.edu>
+ */
+
+module ThreadMapP {
+ provides {
+ interface ThreadInfo[uint8_t id];
+ interface ThreadCleanup as StaticThreadCleanup[uint8_t id];
+ interface ThreadCleanup as DynamicThreadCleanup[uint8_t id];
+ }
+ uses {
+ interface ThreadInfo as StaticThreadInfo[uint8_t id];
+ interface ThreadInfo as DynamicThreadInfo[uint8_t id];
+ interface ThreadCleanup[uint8_t id];
+ interface Leds;
+ }
+}
+implementation {
+ async command thread_t* ThreadInfo.get[uint8_t id]() {
+ return call StaticThreadInfo.get[id]();
+ }
+ default async command thread_t* StaticThreadInfo.get[uint8_t id]() {
+ return call DynamicThreadInfo.get[id]();
+ }
+ default async command thread_t* DynamicThreadInfo.get[uint8_t id]() {
+ return call StaticThreadInfo.get[id]();
+ }
+ async event void ThreadCleanup.cleanup[uint8_t id]() {
+ signal StaticThreadCleanup.cleanup[id]();
+ }
+ default async event void StaticThreadCleanup.cleanup[uint8_t id]() {
+ signal DynamicThreadCleanup.cleanup[id]();
+ }
+ default async event void DynamicThreadCleanup.cleanup[uint8_t id]() {
+ signal StaticThreadCleanup.cleanup[id]();
+ }
+}
+
+
+
+
+++ /dev/null
-/*
- * 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 (klueska@cs.stanford.edu)
- */
-
-configuration ThreadP {
- provides {
- interface Thread as StaticThread[uint8_t id];
- interface DynamicThread;
- interface ThreadNotification as StaticThreadNotification[uint8_t id];
- interface ThreadNotification as DynamicThreadNotification[uint8_t id];
- interface ThreadCleanup as StaticThreadCleanup[uint8_t id];
- }
- uses {
- interface ThreadInfo as StaticThreadInfo[uint8_t id];
- interface ThreadFunction as StaticThreadFunction[uint8_t id];
- }
-}
-implementation {
- components StaticThreadP;
- components DynamicThreadP;
- components TinyThreadSchedulerC;
- components ThreadTimersC;
- components ThreadInfoMapP;
- components BitArrayUtilsC;
- components ThreadSleepC;
- components TosMallocC;
-
- StaticThread = StaticThreadP;
- StaticThreadNotification = StaticThreadP;
- StaticThreadP.ThreadInfo = StaticThreadInfo;
- StaticThreadP.ThreadFunction = StaticThreadFunction;
- StaticThreadP.ThreadSleep -> ThreadSleepC;
- StaticThreadP.ThreadScheduler -> TinyThreadSchedulerC;
-
- DynamicThread = DynamicThreadP;
- DynamicThreadP.ThreadNotification = DynamicThreadNotification;
- DynamicThreadP.ThreadSleep -> ThreadSleepC;
- DynamicThreadP.ThreadScheduler -> TinyThreadSchedulerC;
- DynamicThreadP.BitArrayUtils -> BitArrayUtilsC;
- DynamicThreadP.Malloc -> TosMallocC;
-
- TinyThreadSchedulerC.ThreadInfo -> ThreadInfoMapP;
- ThreadInfoMapP.StaticThreadInfo = StaticThreadInfo;
- ThreadInfoMapP.DynamicThreadInfo -> DynamicThreadP;
-
- ThreadInfoMapP.ThreadCleanup -> TinyThreadSchedulerC;
- DynamicThreadP.ThreadCleanup -> ThreadInfoMapP.DynamicThreadCleanup;
- StaticThreadCleanup = ThreadInfoMapP.StaticThreadCleanup;
-
- components LedsC;
- StaticThreadP.Leds -> LedsC;
- DynamicThreadP.Leds -> LedsC;
- ThreadInfoMapP.Leds -> LedsC;
-}
-
projects / tinyos-2.x.git / commitdiff