1 \documentclass[../thesis.tex
]{subfiles
}
4 \ifSubfilesClassLoaded{
8 \chapter{\Gls{TOP
} for the
\gls{IOT
}}
9 \begin{chapterabstract
}
10 This chapter introduces
\gls{MTASK
} and puts it into perspective compared to traditional microprocessor programming.
12 Traditionally, the first program that one writes when trying a new language is the so called
\emph{Hello World!
} program.
13 This program has the single task of printing the text
\emph{Hello World!
} to the screen and exiting again, useful to become familiarised with the syntax and verify that the toolchain and runtime environment is working.
14 On microprocessors, there often is no screen for displaying text.
15 Nevertheless, almost always there is a monochrome $
1\times1$ pixel screen, namely an---often builtin---
\gls{LED
}.
16 The
\emph{Hello World!
} equivalent on microprocessors blinks this
\gls{LED
}.
18 \Cref{lst:arduinoBlink
} shows how the logic of a blink program might look when using
\gls{ARDUINO
}'s
\gls{CPP
} dialect.
19 Every
\gls{ARDUINO
} program contains a
\arduinoinline{setup
} and a
\arduinoinline{loop
} function.
20 The
\arduinoinline{setup
} function is executed only once on boot, the
\arduinoinline{loop
} function is continuously called afterwards and contains the event loop.
21 After setting the
\gls{GPIO
} pin to the correct mode, blink's
\arduinoinline{loop
} function alternates the state of the pin representing the
\gls{LED
} between
\arduinoinline{HIGH
} and
\arduinoinline{LOW
}, turning the
\gls{LED
} off and on respectively.
22 In between it waits for
500 milliseconds so that the blinking is actually visible for the human eye.
23 Compiling this results in a binary firmware that needs to be flashed onto the program memory.
25 Translating the traditional blink program to
\gls{MTASK
} can almost be done by simply substituting some syntax as seen in
\cref{lst:blinkImp
}.
26 E.g.\
\cleaninline{digitalWrite
} becomes
\cleaninline{writeD
}, literals are prefixed with
\cleaninline{lit
} and the pin to blink is changed to represent the actual pin for the builtin
\gls{LED
} of the device used in the exercises.
27 In contrast to the imperative
\gls{CPP
} dialect,
\gls{MTASK
} is a
\gls{TOP
} language and therefore there is no such thing as a loop, only task combinators to combine tasks.
28 To simulate a loop, the
\cleaninline{rpeat
} task can be used, this task executes the argument task and, when stable, reinstates it.
29 The body of the
\cleaninline{rpeat
} contains similarly named tasks to write to the pins and to wait in between.
30 The tasks are connected using the sequential
\cleaninline{>>|.
} combinator that for all current intents and purposes executes the tasks after each other.
33 \begin{subfigure
}[b
]{.5\linewidth}
34 \begin{lstArduino
}[caption=
{Blink program.
},label=
{lst:arduinoBlink
}]
40 digitalWrite(D2, HIGH);
42 digitalWrite(D2, LOW);
46 \begin{subfigure
}[b
]{.5\linewidth}
47 \begin{lstClean
}[caption=
{Blink program.
},label=
{lst:blinkImp
}]
49 blink :: Main (MTask v ()) | mtask v
51 declarePin D4 PMOutput
\d4->
61 \chapter{The
\gls{MTASK
} \gls{DSL
}}
62 \begin{chapterabstract
}
63 This chapter serves as a complete guide to the
\gls{MTASK
} language, from an
\gls{MTASK
} programmer's perspective.
66 The
\gls{MTASK
} system is a
\gls{TOP
} programming environment for programming microprocessors.
67 It is implemented as an
\gls{EDSL
} in
\gls{CLEAN
} using class-based---or tagless-final---embedding (See~
\cref{ssec:tagless
}).
68 Due to the nature of the embedding technique, it is possible to have multiple interpretations of---or views on---programs written in the
\gls{MTASK
} language.
73 This interpretation converts the expression to a string representation.
76 The simulator converts the expression to a ready-for-work
\gls{ITASK
} simulation in which the user can inspect and control the simulated peripherals and see the internal state of the tasks.
79 The compiler compiles the
\gls{MTASK
} program at runtime to a specialised bytecode.
80 Using a handful of integration functions and tasks,
\gls{MTASK
} tasks can be executed on microprocessors and integrated in
\gls{ITASK
} as if they were regular
\gls{ITASK
} tasks.
81 Furthermore, with special language constructs,
\glspl{SDS
} can be shared between
\gls{MTASK
} and
\gls{ITASK
} programs.
85 To leverage the type checker of the host language, types in the
\gls{MTASK
} language are expressed as types in the host language, to make the language type safe.
86 However, not all types in the host language are suitable for microprocessors that may only have
2KiB of
\gls{RAM
} so class constraints are therefore added to the
\gls{DSL
} functions.
87 The most used class constraint is the
\cleaninline{type
} class collection containing functions for serialization, printing,
\gls{ITASK
} constraints etc.
88 Many of these functions can be derived using generic programming.
89 An even stronger restriction on types is defined for types that have a stack representation.
90 This
\cleaninline{basicType
} class has instances for many
\gls{CLEAN
} basic types such as
\cleaninline{Int
},
\cleaninline{Real
} and
\cleaninline{Bool
}.
91 The class constraints for values in
\gls{MTASK
} are omnipresent in all functions and therefore often omitted throughout throughout the chapters for brevity and clarity.
97 \gls{CLEAN
}/
\gls{MTASK
} &
\gls{CPP
} type &
\textnumero{}bits\\
99 \cleaninline{Bool
} &
\cinline{bool
} &
16\\
100 \cleaninline{Char
} &
\cinline{char
} &
16\\
101 \cleaninline{Int
} &
\cinline{int16_t
} &
16\\
102 \cleaninline{:: Long
} &
\cinline{int32_t
} &
32\\
103 \cleaninline{Real
} &
\cinline{float
} &
32\\
104 \cleaninline{:: T = A | B | C
} &
\cinline{enum
} &
16\\
107 \caption{Mapping from
\gls{CLEAN
}/
\gls{MTASK
} data types to
\gls{CPP
} datatypes.
}%
108 \label{tbl:mtask-c-datatypes
}
111 The
\gls{MTASK
} language consists of a core collection of type classes bundled in the type class
\cleaninline{class mtask
}.
112 Every interpretation implements the type classes in the
\cleaninline{mtask
} class
113 There are also
\gls{MTASK
} extensions that not every interpretation implements such as peripherals and integration with
\gls{ITASK
}.
115 \Cref{lst:constraints
} contains the definitions for the type constraints and shows some example type signatures for typical
\gls{MTASK
} expressions and tasks.
117 \begin{lstClean
}[caption=
{Classes and class collections for the
\gls{MTASK
} language.
},label=
{lst:constraints
}]
118 class type t | iTask, ... ,fromByteCode, toByteCode t
119 class basicType t | type t where ...
121 class mtask v | expr, ..., int, real, long v
123 someExpr :: v Int | mtask v
124 tempTask :: MTask v Bool | mtask, dht v
127 \section{Expressions
}
128 \Cref{lst:expressions
} shows the
\cleaninline{expr
} class containing the functionality to lift values from the host language to the
\gls{MTASK
} language (
\cleaninline{lit
}), to do basic arithmetics and conditional execution.
129 For every common arithmetic operator in the host language, an
\gls{MTASK
} variant is present, suffixed by a period to not clash with
\gls{CLEAN
}'s builtin operators.
131 \begin{lstClean
}[caption=
{The
\gls{MTASK
} class for expressions
},label=
{lst:expressions
}]
133 lit :: t -> v t | type t
134 (+.) infixl
6 :: (v t) (v t) -> v t | basicType, +, zero t
135 (-.) infixl
6 :: (v t) (v t) -> v t | basicType, -, zero t
136 (*.) infixl 7 :: (v t) (v t) -> v t | basicType, *, zero, one t
137 (/.) infixl 7 :: (v t) (v t) -> v t | basicType, /, zero t
138 (&.) infixr 3 :: (v Bool) (v Bool) -> v Bool
139 (|.) infixr 2 :: (v Bool) (v Bool) -> v Bool
140 Not :: (v Bool) -> v Bool
141 (==.) infix 4 :: (v a) (v a) -> v Bool | Eq, basicType a
142 (!=.) infix 4 :: (v a) (v a) -> v Bool | Eq, basicType a
143 (<.) infix 4 :: (v a) (v a) -> v Bool | Ord, basicType a
144 (>.) infix 4 :: (v a) (v a) -> v Bool | Ord, basicType a
145 (<=.) infix 4 :: (v a) (v a) -> v Bool | Ord, basicType a
146 (>=.) infix 4 :: (v a) (v a) -> v Bool | Ord, basicType a
147 If :: (v Bool) (v t) (v t) -> v t | type t
150 Conversion to-and-fro data types is available through the overloaded functions \cleaninline{int}, \cleaninline{long} and \cleaninline{real}.
153 class int v a :: (v a) -> v Int
154 class real v a :: (v a) -> v Real
155 class long v a :: (v a) -> v Long
158 Finally, values from the host language must be explicitly lifted to the \gls{MTASK} language using the \cleaninline{lit} function.
159 For convenience, there are many lower-cased macro definitions for often used constants as can be seen in \cref{lst:convenience_lits}
161 \begin{lstClean}[label={lst:convenience_lits}]
167 \subsection{Functions}
170 \subsection{Basic tasks}
171 \subsubsection{Peripherals}
172 \subsection{Task combinators}
173 \subsubsection{Parallel}
174 \subsubsection{Sequential}
175 \subsubsection{Miscellaneous}
176 \subsection{\glspl{SDS}}
178 \chapter{Green computing with \gls{MTASK}}
180 \chapter{Integration with \gls{ITASK}}
183 \section{Lift \glspl{SDS}}
185 \chapter{Implementation}
186 IFL19 paper, bytecode instructieset~\cref{chp:bytecode_instruction_set}
188 \section{Integration with \gls{ITASK}}
191 \input{subfilepostamble}