mate-manual.tex

tinyos中文手册,是根据tinyos系统自带手册翻译过来的,虽然质量不好,但是对英文不强的人还是有用的

access, or after the tail on assignment (append). For example:

\begin{quotation}
\begin{verbatim}

buffer aggBuffer;
shared val;

val = aggBuffer[];             ! Val is the last value in the buffer
aggBuffer[] = call light();    ! Append a new light value to the buffer

\end{verbatim}
\end{quotation}

\subsection{Functions}

The above code examples used several functions, such as {\tt light()},
{\tt bsorta()}, and {\tt cast()}. Programs invoke functions using the
{\tt call} keyword. Functions take a fixed number (zero or more) of
parameters. For example, {\tt bclear()} takes a single parameter, a
buffer to clear, and {\tt rand()} takes no parameters. Some functions
return values (e.g., {\tt rand()}), while others do not (e.g., {\tt
bsorta()}).

Function parameters may have type requirements. However, as TinyScript
is a dynamically typed language, these types are not checked at
compile time. For example, {\tt bclear()} takes a single parameter, a
buffer. Passing it an integer will cause an error.

Return values of function calls may be ignored. For example,

\begin{quotation}
\begin{verbatim}

call rand();

\end{verbatim}
\end{quotation}

is a valid program.

Every \mate VM has a set of functions it provides as primitives (they
are built into the VM). Customizing this set of functions is one of
the ways that \mate programming environments can be tailored to
specific deployments or applications (Section~\ref{sec:building}
describes the details of how to do so). A \mate scripting environment
should provide information on what functions are available, as well as
what they do, their required parameters, and return values.

The return values of functions can be directly used as values or
parameters to functions:

\begin{quotation}
\begin{verbatim}

buffer aggBuf;
shared val;

val = aggBuf[call rand() \% call bsize(aggBuff)]; ! Hope size isn't zero
val = call sqrt(call bsize(aggBuff)) + 2;         
\end{verbatim}
\end{quotation}

Note that assigning to a buffer is very different than assigning to an
element of a buffer.

\begin{quotation}
\begin{verbatim}

buffer aggBuf;
buffer aggBuf2
shared val;

aggBuf2 = aggBuf;
aggBuf[] = val;
\end{verbatim}
\end{quotation}

Currently, TinyScript does not support user-written functions.


\subsection{Arithmetic, Logic, and Conditionals}

Figure~\ref{fig:arithmetic} shows the set of arithmetic operations
TinyScript provides, as well as their syntax.

\begin{figure}
\centering
\subfigure[Arithmetic Operations]{\scriptsize
\begin{tabular}{|l|c|l|} \hline
Name           & Operator & Example \\ \hline
Addition       & + & val = val + 2;\\ \hline
Subtraction    & - & val = a - b; \\ \hline
Division       & / & val = call bsize() / 2; \\ \hline
Multiplication & * & val = 2 * b; \\ \hline
Exponentiation & $^{\wedge}$ & val = val $^{\wedge}$ 2 \\ \hline
\end{tabular}
\label{fig:arithmetic}
}
\subfigure[Comparison Operations]{\scriptsize
\begin{tabular}{|l|c|l|} \hline
Name                  & Operator & Example \\ \hline
Less than             & $<$  & val = val $<$ 2;\\ \hline
Greater than          & $>$  & val = a $>$ b; \\ \hline
Less than or equal    & $<=$ & val = call bsize() $<=$ 8; \\ \hline
Greater than or equal & $>=$ & val = b $>=$ 2; \\ \hline
Not equal             & $<>$ & cond = val $<>$ b \\ \hline
\end{tabular}
\label{fig:comparison}
}
\caption{TinyScript Computational Primitives}
\label{fig:tscriptcomp}
\end{figure}



All of these operations have a shorthand (similar to the C language)
for self-assignment. For example, {\tt val *= 2;} is the same as {\tt
val = val * 2;}.

