PowerManager.AsyncStdControl -> MyComponentP.AsyncStdControl;
// PowerManager.StdControl -> MyComponentP.StdControl;
// PowerManager.SplitControl -> MyComponentP.SplitControl;
- PowerManager.ResourceController -> Arbiter.ResourceController;
+ PowerManager.ResourceDefaultOwner -> Arbiter.ResourceDefaultOwner;
PowerManager.ArbiterInfo -> Arbiter.ArbiterInfo;
MyComponentP.Leds -> LedsC;
ResourceRequested = Arbiter;
ResourceConfigure = Arbiter;
SharedResourceImplP.ArbiterInfo -> Arbiter;
- PowerManager.ResourceController -> Arbiter;
+ PowerManager.ResourceDefaultOwner -> Arbiter;
PowerManager.SplitControl -> ResourceP;
SharedResourceImplP.ResourceOperations -> ResourceP;
SplitControlPowerManagerC.SplitControl -> HplSensirionSht11P;
SplitControlPowerManagerC.ArbiterInit -> Arbiter.Init;
SplitControlPowerManagerC.ArbiterInfo -> Arbiter.ArbiterInfo;
- SplitControlPowerManagerC.ResourceController -> Arbiter.ResourceController;
+ SplitControlPowerManagerC.ResourceDefaultOwner -> Arbiter.ResourceDefaultOwner;
}
</pre>
<pre class="literal-block">
</p>\r
\r
<p>\r
-Shared resources are essentially built on top of dedicated resources, with access to them being controlled by an arbiter component. In this way, <b>power managers</b> can be used to automatically control the power state of these resources through their <tt>AsyncStdControl</tt>, <tt>StdControl</tt>, or <tt>SplitControl</tt> interfaces. They communicate with the arbiter (through the use of a <tt>ResourceController</tt> interface), monitoring whether the resource is being used by any of its clients and powering it on/off accordingly. The figure below shows how an arbiter component and a power manager can be wired together to provide arbitration and automatic power management for a shared resource.\r
+Shared resources are essentially built on top of dedicated resources, with access to them being controlled by an arbiter component. In this way, <b>power managers</b> can be used to automatically control the power state of these resources through their <tt>AsyncStdControl</tt>, <tt>StdControl</tt>, or <tt>SplitControl</tt> interfaces. They communicate with the arbiter (through the use of a <tt>ResourceDefaultOwner</tt> interface), monitoring whether the resource is being used by any of its clients and powering it on/off accordingly. The figure below shows how an arbiter component and a power manager can be wired together to provide arbitration and automatic power management for a shared resource.\r
</p>\r
\r
<center>\r
</center>\r
\r
<p>\r
-The arbiter component provides the <tt>Resource</tt>, <tt>ArbiterInfo</tt>, <tt>ResourceRequested</tt>, and <tt>ResourceController</tt> interfaces and uses the <tt>ResourceConfigure</tt> interface. The power manager doesn't provide any interfaces, but uses one of either the <tt>AsyncStdControl</tt>, <tt>StdControl</tt>, or <tt>SplitControl</tt> interfaces from the underlying resource, as well as the <tt>ResourceController</tt> interface provided by the arbiter. The figure below shows how these interface are then wired together with the implementation of a shared resource. Please refer to TEP 108 for more information on arbiters and TEP 115 for more information on Power Managers.\r
+The arbiter component provides the <tt>Resource</tt>, <tt>ArbiterInfo</tt>, <tt>ResourceRequested</tt>, and <tt>ResourceDefaultOwner</tt> interfaces and uses the <tt>ResourceConfigure</tt> interface. The power manager doesn't provide any interfaces, but uses one of either the <tt>AsyncStdControl</tt>, <tt>StdControl</tt>, or <tt>SplitControl</tt> interfaces from the underlying resource, as well as the <tt>ResourceDefaultOwner</tt> interface provided by the arbiter. The figure below shows how these interface are then wired together with the implementation of a shared resource. Please refer to TEP 108 for more information on arbiters and TEP 115 for more information on Power Managers.\r
</p>\r
\r
<center>\r
ResourceRequested = Arbiter;\r
ResourceConfigure = Arbiter;\r
SharedResourceImplP.ArbiterInfo -> Arbiter;\r
- PowerManager.ResourceController -> Arbiter;\r
+ PowerManager.ResourceDefaultOwner -> Arbiter;\r
\r
PowerManager.SplitControl -> ResourceP;\r
SharedResourceImplP.ResourceOperations -> ResourceP;\r
SplitControlPowerManagerC.SplitControl -> HplSensirionSht11P;
SplitControlPowerManagerC.ArbiterInit -> Arbiter.Init;
SplitControlPowerManagerC.ArbiterInfo -> Arbiter.ArbiterInfo;
- SplitControlPowerManagerC.ResourceController -> Arbiter.ResourceController;
+ SplitControlPowerManagerC.ResourceDefaultOwner -> Arbiter.ResourceDefaultOwner;
}
::
provides {
interface At45db;
interface Resource[uint8_t client];
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
At45db = At45dbP;
Resource = Arbiter;
- ResourceController = Arbiter;
+ ResourceDefaultOwner = Arbiter;
ArbiterInfo = Arbiter;
MainC.SoftwareInit -> At45dbP;
Atm128AdcP.Atm128Calibrate -> PlatformC;
PM.AsyncStdControl -> Atm128AdcP;
- PM.ResourceController -> AdcArbiter;
+ PM.ResourceDefaultOwner -> AdcArbiter;
}
I2C.Atm128I2C -> Master;
Power.AsyncStdControl -> Master;
- Power.ResourceController -> Arbiter;
+ Power.ResourceDefaultOwner -> Arbiter;
Master.I2C -> HplAtm128I2CBusC;
Master.ReadDebugLeds -> NoLedsC;
UsartShareP.ArbiterInfo -> ArbiterC;
components new AsyncStdControlPowerManagerC() as PowerManagerC;
- PowerManagerC.ResourceController -> ArbiterC;
+ PowerManagerC.ResourceDefaultOwner -> ArbiterC;
components HplMsp430Usart1C as UsartC;
PowerManagerC.AsyncStdControl -> UsartC;
components new SplitControlDeferredPowerManagerC( 1024 ) as PowerManagerC;
PowerManagerC.SplitControl -> SectorP;
- PowerManagerC.ResourceController -> ArbiterC;
+ PowerManagerC.ResourceDefaultOwner -> ArbiterC;
PowerManagerC.ArbiterInfo -> ArbiterC;
components Stm25pSpiC as SpiC;
interface AsyncStdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
interface Timer<TMilli> as TimerMilli;
}
call TimerMilli.startOneShot(delay);
}
- async event void ResourceController.requested() {
+ async event void ResourceDefaultOwner.requested() {
stopTimer = TRUE;
post stopTimerTask();
call AsyncStdControl.start();
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.immediateRequested() {
+ async event void ResourceDefaultOwner.immediateRequested() {
stopTimer = TRUE;
post stopTimerTask();
call AsyncStdControl.start();
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.granted() {
+ async event void ResourceDefaultOwner.granted() {
post timerTask();
}
interface AsyncStdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
implementation {
- async event void ResourceController.requested() {
+ async event void ResourceDefaultOwner.requested() {
call AsyncStdControl.start();
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.immediateRequested() {
+ async event void ResourceDefaultOwner.immediateRequested() {
call AsyncStdControl.start();
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.granted() {
+ async event void ResourceDefaultOwner.granted() {
call PowerDownCleanup.cleanup();
call AsyncStdControl.stop();
}
interface AsyncStdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.AsyncStdControl = AsyncStdControl;
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
PowerManager.TimerMilli -> TimerMilliC;
interface AsyncStdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
}
interface SplitControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
interface Timer<TMilli> as TimerMilli;
}
call TimerMilli.startOneShot(delay);
}
- async event void ResourceController.requested() {
+ async event void ResourceDefaultOwner.requested() {
if(stopping == FALSE) {
stopTimer = TRUE;
post startTask();
else atomic requested = TRUE;
}
- async event void ResourceController.immediateRequested() {
+ async event void ResourceDefaultOwner.immediateRequested() {
}
default command error_t StdControl.start() {
}
event void SplitControl.startDone(error_t error) {
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.granted() {
+ async event void ResourceDefaultOwner.granted() {
post timerTask();
}
interface SplitControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
call SplitControl.stop();
}
- async event void ResourceController.requested() {
+ async event void ResourceDefaultOwner.requested() {
if(stopping == FALSE) {
post startTask();
}
else requested = TRUE;
}
- async event void ResourceController.immediateRequested() {
+ async event void ResourceDefaultOwner.immediateRequested() {
}
default command error_t StdControl.start() {
}
event void SplitControl.startDone(error_t error) {
- call ResourceController.release();
+ call ResourceDefaultOwner.release();
}
- async event void ResourceController.granted() {
+ async event void ResourceDefaultOwner.granted() {
atomic stopping = TRUE;
post stopTask();
}
interface SplitControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
PowerManager.TimerMilli -> TimerMilliC;
interface SplitControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
}
interface StdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
PowerManager.TimerMilli -> TimerMilliC;
interface StdControl;
interface PowerDownCleanup;
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
}
PowerManager.PowerDownCleanup = PowerDownCleanup;
- PowerManager.ResourceController = ResourceController;
+ PowerManager.ResourceDefaultOwner = ResourceDefaultOwner;
PowerManager.ArbiterInfo = ArbiterInfo;
}
UsartShareP.ArbiterInfo -> ArbiterC;
// components new AsyncStdControlDeferredPowerManagerC(1) as PowerManagerC;
-// PowerManagerC.ResourceController -> ArbiterC;
+// PowerManagerC.ResourceDefaultOwner -> ArbiterC;
components HplMsp430Usart0C as UsartC;
//PowerManagerC.AsyncStdControl -> UsartC;
components new SplitControlPowerManagerC();
SplitControlPowerManagerC.SplitControl -> HplSensirionSht11P;
SplitControlPowerManagerC.ArbiterInfo -> Arbiter.ArbiterInfo;
- SplitControlPowerManagerC.ResourceController -> Arbiter.ResourceController;
+ SplitControlPowerManagerC.ResourceDefaultOwner -> Arbiter.ResourceDefaultOwner;
}
* intended use.<br><br>
*
* This component provides the Resource, ResourceRequested, ArbiterInfo,
- * and ResourceController interfaces and uses the ResourceConfigure interface as
+ * and ResourceDefaultOwner interfaces and uses the ResourceConfigure interface as
* described in TEP 108. It provides arbitration to a shared resource.
* An Queue is used to keep track of which users have put
* in requests for the resource. Upon the release of the resource by one
* of these users, the queue is checked and the next user
* that has a pending request will ge granted control of the resource. If
- * there are no pending requests, then the user of the ResourceController
+ * there are no pending requests, then the user of the ResourceDefaultOwner
* interface gains access to the resource, and holds onto it until
* another user makes a request.
*
provides {
interface Resource[uint8_t id];
interface ResourceRequested[uint8_t id];
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
uses {
}
else return call Queue.enqueue(id);
}
- signal ResourceController.requested();
+ signal ResourceDefaultOwner.requested();
return SUCCESS;
}
}
else return FAIL;
}
- signal ResourceController.immediateRequested();
+ signal ResourceDefaultOwner.immediateRequested();
if(resId == id) {
call ResourceConfigure.configure[resId]();
return SUCCESS;
else {
resId = CONTROLLER_ID;
state = RES_CONTROLLED;
- signal ResourceController.granted();
+ signal ResourceDefaultOwner.granted();
}
call ResourceConfigure.unconfigure[id]();
}
return FAIL;
}
- async command error_t ResourceController.release() {
+ async command error_t ResourceDefaultOwner.release() {
atomic {
if(resId == CONTROLLER_ID) {
if(state == RES_GRANTING) {
}
}
- async command uint8_t ResourceController.isOwner() {
+ async command uint8_t ResourceDefaultOwner.isOwner() {
return call Resource.isOwner[CONTROLLER_ID]();
}
}
default async event void ResourceRequested.immediateRequested[uint8_t id]() {
}
- default async event void ResourceController.granted() {
+ default async event void ResourceDefaultOwner.granted() {
}
- default async event void ResourceController.requested() {
- call ResourceController.release();
+ default async event void ResourceDefaultOwner.requested() {
+ call ResourceDefaultOwner.release();
}
- default async event void ResourceController.immediateRequested() {
- call ResourceController.release();
+ default async event void ResourceDefaultOwner.immediateRequested() {
+ call ResourceDefaultOwner.release();
}
default async command void ResourceConfigure.configure[uint8_t id]() {
}
provides {
interface Resource[uint8_t id];
interface ResourceRequested[uint8_t id];
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
uses interface ResourceConfigure[uint8_t id];
Resource = Arbiter;
ResourceRequested = Arbiter;
- ResourceController = Arbiter;
+ ResourceDefaultOwner = Arbiter;
ArbiterInfo = Arbiter;
ResourceConfigure = Arbiter;
*
* This component provides the Resource, ArbiterInfo, and Resource
* Controller interfaces and uses the ResourceConfigure interface as
- * described in TEP 108. An additional ResourceController interface is
+ * described in TEP 108. An additional ResourceDefaultOwner interface is
* provided to allow clients of differing Priorities to control the
* Resource according to some policy implemented in an external
* component. This component provides arbitration to a shared resource in
provides {
interface Init;
interface Resource[uint8_t id];
- interface ResourceController as HighPriorityClient;
- interface ResourceController as LowPriorityClient;
+ interface ResourceDefaultOwner as HighPriorityClient;
+ interface ResourceDefaultOwner as LowPriorityClient;
interface ArbiterInfo;
}
uses {
provides {
interface Resource[uint8_t id];
interface ResourceRequested[uint8_t id];
- interface ResourceController;
+ interface ResourceDefaultOwner;
interface ArbiterInfo;
}
uses interface ResourceConfigure[uint8_t id];
Resource = Arbiter;
ResourceRequested = Arbiter;
- ResourceController = Arbiter;
+ ResourceDefaultOwner = Arbiter;
ArbiterInfo = Arbiter;
ResourceConfigure = Arbiter;