A Shallow Embedded, Type Safe Extendable DSL for the Arduino. Pieter Koopman

Transcription

1 A Shallow Embedded, Type Safe Extendable DSL for the Arduino Pieter Koopman

2 what is an Arduino? open source microprocessor board Ø 8-bit ATMega328 Ø 16 MHz Ø 32 KB flash memory Ø 2 KB RAM Ø big input / output connectors (14D, 6A) Ø USB port Ø boot loader Ø 1 on-board LED Ø cheap 2

3 why an Arduino very suited to handle sensors and actuators Ø sensors: buttons, temperature, heart rate, GPS,.. Ø actuators: lights, motors, robots, LCD, relay,.. Ø many shields available LCD, relay, GPS, keypad,.. shields can be stacked easy experimentation hence very suited for simple control tasks Ø integrate this with itasks Ø IoT Internet of Things 3

4 software on the Arduino no multitasking / no threads no operating system, just a tiny boot-loader your program has to do everything Ø setup: initialisation Ø loop: repeated ever after the setup programming language(s) for Arduino Ø C for all basic things Ø C++ like objects to control shields 4

5 'hello world' for Arduino blink the LED boolean ledon = false; void setup() { pinmode(13, OUTPUT); digitalwrite(13, LOW); } void loop() { ledon = not ledon; digitalwrite(13, ledon); delay(500); } busy-wait loop L L entire Arduino is sleeping 5

6 better 'hello world' for Arduino blink the LED boolean ledon = false; long lasttime = 0; void setup() { pinmode(13, OUTPUT); digitalwrite(13, LOW); } void loop() { } if (millis() / 500 > lasttime) { } ledon = not ledon; digitalwrite(13, ledon); lasttime += 1; J no delay 6

7 servomotor rotary actuator with control of angular position Ø duration of input pulse controls position PWM: pulse width modulation Ø Arduino ports can generate PWM signals 7

8 servo sweep program #include <Servo.h> Servo s; int pos = 10; int step = 1; long time = 0; // include library // create servo object // servo position // angle change // time of last change void setup() { s.attach( A5 ); // attach servo on pin A5 to object } void loop() { if (millis() / 25 > time) { // 40 step per second time += 1; pos += step; if (pos > 170 pos < 10) { // outside preferred angle region? step = - step; // turn the direction of the servo pos += step; } s.write( pos ); // set servo angle in degrees } } easy to combine with blink program 8

9 why a Domain Specific Language? the Arduino is very suited for low level I/O Ø we need this kind of control in itask, e.g. IoT running Clean on the Arduino is not feasible programming the Arduino in C and interfacing it with itask is tedious, error-prone detention work Embedded Domain Specific Language bridge the gap Ø single source of program Ø strong typing Ø extendable DSL new shields without recompiling Ø complete DSL control the parts of Clean inherited Ø multiple views compile, simulate, analyse,.. 9

10 implementing a DSL 1 a library with function and data types Ø shallow embedding of DSL Ø like the itask system: a DSL for task oriented programs Clean with EDSL program must run on Arduino this requires Clean on the Arduino Ø this cannot work Ø 32KB flash, 2KB ram, 8 bit, 16 MHz Ø 10

11 implementing a DSL 2 a library with function and data types Ø like the itask system: a DSL for task oriented programs running Clean with EDSL program on PC, remote control of Arduino Ø e.g. Firmata protocol, like harduino Ø can work requires much interaction between PC and Arduino Ø we want independent tasks at the Arduino Ø 11

12 implementing a DSL 3 EDSL should have clear border Ø DSL does not inherit everything from Clean DSL is an algebraic data type, deep embedding :: Expr = Num Int Bool Bool Add Expr Expr.. this does not prevent runtime type errors in DSL p = Add (Int 7) (Bool False) Ø we want a strongly typed DSL Ø 12

13 implementing a DSL 4 EDSL should have clear border Ø DSL does not inherit everything from Clean DSL is an generalized algebraic data type, GADT :: Expr a = Lit a Add (BM a Int) (Expr Int) (Expr Int).. this prevents runtime type errors in DSL p = Add bm (Lit 7) (Lit False) // this is rejected by the compiler q = Add bm (Lit 7) (Lit 36) Ø this is strongly typed DSL, Ø but the DSL cannot be extended without recompilation Ø 13

