tinyscript-manual.tex

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

\documentclass[12pt]{article}

\usepackage{graphicx}
\usepackage{graphics}
\usepackage{multicol}
\usepackage{epsfig,amsmath,amsfonts}
\usepackage{xspace}
\usepackage{subfigure}

\makeatletter                                   % Make '@' accessible. 
\oddsidemargin=0in                              % Left margin minus 1 inch.
\evensidemargin=0in                             % Same for even-numbered pages.
\marginparsep=0pt                               % Space between margin & text

\renewcommand{\baselinestretch}{1.2}              % Double spacing

\textwidth=6.5in                                % Text width (8.5in - margins).
\textheight=9in                                 % Body height (incl. footnotes)

\topmargin=0in                                  % Top margin minus 1 inch.
\headsep=0.0in                                  % Distance from header to body.
\skip\footins=4ex                               % Space above first footnote.
\hbadness=10000                                 % No "underfull hbox" messages.
\makeatother                                    % Make '@' special again.

\newcommand{\mate}{Mat\'{e}\xspace}
\newcommand{\bomb}{Bombilla\xspace}
\newcommand{\kw}[1]{{\tt #1}}
\newcommand{\grammarshift}{\vspace*{-.7cm}}
\newcommand{\grammarindent}{\hspace*{2cm}\= \\ \kill}
\newcommand{\opt}{$_{OPT}$}

\title{The TinyScript Language}
\author{Philip Levis\\[e-mail]}
\date{}

\begin{document}

%\fontfamily{cmss}                               % Make text sans serif.
%\fontseries{m}                                  % Medium spacing.
%\fontshape{n}                                   % Normal: not bold, etc.
%\fontsize{10}{10}                               % 10pt font, 10pt line spacing 

\maketitle
\vspace{2in}
\begin{center}
Version 1.0\\
July 12, 2004
\end{center}

\fontfamily{cmr}                                % Make text Roman (serif).
\fontseries{m}                                  % Medium spacing.
\fontshape{n}                                   % Normal: not bold, etc.
\fontsize{10}{10}                               % 10pt font, 10pt line spacing


\thispagestyle{empty}
\newpage
\tableofcontents
\newpage

\section{Introduction}

This document describes TinyScript, a language that the \mate VM
framework supports for programming sensor networks. TinyScript is an
imperative, BASIC-like language with dynamic typing and basic control
structures such as conditionals and loops. 

\section{Script Structure}
\label{sec:tinyscript}

This is an example TinyScript program that increments a counter:

\begin{quotation}
\begin{verbatim}

! Define a shared variable, counter
shared counter;

! Increment it
counter = counter + 1;

\end{verbatim}
\end{quotation}

In TinyScript programs, all variables must be declared before any
program statements. For example, the following program is invalid (and
will throw a compilation error):

\begin{quotation}
\begin{verbatim}

! Define a shared variable, counter
shared counter;

! Increment it
counter = counter + 1;

! Define a shared variable, index: ERROR
shared index;

\end{verbatim}
\end{quotation}

Statements generally end with a semicolon. {\tt !} declares the start
of a comment, which extends to the end of a line. For example,

\begin{quotation}
\begin{verbatim}

shared counter; ! Define a shared variable, counter
counter = counter + 1; ! Increment it

\end{verbatim}
\end{quotation}

is valid TinyScript code.

TinyScript function and variable identifiers are case insensitive:
{\tt var} is the same as {\tt VAR} or {\tt Var}. Identifiers are
composed of alphanumeric characters and the underscore ('\_'), but the
first character of an identifier must be a letter or the
underscore. The following are all valid identifiers:

\begin{verbatim}
temp
a51_b
TEMP
temp7
buffer_Index
_3
\end{verbatim}

The following are invalid identifiers:


\begin{verbatim}
@a
4b
sd?
a 5
\end{verbatim}


To be precise, identifiers must follow the pattern {\tt
[A-Za-z\_][A-Za-z0-9\_]*}.

Certain words are TinyScript keywords, and cannot be used in programs
to name variables or functions. In the above scripts, {\tt shared} is
a keyword, declaring {\tt counter} to be a shared variable. The full
list of keywords is:

\begin{verbatim}
not     and     or      xor     eqv     imp
for     to      next    step    until   while
end     private shared  buffer  if       then
else
\end{verbatim}

TinyScript function and variable identifiers are case insensitive:
{\tt var} is the same as {\tt VAR} or {\tt Var}. Keywords exist as
both their uppercase and lowercase versions: {\tt shared} can also be
written {\tt SHARED}, but cannot be written {\tt sHarEd}.

\section{Variables}
\label{sec:variables}

TinyScript programs have two basic variable types: scalars and
buffers. Scalars represent a single data item, such as an integer or a
sensor reading. Buffers are small collections of values. In the above
programs, the keyword {\tt shared} declared the variables to be
scalars. Handlers can declare two kinds of scalars: {\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, declared with {\tt buffer}, are
implicitly shared variables.

Both values and buffers are dynamically typed. That is, the variables
themselves have no explicit type in a program; instead, their type
is determined dynamically as a program runs. In this program,

\begin{quotation}
\begin{verbatim}

shared counter; 
shared sensor;
counter = random();
sensor = light();

\end{verbatim}
\end{quotation}

the variable {\tt counter} takes the type integer ({\tt rand()}
returns an integer) while {\tt sensor} takes the type light ({\tt
light()} returns a light value).

Types constrain how values can be modified, and how buffers can be
accessed. There is one basic scalar type, integer (16-bit, signed).
Additionally, every sensor has its own type. Integers can be modified
freely, through arithmetic, assignment, and other
transformation. Sensor readings, however, are immutable. You cannot
add two sensor readings, even if from the same sensor.

The idea is that sensor readings should only be what is actually read
from a sensor. Transformations on these readings should be
distinguishable from actual readings.  To modify sensor readings, they
must be cast to an integer with the {\tt int()} function. For example,
this program computes an exponentially weighted moving average of the
light sensor:

\begin{quotation}
\begin{verbatim}

shared sensor; 
shared aggregate;

sensor = light();
aggregate = (aggregate / 2) + (int(sensor) / 2); ! Cast light reading to integer

\end{verbatim}
\end{quotation}

Buffers also have a type, which defines what values can be placed in
it. A cleared buffer has no type, and takes the type of the first
value placed in it. In the following program, {\tt aggBuffer} is
cleared, which clears its type. An integer ({\tt aggregate}) is added
to the buffer, making the buffer of the type integer.

\begin{quotation}
\begin{verbatim}

shared sensor;
shared aggregate;
buffer aggBuffer;

sensor = light();
aggregate = aggregate + int(sensor); ! Cast light reading to integer
aggregate = aggregate / 2;

bclear(aggBuffer); ! Clear all buffer entries and type
aggBuffer[] = aggregate; ! Append aggregate value to buffer
                         ! Buffer is now of type integer

\end{verbatim}
\end{quotation}

Buffers have a fixed maximum size of ten values. The function {\tt
bfull()} can be used to see if a buffer is full, while {\tt bsize()}
indicates how many entries it currently has. Individual buffer values
can be accessed by indexing into a buffer. The following program
obtains the median value stored in a buffer:

\begin{quotation}
\begin{verbatim}

shared size;
shared median;
buffer aggBuffer;
 
bsorta(aggBuffer);        ! Sort buffer entries in ascending order
size = bsize(aggBuffer);  ! Number of entries in buffer
median = aggBuffer[size / 2];  ! Return median value

\end{verbatim}
\end{quotation}

An empty index value implies the tail (last value) of a buffer on
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[] = light();    ! Append a new light value to the buffer

\end{verbatim}
\end{quotation}

\section{Functions}

The above code examples used several functions, such as {\tt light()},
{\tt bsorta()}, and {\tt int()}. 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 dynamically typed, these types are not checked at compile time. For
example, {\tt bclear()} takes a single parameter, a buffer. Passing it
an integer will cause a run-time error.

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

\begin{quotation}
\begin{verbatim}

rand();

\end{verbatim}
\end{quotation}

is a valid program.

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[rand() \% bsize(aggBuff)]; ! Hope size isn't zero
val = sqrt(bsize(aggBuff)) + 2;         
\end{verbatim}
\end{quotation}

Note that assigning to a buffer is different than assigning to an
element of a buffer. Assigning a scalar to a buffer appends it. If a
scalar is assigned to an element of a buffer, the buffer is
dynamically sized to include that element if need be. Buffers can be
assigned to one another (which results in a copy), but a buffer cannot
be assigned to be the element of another buffer.

\begin{quotation}
\begin{verbatim}

buffer aggBuf;
buffer aggBuf2
shared val;

aggBuf2 = aggBuf;
aggBuf[] = val;
aggBuf2[val \% 8] = val;
aggBuf[1] = aggBuf2;  ! ERROR
\end{verbatim}
\end{quotation}

Currently, TinyScript does not support scripting functions.

\section{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