From: liang_mike Date: Fri, 22 Aug 2008 04:09:48 +0000 (+0000) Subject: Unlike CTP, underlying LQI forwarding engine expects the outgoing packet to be update... X-Git-Tag: rc_6_tinyos_2_1_1~641 X-Git-Url: https://oss.titaniummirror.com/gitweb/?p=tinyos-2.x.git;a=commitdiff_plain;h=855190cd2b2dd10826e3b4b93c34125ab168fcec Unlike CTP, underlying LQI forwarding engine expects the outgoing packet to be updated with the collection ID already --- diff --git a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc b/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc deleted file mode 100644 index 3b321582..00000000 --- a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderImplP.nc +++ /dev/null @@ -1,111 +0,0 @@ -/* - * 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 deleted file mode 100644 index e2ba37e3..00000000 --- a/tos/lib/tosthreads/lib/net/BlockingCollectionSenderP.nc +++ /dev/null @@ -1,51 +0,0 @@ -/* - * 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 - * @author Kevin Klues - */ - -configuration BlockingCollectionSenderP { - provides { - interface BlockingSend[uint8_t id]; - } -} - -implementation { - components BlockingCollectionSenderImplP, - CollectionC as Collector, - MutexC, - SystemCallC, - MainC, - LedsC; - - MainC.SoftwareInit -> BlockingCollectionSenderImplP; - BlockingSend = BlockingCollectionSenderImplP.BlockingSend; - - BlockingCollectionSenderImplP.Mutex -> MutexC; - BlockingCollectionSenderImplP.SystemCall -> SystemCallC; - BlockingCollectionSenderImplP.Send -> Collector; - BlockingCollectionSenderImplP.Packet -> Collector; - BlockingCollectionSenderImplP.Leds -> LedsC; -} - diff --git a/tos/lib/tosthreads/lib/net/ctp/BlockingCollectionSenderImplP.nc b/tos/lib/tosthreads/lib/net/ctp/BlockingCollectionSenderImplP.nc new file mode 100644 index 00000000..3b321582 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/ctp/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/ctp/BlockingCollectionSenderP.nc b/tos/lib/tosthreads/lib/net/ctp/BlockingCollectionSenderP.nc new file mode 100644 index 00000000..e2ba37e3 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/ctp/BlockingCollectionSenderP.nc @@ -0,0 +1,51 @@ +/* + * 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 + * @author Kevin Klues + */ + +configuration BlockingCollectionSenderP { + provides { + interface BlockingSend[uint8_t id]; + } +} + +implementation { + components BlockingCollectionSenderImplP, + CollectionC as Collector, + MutexC, + SystemCallC, + MainC, + LedsC; + + MainC.SoftwareInit -> BlockingCollectionSenderImplP; + BlockingSend = BlockingCollectionSenderImplP.BlockingSend; + + BlockingCollectionSenderImplP.Mutex -> MutexC; + BlockingCollectionSenderImplP.SystemCall -> SystemCallC; + BlockingCollectionSenderImplP.Send -> Collector; + BlockingCollectionSenderImplP.Packet -> Collector; + BlockingCollectionSenderImplP.Leds -> LedsC; +} + diff --git a/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderC.nc b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderC.nc index e65b6954..eedf6c93 100644 --- a/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderC.nc +++ b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderC.nc @@ -46,5 +46,5 @@ implementation { BlockingSend = BlockingCollectionSenderP.BlockingSend[CLIENT_ID]; Packet = Collector; - Collector.CollectionId[CLIENT_ID] -> CollectionIdP; + BlockingCollectionSenderP.CollectionId[CLIENT_ID] -> CollectionIdP; } diff --git a/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderImplP.nc b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderImplP.nc new file mode 100644 index 00000000..1f886f49 --- /dev/null +++ b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderImplP.nc @@ -0,0 +1,116 @@ +/* + * 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; + interface CollectionPacket; + interface CollectionId[uint8_t client]; + } +} + +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; + + call CollectionPacket.setType(p->msg, call CollectionId.fetch[s->id]()); + 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); + } + + default command collection_id_t CollectionId.fetch[uint8_t id]() { return 0; } +} diff --git a/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderP.nc b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderP.nc new file mode 100644 index 00000000..fd2b301a --- /dev/null +++ b/tos/lib/tosthreads/lib/net/lqi/BlockingCollectionSenderP.nc @@ -0,0 +1,57 @@ +/* + * 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 + * @author Kevin Klues + */ + +configuration BlockingCollectionSenderP { + provides { + interface BlockingSend[uint8_t id]; + } + + uses { + interface CollectionId[uint8_t id]; + } +} + +implementation { + components BlockingCollectionSenderImplP, + CollectionC as Collector, + MutexC, + SystemCallC, + MainC, + LedsC; + + MainC.SoftwareInit -> BlockingCollectionSenderImplP; + BlockingSend = BlockingCollectionSenderImplP.BlockingSend; + CollectionId = BlockingCollectionSenderImplP; + + BlockingCollectionSenderImplP.Mutex -> MutexC; + BlockingCollectionSenderImplP.SystemCall -> SystemCallC; + BlockingCollectionSenderImplP.Send -> Collector; + BlockingCollectionSenderImplP.Packet -> Collector; + BlockingCollectionSenderImplP.Leds -> LedsC; + BlockingCollectionSenderImplP.CollectionPacket -> Collector; +} +