14 implementing a DSL 5 EDSL should have clear border Ø DSL does not inherit everything from Clean DSL is set of type constructor classes Ø strongly typed, have a border, have multiple views class expr v where lit :: t - > v t add :: (v Int) (v Int) - > v Int p :: a Int expr x p = add (lit 7) (lit 36) this solves our problems Ø 14

15 Show view of this DSL the DSL class expr v where lit :: t - > v t tostring t add :: (v Int) (v Int) - > v Int each view is an instance of this class Ø e.g. show = conversion to list of strings :: Show a = S [String] instance expr Show where we do not use argument a, but it must be there lit a = S [tostring a] add (S x) (S y) = S (["("] ++ x ++ ["+"] ++ y ++ [")"]) 15

16 Show view of this DSL 2 class expr v where lit :: t - > v t tostring t add :: (v Int) (v Int) - > v Int :: Show a = S [String] instance expr Show where lit a = S [tostring a] add (S x) (S y) = S (["("] ++ x ++ ["+"] ++ y ++ [")"]) Ø a DSL program p :: (v Int) expr v p = add (lit 7) (lit 36) Ø evaluating this program in the Show view Start = strings where (S strings) = p this yields ["(","7","+","36",")"] 16

17 Evaluation view of this DSL the DSL class expr v where lit :: t - > v t tostring t add :: (v Int) (v Int) - > v Int each view is an instance of this class Ø e.g. eval = conversion to single value :: Eval a = E a instance expr Eval where lit a = E a add (E x) (E y) = E (x + y) here we use argument a 17

18 Eval view of this DSL 2 class expr v where lit :: t - > v t tostring t add :: (v Int) (v Int) - > v Int :: Eval a = E a instance expr Eval where lit a = E a add (E x) (E y) = E (x + y) Ø a DSL program p :: (v Int) expr v p = add (lit 7) (lit 36) Ø evaluating this program in the both views Start = (val, strings) where (E val) = p (S strings) = p this yields (43,["(","7","+","36",")"]) 18

19 extending the DSL leave class expr untouched, define a new class Ø we do not break existing code and views class expr v where lit :: t - > v t tostring t add :: (v Int) (v Int) - > v Int class expr2 v where And :: (v Bool) (v Bool) - > v Bool Not :: (v Bool) - > v Bool equ :: (v a) (v a) - > v Bool ==, tostring a unchanged 19

20 extending the DSL 2: views make instances of Show and Eval for expr2 :: Show a = S [String] // unchanged instance expr2 Show where And (S x) (S y) = S (["("] ++ x ++ ["&&"] ++ y ++ [")"]) Not (S x) = S (["(Not"] ++ x ++ [")"]) equ (S x) (S y) = S (["("] ++ x ++ ["=="] ++ y ++ [")"]) :: Eval a = E a // unchanged instance expr2 Eval where And (E x) (E y) = E (x && y) Not (E x) = E (not x) equ (E x) (E y) = E (x == y) q :: (v Bool) expr, expr2 v q = Not (equ p (lit 42)) execution yields (True, ["(Not","(","(","7","+", "36", ")","==","42",")",")"]) 20

21 borders of DSL the classes expr and expr2 are our DSL class dsl t expr, expr2 t there is a clear difference between Ø 7, it has type Int Ø lit 7, it has type v Int expr v this is exactly what we want Ø we can make a view for dsl, without having to implement it for everything in Clean 21

22 strong typing the Clean type system detects statically any type error in our DSL Ø for instance adding an integer and a Boolean err = add (lit 7) (lit True) Ø Type error :"argument lit" cannot unify types: Int Bool Ø comparing an integer and a Boolean err2 = equ (lit 7) (lit True) Ø Type error :"argument lit" cannot unify types: Bool Int this prevents runtime type errors in our DSL 22