TinyScript also supports logical operations, which are show in
Figure~\ref{fig:logic}. All of these operations only accept integers
as operands. For the boolean operators (e.g., and, not), a value of
zero is considered false; all other values are considered true. All
operators use 0 as false and 1 as true. So, {\tt 1 and 2} resolves to
1, while {\tt 0 and 34} resolves to 0. Figure~\ref{fig:tables}
contains the truth tables for the boolean operators.

\begin{figure}
\centering
\scriptsize
\subfigure[Logical Operations] {
\begin{tabular}{|l|c|l|} \hline
Name           & Operator & Example \\ \hline
And          & AND, and        & ready = full and idle;\\ \hline
Or           & OR, or          & ready = full OR idle;\\ \hline
Not          & NOT, not        & ready = not idle; \\ \hline
Exclusive or & XOR, xor        & diff = a XOR b; \\ \hline
Equivalent   & EQV, eqv        & rval = a eqv b; \\ \hline
Implies      & IMP, imp        & ready = a imp b; \\ \hline
Logical And  & \&              & bits = packetbits \& mask; \\ \hline
Logical Or   & $\mid$          & bits = firstbit $\mid$ secondbi t; \\ \hline
Logical Not  & $^{\sim}$       & mask = $^{\sim}$bits; \\ \hline
\end{tabular}
\label{fig:logic}
}
\subfigure[Truth Tables] {
\begin{tabular}{|c||c|c||c|c||c|c||}\hline
&\multicolumn{2}{|c||}{and}&\multicolumn{2}{c||}{or}&\multicolumn{2}{c||}{not} \\ \hline
  & F & T & F & T & \multicolumn{2}{|c||}{} \\ \hline
F & {\bf F} & {\bf F} & {\bf F} & {\bf T} & \multicolumn{2}{|c||}{{\bf T}} \\ \hline
T & {\bf F} & {\bf T} & {\bf T} & {\bf T} & \multicolumn{2}{|c||}{{\bf F}} \\ \hline \hline
&\multicolumn{2}{|c|}{xor}&\multicolumn{2}{|c|}{eqv}&\multicolumn{2}{|c|}{imp} \\ \hline
  & F & T & F & T & F & T \\ \hline
F & {\bf F} & {\bf T} & {\bf T} & {\bf F} & {\bf T} & {\bf T} \\ \hline
T & {\bf T} & {\bf F} & {\bf F} & {\bf T} & {\bf F} & {\bf T} \\ \hline
\end{tabular}
}
\caption{TinyScript Logical Primitives}
\label{fig:tables}
\end{figure}

The logical operations manipulate integer bit fields. Instead of
manipulating the integer as a singe value, they operate on each bit,
in a manner similar to C operators. For example, {\tt 1 and 2}
resolves to 1, while {\tt 1 \& 2} resolves to zero (1 and 2 share no
common bits), and {\tt 1 $\mid$ 2} resolves to 3.

Finally, TinyScript has standard comparison operators, as shown in
Figure~\ref{fig:comparison}. They resolve to one if true, zero if
false.

\subsection{Control Structures}

TinyScript supports standard language control structures such as
conditionals and loops.

The first set of control structures, conditionals, take this form:

\begin{quotation}
\begin{verbatim}

if <expression> then                if <expression> then
 <block 1>                           <block 1>
end if                              else 
                                     <block 2>
                                    end if
\end{verbatim}
\end{quotation}


If expression resolves to true, then block 1 executes. If the
statement has an else clause and expression resolves to false, then
block 2 executes. There can be nested if-then statements:

\begin{quotation}
\begin{verbatim}
shared idle;
buffer buf;

if call bfull(buf) then
  idle = 0;
  if call rand() & 1 then
    call send(buf);
    call bclear(buf);
  end if
  idle = 1;
end if
\end{verbatim}
\end{quotation}

