From: liang_mike Date: Thu, 24 Jul 2008 20:44:04 +0000 (+0000) Subject: Add tosthreads active message support for tda5250 X-Git-Tag: release_tinyos_2_1_0_0~28 X-Git-Url: https://oss.titaniummirror.com/gitweb/?p=tinyos-2.x.git;a=commitdiff_plain;h=2a2d4fe517e6cf092c375d7824ba077e2943033f Add tosthreads active message support for tda5250 --- diff --git a/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageC.nc b/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageC.nc new file mode 100644 index 00000000..cb7dbc01 --- /dev/null +++ b/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageC.nc @@ -0,0 +1,88 @@ +// $Id$ + +/* + * "Copyright (c) 2004-2005 The Regents of the University of California. + * 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 following + * two paragraphs and the author appear in all copies of this software. + * + * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT + * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF + * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS." + * + * Copyright (c) 2004-2005 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. + */ +/* + * + * Authors: Philip Levis + * Date last modified: $Id$ + * + */ + +/** + * + * The Active Message layer for the TDA5250 radio. This configuration + * just layers the AM dispatch (Tda5250ActiveMessageP) on top of the + * underlying TDA5250 radio packet. + * + * @author Philip Levis + * @author Vlado Handziski (TDA5250 modifications) + * @date July 20 2005 + */ + + +#include "Timer.h" + +configuration Tda5250ActiveMessageC { + provides { + interface SplitControl; + interface AMSend[am_id_t id]; + interface Receive[am_id_t id]; + interface Receive as ReceiveDefault[am_id_t id]; + interface Receive as Snoop[am_id_t id]; + interface Receive as SnoopDefault[am_id_t id]; + interface AMPacket; + interface Packet; + interface PacketAcknowledgements; + interface Tda5250Packet; + } +} +implementation { + + components Tda5250ActiveMessageP as AM, RadioDataLinkC as Radio; + components ActiveMessageAddressC as Address; + + SplitControl = Radio; + + Packet = Radio; + PacketAcknowledgements = Radio; + Tda5250Packet = AM; + + AMSend = AM; + Receive = AM.Receive; + ReceiveDefault = AM.ReceiveDefault; + Snoop = AM.Snoop; + SnoopDefault = AM.SnoopDefault; + AMPacket = AM; + + AM.SubSend -> Radio.Send; + AM.SubReceive -> Radio.Receive; + AM.SubPacket -> Radio.Packet; + AM.amAddress -> Address; +} diff --git a/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageP.nc b/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageP.nc new file mode 100644 index 00000000..59f8cd85 --- /dev/null +++ b/tos/lib/tosthreads/chips/tda5250/Tda5250ActiveMessageP.nc @@ -0,0 +1,181 @@ +// -*- mode:c++; indent-tabs-mode: nil -*- $Id$ +/* + * "Copyright (c) 2004-2005 The Regents of the University of California. + * 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 following + * two paragraphs and the author appear in all copies of this software. + * + * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT + * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF + * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS." + * + * Copyright (c) 2004-2005 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. + */ +/* + * + * Authors: Philip Levis + * Date last modified: $Id$ + * + */ + +/** + * @author Philip Levis + * @author Vlado Handziski (TDA5250 modifications) + * @date July 20 2005 + */ + +module Tda5250ActiveMessageP { + provides { + interface AMSend[am_id_t id]; + interface Receive[am_id_t id]; + interface Receive as ReceiveDefault[am_id_t id]; + interface Receive as Snoop[am_id_t id]; + interface Receive as SnoopDefault[am_id_t id]; + interface AMPacket; + interface Tda5250Packet; + } + uses { + interface Send as SubSend; + interface Receive as SubReceive; + interface Packet as SubPacket; + command am_addr_t amAddress(); + } +} +implementation { + + tda5250_header_t* getHeader( message_t* msg ) { + return (tda5250_header_t*)( msg->data - sizeof(tda5250_header_t) ); + } + + tda5250_metadata_t* getMetadata(message_t* amsg) { + return (tda5250_metadata_t*)((uint8_t*)amsg->footer + sizeof(message_radio_footer_t)); + } + + command error_t AMSend.send[am_id_t id](am_addr_t addr, + message_t* msg, + uint8_t len) { + tda5250_header_t* header = getHeader(msg); + header->type = id; + header->dest = addr; + header->src = call amAddress(); + return call SubSend.send(msg, len); + } + + command error_t AMSend.cancel[am_id_t id](message_t* msg) { + return call SubSend.cancel(msg); + } + + event void SubSend.sendDone(message_t* msg, error_t result) { + signal AMSend.sendDone[call AMPacket.type(msg)](msg, result); + } + + command uint8_t AMSend.maxPayloadLength[am_id_t id]() { + return call SubPacket.maxPayloadLength(); + } + + command void* AMSend.getPayload[am_id_t id](message_t* m, uint8_t len) { + return call SubPacket.getPayload(m, len); + } + + /* Receiving a packet */ + + event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len) { + if (call AMPacket.isForMe(msg)) { + return signal Receive.receive[call AMPacket.type(msg)](msg, payload, len); + } + else { + return signal Snoop.receive[call AMPacket.type(msg)](msg, payload, len); + } + } + + command am_addr_t AMPacket.address() { + return call amAddress(); + } + + command am_addr_t AMPacket.destination(message_t* amsg) { + tda5250_header_t* header = getHeader(amsg); + return header->dest; + } + + command void AMPacket.setDestination(message_t* amsg, am_addr_t addr) { + tda5250_header_t* header = getHeader(amsg); + header->dest = addr; + } + + command am_addr_t AMPacket.source(message_t* amsg) { + tda5250_header_t* header = getHeader(amsg); + return header->src; + } + + command void AMPacket.setSource(message_t* amsg, am_addr_t addr) { + tda5250_header_t* header = getHeader(amsg); + header->src = addr; + } + + command bool AMPacket.isForMe(message_t* amsg) { + return (call AMPacket.destination(amsg) == call AMPacket.address() || + call AMPacket.destination(amsg) == AM_BROADCAST_ADDR); + } + + command am_id_t AMPacket.type(message_t* amsg) { + tda5250_header_t* header = getHeader(amsg); + return header->type; + } + + command void AMPacket.setType(message_t* amsg, am_id_t type) { + tda5250_header_t* header = getHeader(amsg); + header->type = type; + } + + command void AMPacket.setGroup(message_t* msg, am_group_t group) { + return; + } + + command am_group_t AMPacket.group(message_t* msg) { + return TOS_AM_GROUP; + } + + command am_group_t AMPacket.localGroup() { + return TOS_AM_GROUP; + } + + async command uint8_t Tda5250Packet.getSnr(message_t* msg) { + return getMetadata(msg)->strength; + } + + default event void AMSend.sendDone[uint8_t id](message_t* msg, error_t err) { + return; + } + + default event message_t* Receive.receive[am_id_t id](message_t* msg, void* payload, uint8_t len) { + return signal ReceiveDefault.receive[id](msg, payload, len); + } + + default event message_t* ReceiveDefault.receive[am_id_t id](message_t* msg, void* payload, uint8_t len) { + return msg; + } + + default event message_t* Snoop.receive[am_id_t id](message_t* msg, void* payload, uint8_t len) { + return signal SnoopDefault.receive[id](msg, payload, len); + } + + default event message_t* SnoopDefault.receive[am_id_t id](message_t* msg, void* payload, uint8_t len) { + return msg; + } +}