23 show in combinators hide the implementation of show a little :: Show a = S [String] (+.+) infixr 5 :: (Show a) (Show b) - > Show c (+.+) (S a) (S b) = S (a ++ b) brac :: (Show a) - > Show b brac s = S ["("] +.+ s +.+ S [")"] the view for our DSL becomes instance expr Show where lit a = S [tostring a] add x y = brac (x +.+ S ["+"] +.+ y) instance expr2 Show where And x y = brac (x +.+ S ["&&"] +.+ y) Not x = brac (S ["Not"] +.+ x) equ x y = brac (x +.+ S ["=="] +.+ y) why are these type arguments different? 23

24 variables in our DSL simple approach Ø state = list of values Ø dynamic to put different type of variables in one list :: State :== [Dyn] :: Eval a = E (State - > (a, State)) monad (>>==) infixl 1 :: (Eval a) (a - > Eval b) - > Eval b (>>==) (E f) g = E \s. let (a,s2) = f s; (E h) = g a in h s2 rtrn :: a - > Eval a rtrn a = E \s - > (a,s) 24

25 variables in our DSL 2 update eval view of our DSL instance expr Eval where lit a = rtrn a add x y = x >>== \a. y >>== \b. rtrn (a + b) instance expr2 Eval where And x y = x >>== \a. y >>== \b. rtrn (a && b) Not x = x >>== \a. rtrn (not a) equ x y = x >>== \a. y >>== \b. rtrn (a == b) 25

26 variables in our DSL 3 add variables to our DSL Ø use index in list as identification class var v where var :: Int - > v a dyn a instance var Show where var v = S ["v" + tostring v] instance var Eval where var v = E \s.(fromjust (fromdyn (s!! v)), s) example p2 :: (v Int) expr, var v p2 = add (lit 7) (var 1) 26

27 limitations of these variables type system cannot check indices Ø index can be wrong p3 :: (v Int) expr, var v p3 = add (lit 7) (var - 1) Ø types of variable can be inconsistent p4 :: (v Bool) expr, var v p4 = And (equ (lit 7) (var 1)) (var 1) Int it is dangerous when the user handles indices Ø let the system generate them Bool 27

28 better variables DSL implementation assigns numbers Ø expression is function that accepts a variable class var v where var :: t ((v t)- >v t) - > v t dyn, tostring t Ø application p2 :: (v Int) expr, var v p2 = var 3 \x.add (lit 7) x Ø implementing views instance var Show where this yields (10, "v = 3 in (7 + v)") fresh name required var v f = name +.+ S [" = " + tostring v + " in "] +.+ f name where name = S ["v"] instance var Eval where var v f = E (\s.(length s, s ++ [todyn v])) >>== \n- >f (E \s.(fromjust (fromdyn (s!! n)), s)) 28

29 variables are special suppose we add an assignment assign x (add x (lit 1)) or x = x + 1 Ø variables are allowed on the left-hand side array selection might be added Ø lit 1 is not allowed on the left-hand side, our type system should prevent that add an additional type to control access Ø Read: read-only expressions Ø Write: read and write access :: Read = Read :: Write = Write add these types to every class in the DSL 29

30 new type classes class expr v where lit :: t - > v t Read tostring t add :: (v Int p) (v Int q) - > v Int Read class expr2 v where And :: (v Bool p) (v Bool q) - > v Bool Read Not :: (v Bool p) - > v Bool Read equ :: (v a p) (v a q) - > v Bool Read ==, tostring a new variable class class var v where var :: t ((v t Write)- >v t p) - > v t p dyn, tostring t views get also an additional argument :: Show a p = S [String] 30

31 sequencing expressions once we have a global state it make sense to sequence expressions Ø first expression can change state Ø second expression is executed with that state class sequ v where sequ :: (v a p) (v b q) - > v b q instance sequ Show where sequ x y = S ["sequ"] +.+ x +.+ y instance sequ Eval where sequ x y = x >>== \_. y 31

32 assignment: change the state assign x (add x (lit 1)) or x = x + 1 write read how to distinguish x and x? the assign function knows the context Ø tell it to the Eval view :: RW a = R W a :: Eval a p = E ((RW a) State - > (a, State)) 32