TinyScript provides loops through the {\tt for} construct. There are
two basic forms, unconditional and conditional. Unconditional (for-to)
loops run a specific number of times; their termination condition when
the loop variable takes a specific value. Conditional (for-until)
loops run until an arbitrary condition becomes true. {\tt next}
defines the end of the loop block, and increments the loop
variable. By default, the variable increments by one. However, the
increment step can be set with the {\tt step} keyword. In summary:

\begin{quotation}
\begin{verbatim}

for <x> = <expression> to <to-constant>
  ...
next <x>

for <x> = <expression> to <to-constant> step <step-constant>
  ...
next <x>

for <x> = <expression> until <until-exp>
  ...
next <x>

for <x> = <expression> step <step-constant> until <until-exp>
  ...
next <x>

\end{verbatim}
\end{quotation}

For example, this loop will run one hundred times, blinking the leds,

\begin{quotation}
\begin{verbatim}

private i;

for i = 1 to 100
  call leds(i & 7)
next i
\end{verbatim}
\end{quotation}

while this loop will put the values 1 to 21 in the buffer (when it has
ten values, it will be full),

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

call bclear(buf);
for i = 1 step 1 until i > 10
  buf[] = i * 2;
next i
\end{verbatim}
\end{quotation}

Standard while loops can be implemented by setting a step of
zero. This loop, for example, will put random values into a buffer
until it is full:

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

for i = 0 step 0 until call bfull(buf)
  buf[] = call rand();
next i
\end{verbatim}
\end{quotation}

Parenthesis pairs can be added to define precedence, or for readability.

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

call bclear(buf);
for i = 1 step 1 until i > 10
  buf[] = ((i * 2) + 1);
next i
i = (5 + 2 * 2);    ! i = 9
i = (5 + 2) * 2;    ! i = 14
i = ((((5))));      ! i = 5

\end{verbatim}
\end{quotation}


\subsection{Error Conditions}

Program errors can be divided into two classes: compile-time and
run-time. Compile-time errors cause the compiler to fail; they are
often language mistakes, such as passing too few parameters to a
function. Run-time errors are detected as a program runs on a \mate
VM, can cause the VM to stop execution and enter an error
condition. The error condition involves flashing all of the mote LEDS
simultaneously, and broadcasting an error message, alternating over
the radio and over the UART. Examples of run-time errors include type
checks (e.g., adding a sensor reading to an integer) and buffer
overflow (trying to put more in a buffer than it can hold).

Once a mote has entered an error condition, the only way to return it
to operation is to reprogram it; hopefully, the new program will not
have the error.


\subsection{Event Handlers}

All \mate scripts run in response to an event. A given \mate VM has a
static set of events that trigger execution. To program a \mate
network, one writes scripts for these event handlers. Some events,
such as Timer, are of general use. Timer executes periodically (e.g.,
every second). Other events have very narrow and specific uses. The
SendR event, for example, is triggered by the {\tt sendr()} function
and allows a program to modify packet headers, which is useful if
implementing an ad-hoc routing protocol.

The Once event is unusual; it only runs once, when new code is
installed for it. This allows users to manage a network more easily
than with periodic events. For example, one can write a Once handler
that changes a mote's radio transmit power; this need not run many
times, and doing so would be wasteful.

\subsection{Parallelism}
\label{sec:parallelism}

\mate VMs can run multiple event handlers can run simultaneously. When it installs
new code, the runtime determines which handlers can run concurrently in a safe manner,
and disallows parallelism that could corrupt data.

Handlers can declare two kinds of variables: {\tt private} and {\tt
shared}. Private variables are local to that handler; the statement
{\tt private a;} in two different handlers refers to two different
variables. In contrast, {\tt shared a;} in two different handlers
refer to the same variable. Using a shared variable, handers can pass
data to one another. Buffers are implictly shared variables.

For example, imagine a situation in which you want a program to
measure the maximum time that elapses between receiving packets. One
way to accomplish this is to use two handlers, Receive and Timer, with
two shared variables, {\tt current} and {\tt max}. Whenever Timer