33 the assignment class readvar :: Var (RW a) [Dyn] - > (a, [Dyn]) dyn a readvar n R s = (fromjust (fromdyn (s!! n)), s) readvar n (W a) s = (a, updateat n (todyn a) s) class var v where var :: t ((v t Write)- >v t p) - > v t p dyn, tostring t instance var Eval where var v f = E (\r s.(length s, s ++ [todyn v])) >>== \n. f (E (readvar n)) class assign v where assign :: (v t Write) (v t p) - > v t q dyn, tostring t instance assign Eval where assign (E v) e = e >>== \a. E \r s.v (W a) s 33

34 using this class dsl t expr, expr2, var, assign, sequ t p3 :: (v Int Read) dsl v p3 = var 15 \n. sequ (assign n (add n (lit 6))) (add n n) Ø showing p3 yields v = 15 in sequ (v = (v + 6)) (v + v) Ø evaluating p3 yields 42 compiler rejects any improper assignment we cannot use undefined or ill typed variables Ø 34

35 back to a DSL for the Arduino how to write C++ code in Clean 35

36 design of the DSL we need a state to store information Ø next iteration of loop needs to know what we are doing Ø hence we add an assignment to fields in the state we need to control heap usage, no recursive types use shallow embedding for easy extension of DSL Ø language is based on functions use classes to allow multiple views Ø one instance for each view Ø currently two views: compile + simulate in itask 36

37 DSL constants and operators each DSL element is a type constructor class Ø argument v: the view this view v has two arguments Ø t: the type of this construct Ø p: Read / Write behaviour of this construct class lit v where lit :: t - > v t Read tostring, type, tocode t class arith v where (+.) infixl 6 :: (v t p) (v t q) - > v t Read type, + t (-.) infixl 6 :: (v t p) (v t q) - > v t Read type, - t class eq v where (=.=) infix 4 :: (v t p) (v t q) - > v Bool Read type, Eq t class logical v where ~. :: (v Bool p) - > v Bool p 37

38 assignment and variables class assign v where (=.) infixr 1 :: (v t Write) (v t q) - > v t Read type t variable has same type as value written variable must be writable (no assignment to a lit ) class bind v where (>==) infixr 0 :: (v t p) ((v t Read)- >(v u q)) - > (v u q) class vardef v where type, type2code t & type u int :: ((v Int Write) - > ARDSL (v t p) (v u q)) - > ARDSL (v t p) (v u q) :: ArDSL a b = {setup :: a, loop :: b} 38

39 'Hello world' in ARDSL helloworld = boolean \ledon. int \lasttime. ardsl { } setup = pinmode D13 OUTPUT :. digitalwrite D13 (lit False), loop = If (millis /. lit 500 >. lasttime) ( ) ledon =. ~. ledon >== \b. digitalwrite D13 b :. lasttime =. lasttime +. lit 1 define state variables enumeration i.s.o. integer operators have extra. 39

40 servo sweep in ARDSL servosweep = servo \s. int \pos. int \step. long \time. ardsl { setup = pos =. lit 10 :. step =. lit 1 :. attach s A5, loop = If (millis /. lit 25 >. time) ( time =. time +. lit 1 :. pos =. pos +. step :. If (pos >. lit 170. pos <. lit 10) ( step =. lit 0 -. step ) :. writes s pos ) } 40

41 "Hello world" and ticks on LCD testlcd = int \n. liquidcrystal [] \lcd. ardsl { setup = begin lcd (lit 16) (lit 2) :. print lcd (lit "hello world"),loop = } setcursor lcd (lit 1) (lit 1) :. n =. n +. lit 1 :. setcursor lcd (lit 0) (lit 1) :. print lcd n :. delay (lit 1000) // ARDSL knows default pins // better check the time 41

42 adding a LCD shield :: LCD class lcd v where begin :: (v LCD r) (v Int p) (v Int q) - > v Int Read print :: (v LCD r) (v t p) - > v Int Read printcode t setcursor :: (v LCD r) (v Int p) (v Int q) - > v Void Read liquidcrystal :: [DigitalPin] no assignment to this variable abstract type methods of C++ class LCD ((v LCD Read) - > ARDSL (v t p) (v u q)) - > ARDSL (v t p) (v u q) 42

43 compiling ARDSL an instance of the classes that emits C-code use Arduino IDE to compile and load this code :: Code t p = Code (CompState - > CompState) :: *CompState = { gcode :: *File // code to this file, idnum :: Int // fresh identifiers, indnt :: Int // indentation } type arguments are not used here 43

44 compiling ARDSL to Arduino ARDSL C++ as intermediate language C++ 44

45 compiling: basic cases instance lit Code where lit x = tocode x tocode :: t - > Code b p tocode t tocode a = addcode (tocode a) class tocode t :: t - > String instance tocode Int where tocode x = tostring x instance tocode Bool where tocode b b = "true"; = "false" instance arith Code where (+.) x y = codeop2 x " + " y (-.) x y = codeop2 x " - " y codeop2 :: (Code t p) String (Code u q) - > Code c r codeop2 x n y = brackets (x +.+ addcode n +.+ y) 45

46 compiling: bind make a new variable and let Clean substitute it class bind v where (>==) infixr 0 :: (v t p) ((v t Read)- >(v u q)) - > (v u q) instance bind Code where (>==) x f = genname \var. type, type2code t & type u type2code x +.+ addcode var +.+ addcode " = " +.+ x +.+ addcode ";" +.+ nl +.+ f (addcode var) 46

47 compiling: variable definition make a new variable and let Clean substitute it class vardef v where int :: ((v Int Write) - > ARDSL (v t p) (v u q)) - > ARDSL (v t p) (v u q) instance vardef Code where int f = {ardsl & defs = [def: ardsl.defs]} where ardsl = f (addcode name) name = newname ardsl def = {name = name, type = "long", args = ""} 47

48 next view: simulate DSL as itask evaluation in itask simulator Ø executes loop in each step :: Eval a p = Eval ((RW a) State - > (a, State)) :: State = { vars :: [(String, Dyn)], dpins :: [(DigitalPin, Bool)], apins :: [(AnalogPin, Int)], time :: Int } simulate :: (ARDSL (Eval a p) (Eval b q)) - > Task Void 48

49 to do / future work more complex types in DSL, e.g. array user defined functions more shields fancy simulation of shields step-by-step simulation serial communication integration with itask Ø serial communication: message based Ø itask: task communicate by changes in shared state.. 49

50 achieved type safe extendable DSL for the Arduino Ø Clean checks types for the DSL Ø DSL uses only type-safe and properly defined variables Ø DSL does not inherit Clean as a side-effect, Clean is just the macro layer for ARDSL Ø we can add new constructs one-by-one Ø we can add new views one-by-one occasionally a minor change: add a class restriction (almost) solves Wadler's expression problem ['98] Ø The goal is to define a datatype by cases, where one can add new cases to the datatype and new functions over the datatype, without recompiling existing code, and while retaining static type safety 50

51 exercises 1. "Hello CEFP" on lcd (8,9,4,5,6,7) from Arduino IDE Ø connect Arduino, start IDE, select port and UNO, write program, check program, upload it 2. "Hello CEFP" on lcd from ARDSL Ø generate C++ from ARDSL, copy this to Arduino IDE 3. print the key pressed on the lcd Ø Ø key represented by voltage on A0, web: arduino.cc use keyswitch from lcd.dcl 4. make a clock on the lcd, keys to adjust time 5. add a += operator to ARDSL 6. add read and write to serial port to ARDSL 51

52 hello CEFP #include <LiquidCrystal.h> LiquidCrystal lcd(8,9,4,5,6,7); int ticks; void setup() { lcd.begin(16, 2); lcd.print("hello CEFP"); } void loop() { } if (millis() / 500 > ticks) { lcd.setcursor(0,1); } lcd.print(ticks); ticks += 1; 52

53 on your own computer download Arduino IDE: arduino.cc special driver for this Arduino Ø see Ø CH340 micro-usb driver at (in Chinese): 53