From c237c320de0460665d2adf13fc24034398a2d9c9 Mon Sep 17 00:00:00 2001 From: rtrimana Date: Wed, 4 Apr 2018 11:39:36 -0700 Subject: [PATCH] Adding more directory structure to generated files by compiler, also script to copy files directly to the appropriate paths; also adding files for tutorial. --- benchmarks/interfaces/CameraCallback.java | 4 +- benchmarks/interfaces/Room.java | 3 + iotjava/Makefile | 3 +- iotjava/iotpolicy/IoTCompiler.java | 26 +- .../.gradle/3.3/taskArtifacts/fileHashes.bin | Bin 689445 -> 689545 bytes .../3.3/taskArtifacts/fileSnapshots.bin | Bin 6218161 -> 6218161 bytes .../3.3/taskArtifacts/taskArtifacts.bin | Bin 212058 -> 212058 bytes .../3.3/taskArtifacts/taskArtifacts.lock | Bin 17 -> 17 bytes .../localClassSetAnalysis.lock | Bin 17 -> 17 bytes .../localJarClasspathSnapshot.lock | Bin 17 -> 17 bytes others/lede-gui/.idea/misc.xml | 2 +- others/lede-gui/.idea/workspace.xml | 287 ++-- others/lede-gui/lede-gui.iml | 30 +- others/script/deploy.sh | 33 + .../application/SmartLights/Makefile | 31 + .../SmartLights/SmartLights.config | 7 + .../application/SmartLights/SmartLights.java | 52 + .../SmartLights/SmartLights.tomoyo | 3 + .../drivers/HomeRoom/HomeRoom.config | 10 + .../benchmarks/drivers/HomeRoom/HomeRoom.java | 14 + .../drivers/SmartLightBulb/BulbColor.java | 67 + .../SmartLightBulb/DeviceStateGroup.java | 25 + .../DeviceStateHostFirmware.java | 21 + .../SmartLightBulb/DeviceStateHostInfo.java | 25 + .../SmartLightBulb/DeviceStateInfo.java | 26 + .../SmartLightBulb/DeviceStateLocation.java | 25 + .../SmartLightBulb/DeviceStateService.java | 19 + .../SmartLightBulb/DeviceStateVersion.java | 25 + .../DeviceStateWifiFirmware.java | 21 + .../SmartLightBulb/DeviceStateWifiInfo.java | 25 + .../drivers/SmartLightBulb/LifxHeader.java | 263 ++++ .../SmartLightBulb/LightBulb_Skeleton.java | 520 +++++++ .../drivers/SmartLightBulb/LightState.java | 25 + .../SmartLightBulb/SmartLightBulb.config | 22 + .../SmartLightBulb/SmartLightBulb.java | 1228 +++++++++++++++++ others/tutorial/iotpolicy/HomeRoom/room.pol | 11 + .../tutorial/iotpolicy/HomeRoom/roomsmart.req | 3 + .../SmartLightBulb/smartlightbulb.pol | 62 + .../SmartLightBulb/smartlightsbulb.req | 3 + 39 files changed, 2771 insertions(+), 150 deletions(-) create mode 100755 others/script/deploy.sh create mode 100644 others/tutorial/benchmarks/application/SmartLights/Makefile create mode 100644 others/tutorial/benchmarks/application/SmartLights/SmartLights.config create mode 100644 others/tutorial/benchmarks/application/SmartLights/SmartLights.java create mode 100644 others/tutorial/benchmarks/application/SmartLights/SmartLights.tomoyo create mode 100644 others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.config create mode 100644 others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/BulbColor.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateGroup.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostFirmware.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostInfo.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateInfo.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateLocation.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateService.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateVersion.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiFirmware.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiInfo.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/LifxHeader.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/LightBulb_Skeleton.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/LightState.java create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.config create mode 100644 others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.java create mode 100644 others/tutorial/iotpolicy/HomeRoom/room.pol create mode 100644 others/tutorial/iotpolicy/HomeRoom/roomsmart.req create mode 100644 others/tutorial/iotpolicy/SmartLightBulb/smartlightbulb.pol create mode 100644 others/tutorial/iotpolicy/SmartLightBulb/smartlightsbulb.req diff --git a/benchmarks/interfaces/CameraCallback.java b/benchmarks/interfaces/CameraCallback.java index 5d5377d..3069957 100644 --- a/benchmarks/interfaces/CameraCallback.java +++ b/benchmarks/interfaces/CameraCallback.java @@ -1,6 +1,8 @@ package iotcode.interfaces; +import java.util.List; +import java.util.ArrayList; + public interface CameraCallback { public void newCameraFrameAvailable(byte latestFrame[], long timeStamp); - //public void newCameraFrameAvailable(CameraSmart _camera); } diff --git a/benchmarks/interfaces/Room.java b/benchmarks/interfaces/Room.java index c7388fd..e9d99de 100644 --- a/benchmarks/interfaces/Room.java +++ b/benchmarks/interfaces/Room.java @@ -1,5 +1,8 @@ package iotcode.interfaces; +import java.util.List; +import java.util.ArrayList; + public interface Room { public int getRoomID(); } diff --git a/iotjava/Makefile b/iotjava/Makefile index c68c986..7cd1f7a 100644 --- a/iotjava/Makefile +++ b/iotjava/Makefile @@ -86,7 +86,8 @@ run-compiler-smartlight: cp ../localconfig/iotpolicy/AmcrestCamera/*.req $(BIN_DIR)/iotpolicy/ cp ../localconfig/iotpolicy/Room/*.pol $(BIN_DIR)/iotpolicy/ cp ../localconfig/iotpolicy/Room/*.req $(BIN_DIR)/iotpolicy/ - cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler -cont SmartLightsController lifxlightbulb.pol smartlightsbulb.req -drv LifxLightBulb amcrestcamera.pol smartlightscam.req -drv AmcrestCamera motiondetection.pol motiondetection.req -drv AmcrestCamera room.pol roomsmart.req -drv LabRoom -java Java + #cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler -cont SmartLightsController lifxlightbulb.pol smartlightsbulb.req -drv LifxLightBulb amcrestcamera.pol smartlightscam.req -drv AmcrestCamera motiondetection.pol motiondetection.req -drv AmcrestCamera room.pol roomsmart.req -drv LabRoom -java Java + cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler -cont SmartLightsController lifxlightbulb.pol smartlightsbulb.req -drv LifxLightBulb amcrestcamera.pol smartlightscam.req -drv AmcrestCamera motiondetection.pol motiondetection.req -drv AmcrestCamera room.pol roomsmart.req -drv LabRoom -cplus Cplus PHONY += run-compiler-lifx run-compiler-lifx: diff --git a/iotjava/iotpolicy/IoTCompiler.java b/iotjava/iotpolicy/IoTCompiler.java index 79e838c..027ea07 100644 --- a/iotjava/iotpolicy/IoTCompiler.java +++ b/iotjava/iotpolicy/IoTCompiler.java @@ -73,6 +73,8 @@ public class IoTCompiler { private final static String OUTPUT_DIRECTORY = "output_files"; private final static String INTERFACES_DIRECTORY = "interfaces"; private final static String VIRTUALS_DIRECTORY = "virtuals"; + private final static String DRIVERS_DIRECTORY = "drivers"; + private final static String CONTROLLER_DIRECTORY = "controller"; private final static String CODE_PREFIX = "iotcode"; private final static String INTERFACE_PACKAGE = "iotcode.interfaces"; @@ -1174,10 +1176,10 @@ public class IoTCompiler { // Check if this interface is a callback class if(isCallbackClass(intface)) { packageClass = CODE_PREFIX + "." + driverClass; - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); } else { packageClass = controllerClass; - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); } FileWriter fw = new FileWriter(path + "/" + newStubClass + ".java"); pw = new PrintWriter(new BufferedWriter(fw)); @@ -2304,10 +2306,10 @@ public class IoTCompiler { // Check if this interface is a callback class if(isCallbackClass(intface)) { packageClass = controllerClass; - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); } else { packageClass = CODE_PREFIX + "." + driverClass; - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); } FileWriter fw = new FileWriter(path + "/" + newSkelClass + ".java"); pw = new PrintWriter(new BufferedWriter(fw)); @@ -3217,9 +3219,9 @@ public class IoTCompiler { String newStubClass = newIntface + "_Stub"; // Check if this interface is a callback class if(isCallbackClass(intface)) - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); else - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); FileWriter fw = new FileWriter(path + "/" + newStubClass + ".hpp"); pw = new PrintWriter(new BufferedWriter(fw)); // Write file headers @@ -3300,9 +3302,9 @@ public class IoTCompiler { String newStubClass = newIntface + "_Stub"; // Check if this interface is a callback class if(isCallbackClass(intface)) - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); else - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); FileWriter fw = new FileWriter(path + "/" + newStubClass + ".cpp"); pw = new PrintWriter(new BufferedWriter(fw)); // Write file headers @@ -4323,9 +4325,9 @@ public class IoTCompiler { String driverClass = drvList.get(i); // Check if this interface is a callback class if(isCallbackClass(intface)) - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); else - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); FileWriter fw = new FileWriter(path + "/" + newSkelClass + ".hpp"); pw = new PrintWriter(new BufferedWriter(fw)); // Write file headers @@ -4419,9 +4421,9 @@ public class IoTCompiler { String driverClass = drvList.get(i); // Check if this interface is a callback class if(isCallbackClass(intface)) - path = createDirectories(dir + "/" + subdir, controllerClass); + path = createDirectories(dir + "/" + subdir + "/" + CONTROLLER_DIRECTORY, controllerClass); else - path = createDirectories(dir + "/" + subdir, driverClass); + path = createDirectories(dir + "/" + subdir + "/" + DRIVERS_DIRECTORY, driverClass); FileWriter fw = new FileWriter(path + "/" + newSkelClass + ".cpp"); pw = new PrintWriter(new BufferedWriter(fw)); // Write file headers diff --git a/others/lede-gui/.gradle/3.3/taskArtifacts/fileHashes.bin b/others/lede-gui/.gradle/3.3/taskArtifacts/fileHashes.bin index b3625fe35f5d29ec76f5c8fd5f8f5db1d2f912f5..14472c964c64a332ada1c78b129a44dc4b6caed4 100644 GIT binary patch delta 5185 zcmZvg3s93+7Jx|zki-XQP-q}LgpdTKk_SnUyaL+k$kw}Ojhlg zED8BY$tRF}WZpAbL643}I=rVJ1pOs3)YsD4`AeOT&MWmUi3y$^Bu$>s8XpWp^A+Ra z`QJ$<)!s7%lTV2EocA~#*r1U>J_)UZ2Bs^WDw#Qq>rLod~%ufUH{Qa+Pr zaigSO4bMkY&#_PvO)YvTDIt?S{t9b|-pD7D#zKi+se*1gtic)rlpv`MR)OTA98>z? z84U)C?tm4a%hm9*26II3fj6lsCIALBQZ<~RCe1n+xF}EImK?=r3y|yw-;yAeH|3K2 zHgd5ccK*>$)o%RakJPaXq-^5C^522=ytfO1dkHX1+ zQ`aUKqGHlKi0_l9a9vHBhN(l}g6cbDNz41>d{>j=u&d2|*buD){lcL2s8j`E8U?>s zNpc(>55^iYyQo&iHzavAL|vt6yI>|2la_+fPKq_`LN9F{9HFMfqtJSbm>ylF>(~dC zb!6ewuc4l}4UFSL_)XNVhRRXm+DJ`F8F1hl=1ORS^A4pNMyN@93qrp}Q_>0OX_oN; zlJ@UKXv*P*4LAz6j5F8hLSL1?}%6MG4*kE4m0uD6Z-x1n z;A;uZG7mzfw8ou~BZx<#WSEX_gbAC-+~j;0?AdJfVp&cVS!`4cgfAre}H zNUDq9&{Pj$OE1Y4G$>ce$iXv!uUGagcbpB&plA@Y8p>e3ASOcfU7Do@j9X|HIY=ha zGOmL$ge0iCjtLB_A?`9suwBrzVN);-&;h3e(GSB^Odbo8d+3lH4Zf|IAvplHPNt&{ z@X4{TAUNFn{D0-K{PiRdTkt(POxp-57@ze(Oq({vCcA$j){Fzk?Nxjs+tfX@^m z>d4OU_A}{ScSkS$az(l{{l*$$0>o0N822&07>|niV)TpoV*J^Ac z1I8LA0*qD90AqbY3>fP&1{mub3^3Lf1{mvMF<`7G#DKA$dkh%vI9jj6BN<*~>s>|| zn~V|07S0G`i(`bbr82_Uvc-h46^jXDt6+pli)4gJOJ#&f%Vva0D`tdAt6+plTg?cQ zwi5}nSdaXCE}8?18h-mB>gf@1P_N*>z|zyfFNmw)WCWq^&w^JiI1JQl2mIzEDz?Ki zK|Bq+1o1Kq?<0u+;Uk)12(prKLPj906h!i*RT!j(bvw{2LkCSes8=Oj zkZLFIq+V@sD4Epd7WA_)!0E3G`k?pxR0VP)V+1zOBpIfcDfkDy%rSW7tA=2!g*aQsh@VS3&hSlD@P-QX`KrJS6G-}jj}pf!dpE42mvvjU+f8dsbZ3zAS`s$ED;HfUam z3A6H`M-b;jSSua0s7NTApwrq%<1uSa2pE%aYEA@HMq+I_I#@G>L>Z;Ca%|p+#q=2Ec%Xj@&ag+o zgaj&@;fRTfMUc7&J7q72fkX^xUjYl}l5J=#+c+h&Y0vpEoPGQGGmhS24j-*j+jZVK*l6j0%MZPEM}6cO3WlzjhIQU z2AH71L*Z%`Bgu8>*OBBp^{Ys7UF49YhOAjZJfa+(*w>X*&(m=_f7SEmb3{V%H4Zks zm|uz$mhZxi%dh7Sv>IBdo_iea!cBLCh;OE9c_w!Q|z%0EtKZ8fLF841CQ^4>>0h)_YW`3~|#u29GIm)ZBM z8lO4Z8yPY2#8fT$TIYTMEzjnIjX7}ATYFWpTgH`{SOJxOvMKp~T({{BPUm}^VTVS) zqMY+`sbIvf=;Xwdb>340ircU7lT+cZZYBRV!?X|Yqbe8Q5vAoT`L`JvYoIWnycn?L zEBOoQ%JmXm$G=TUyaxLVh^?XkZN@H6=X0l*!*~xd-J>RF6sPmGq^>#7KSlh;Y9M2Z-bJ5X_9dqs~m@Kk%VE_D$#K72IXX^-Jl%d zq9xpi4I62+qwob0xhJBGMw~%jjvONoO5GbVzN_fT;TIFSzg73WdFlTCsF(AqwH?9S yHY6pSz9pqs6?Ee8;(7*%$ delta 4916 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 S=i=*vPD_T}eE2N>AM<~7R+o1G diff --git a/others/lede-gui/.gradle/3.3/taskArtifacts/fileSnapshots.bin b/others/lede-gui/.gradle/3.3/taskArtifacts/fileSnapshots.bin index 15c118bdbefd296199e1247f2e90dba3d65d7fde..c27ddb0492b609e11f581bc369332934f256739f 100644 GIT binary patch delta 6171 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 Q z6-^tP8JtsAcidubZ+T3DP|kz;IJAj$-f-^<;p~|)@Ng=l*0#O+_HWhE(FD@>o%@`B zJJMx2@xWxl1Fo1sK^hYe3(}bEu*`r5A;Zjj0ytBsiJ?p8-QS89CPMBs%@!^(@T^Z$ zRZ&^%xC(`0Prz$9lyq!Uqm60IV(yr$cK-$rO2=NKawQRl^iMtDjzJ zcTi+QxID`l3Njge=&H*{n;wtjDkKrxxBumTFRu*y1Z5Csk-G2S9tDaKOWY57q!CV6 zO^0(b@w1et6>8(R{z;&f34XCNnLw>#;^e&eHS-BHuiRvq#*``X$2>|pe7MN{Z$NPt zo_$0X&XWa-bMN=p4I&om)LfX5g?En2SU+zrBe58Z-M|kW`bgm18*u&;7tef7`QG;HXrqbQ2!XAeeTMU zBG`Pvh&wN$5?`f@Dg64KKp5z&9FBbS%Gy%6 z?N+D^HGE^A=Te&9qeSUFs=!R-Gr;Ps0IDCWoza>&*%!u0GL9|wMTh2V8XZyg1{NQ| z9yG9p{h()zawWv)a8G3OBfBvhg}*erM*q*EVN8a~!njmgpvKZ5X@TROPtcN6RE`+o zfv;*PT$Xu+L+=8MVQ89@I@$=mm029(mqxTXVmVv-D*ttQ4$NtTe22tPHG7TeD;f0U`h!7A61Q3EqK)DYC2r6C?M8y+4>RAb>rS(K!WxP<( zT8~zWM}56Ttyr}xYHK~JMXmO-m8#Uc{`Y-fg8u%`w>;0}-Tmy$?Ck8!?3)d{PQK#o zLR8~ff&HOlu~@E%&|kp{^ue?-(YEe3E+@L%m~>BfTl(xb)EL1&6#}kJZGgl!J54+meT>c9ksfDcU#pXzPpV(EMc)E0-8rL z{TCK1d@0@bZA1ojwN>YbvRIKw9{nk9y0KWp%2#|JNrbRHu*jhmEOu-gJ;W;9z9*mk zlRG<^i1e7{fBo%R`J#y3^pNy^&fBiP`RjjK_CdpmDKsA7Cm@b^#1K;4N_>PHu`nj;M_K{Q`~i{B{$axJI_<$7B1ltH#czL3!Q?LgE>Nt%}{-dhYd8 z8dF)e5c!^3VwvX%*^W*9Pz5eK1^wv zq$*=<)*K&CL@Hy5kCdtYYfT&dchtY8c^#j}+I7I5ysdTf3oSJ6(t8haOQ|K?y$u74 zni7|Ld=*0D0&>2cfA!eyYrc!w{t=DyB2RSVhm3#8H|ONhxCW-#@ilM5@r6IPFzyno zh&>a%KVf6fCjR)5|Ak2m^Wyh<2Mmm>Kx3ag>|lQ6N5Rs>?T&J zW3X#0^Gjx&Vrh}w4vpbcSJ;i( zydfn0?W=Sy!~2j$EYxU;qZ$w5FGMP>2WG@)+|W;ppvQR!ZW6&-E!Ml$bH}UB2@K}f zN+fBu#5}DPGhWZTbMq(0QS#j*i9fX(Lgy2PEouE@Z@-Q?G`|~PNM!kFu>mUr>sgYy zG{zdJBuac@he%i3 z6+NygyHAwpkg#rf0J;Ch{+0*DMtVT{>ZE;@``spN9I@N+C8Kb=ipcMwA-43uiK{&n z1kXQJcC7!%jKk+*UeOFLyM_}<{ubHs<*)Zm?QC|YL7rwXvD80?xa~hecIw*|pDiwX z_9H#ODqKZG29#p9--qn#Q8k~&_#P{XodH_nLBLGx(Jw@hapNu;cdPr3$k)dZNA(Kg zPkoK-LdAm2@T0w2=|Mr+K4N-c4yHUb&XRU=I*oa>Od!4wjFz?id?@CI?@_8KvRIgG zF~JMc$S(DhpA%ope?o(Nxs~t^(h>zh9@szHDeUkOHX7HAZy`z$^OdXrnp&XPkDb5ES4L80~mp$pYwqrTay zKfduV8dF6KC-OrpiN8W?h&qE6yElI9+X0!i^ceO>GvOU(BhH7VVPDRiU%ouKn8pRC zP7#uDEs-2*fN#a zV!T6ah_Djwkp^OTWT@+>s9y@gMD+ZEZL z=!k1%{crpL3!N@@KKm2#U-}RHxBr1xyk)V}?Ef)9;rM^xVgG@r{RcksKk!+s$fEzX z0`-dj5ZL}7`0@Y1uT%IQN%UxqAd9zpCt$+Y-3!Zd7Q=x&Tmu9B6jcZL-pif z5MjO?b|UJ~x3V%P74j>;Xc|{7~ zc1llzYb5V0*!)I%ukKf=H);FaWiStBDzGN9tv7E&F8M<2R-q>2Phr8wJd9kZ17}U~R;3w!>HH zvSKkgDJ}ZC4|(_r?}~uTJ;^;Us2#mbZ zq0@{Y@^FYKU^{6Z?lPV&!|y!eiTfS+@)^F)LG5&kM>d=hBnZfcc2O2i5)SwnN0NO{ zl+Pva@AQzd$=eU2<9XzxhoVtVu)onImat8eg7pyB#bFpaL&?Kl;-5G`6v&5z`Xbkz z#MI&&9MI{7Iuy%XK&IgSbaxF%HL>4a!FgX*Jo_7y^7#hr#^Q?^%4j2!fWX&N7$tie&C)RAOHO*a*+A^#L(I5 zDRU3e`&UDRjW%>g`$}+ez^=i_hk{-ptI#BpGE6;-O)hi7wzFY#9B&9L^}sy1GZi*4 zM5t8cIVtv!hAj5v59X7eQP`AmPpsIAs;6DS z$Z1z(>iMvFvSu!c4U|7Gq{D=qxm&(=CHdEM#c?S#N@Qx%X@{4HEjy9@!^I_L-#1&1 z4vQPIbL%5G{;N11tQ|rha(I|}gBF?|3y)Nvp5;uQp5-D81>dLALF{3qAxtb`gJl|y z9D!kCXqkrll5=;s{LY6ooIj8Jd6&ywM>4#E^Kk&6sFagehR1!=moy8)zY&s;!dZ}8U+*o3(>TAZIuqQ;OmH7GPsq<@vG}=cXYx`cZ!`~1^u!)= z_#=QF9h|%GELY8jOWUys*f2|j$;LMadI$e%diZ8p<_^WraZ|`jna^e~a!ib(x;Lqo zW5+n~ccqiNtiSY5N!vN6xGlP3_u91+?m*aVULVj5u%LNBST($e-<<<$UV=Mtg*$U`k3a+WCifQ>KfAzPBLVockDx~V=#Uw!2f z#9c#6LYv6TARF4)n121(s0%fh#eaP8`bi>f4w_B_lf_D+=FofR|P)7CE=QaNdz1u8Gd`+)UMK#1(d&H4K@lBHiRvN`zA=rinT zm*>as5qZ}zO~D1n@MG}OFS7$wUJE02EU{%y8xL*^A> z))z7;Um`I;!xyTa#xo=8p3D^<+plhvCPPkE$sit~0hw`0R4 z(tn4d(;#HWp#vrk9WX0O*?pj62uBPuZ?POwr{fQ>(9x48j4GKjH8jFtFoZ^e_65fa z+RteN!P0|+fh5^>=E7!(2)fye-N zUx#8ykTYb6|w_V`|LEZ&tynCKNuwGQT!Y?UkvZ7Csg7!{j0@yl~GMJf)Fb-+Q z%sOP0Fb!dk1Gw)L^aR5&z69#10q5(AAz*Is(|~U}CA-wl*FYwQ(Xk0%Q3F-QcBL(c z!=%tJqm1S?x4hxxlvxY4dI+nZPfm&YI$56hk~3X2in1f!*9nTVkpik)mn71`6yej8I_3RUS#fkm z2_T_|urI$$aUZAv}aO(pyU*GqmqHUNW8#tR3 zUA9>N<{F{BK0x!H*ARw|lioV{dsv63Q#_QJP-wi1LwZVctD6KYqdD}xj|bT`trm9Q z)b<70bW!em(TJGQyxmD)#zoohtD?+kUgDu-a;!N=Yk`hZr1ahPl)c~v!tuqzuIz0Y zVT=JI;nB4Y+c~#nz}5!Kp*GUD3quknXfILtKyGi*J1hk*db-FNBP~V7T&Vr`|47Kx zA}=N+(f+2vr7F(5h{y!nK(s&<@#CT6Ls95E**ZT_FVIYIlEA~4l*8@2P2-lpNGI4Z zj!MtbcF)`D6@%f#7Q0~`r~L}v>&o8v7Q9mqHoa3n`0EW)-0gm(I0`fkNL}|_&@oXl z;9ZxVx?`Nt`#nY0@y33u(oudXw`2l71M@0URGlV}g|w~%|0`>4*7=LW~vm=8M;Diu6`Xy2)DMDKB4B8bm& z=95R)M5Q~DNpifAjqPyVGBm8}2=hH~-~_VM8Fw(S)5({KxQGqLez*tL5<72Pwi}mb zQAIC@#C~`w7F8pd>TtV;201DnZ0d){z>|Ks6~-swscNF8O%xj%vSEh(- z(z``OP?xPNmf%DWs7k|QFrQ<>ECIJK4Y~~1!R|ENBJ+4K;IL!(Ugm;_r#T5P5o+KV2f4RGI!8c=9(Kyb1)s6q7ER9~&RKO?+uLM&j+O)-)cqm-X#Bu+PbCVtF z1k6QA)|y}KVmir!@zHlrbgegSF$88IgB?-_Uv#0w!z9FM=-r;8WJqv$t~bI#|2FUW^U;i6V|h0|X*|B+S`Bm0rpg%wfflsV zITpNTVBpb$kNR$50!&k0WtWKV|NZ1SZdd=HHEGH&b>j>B?a%n6YA20j*v4-B*IVNa zj~i2H+~~g!Jah19bIgOO-*2@IE~in)13#U&{L@{D%q5%;~Z zwT$PSuQq{CK1#DFwRLk$NIlIdY*9mQK1#DJ!@2cs`A-!zDmab7?tJ_XwtDUKzMmf% zMuQ&FAHkvmTni@)P>G2hh%cArz1ca!7JJK+nY3{_oEV6g`rk;l<=5YvM}um~0Q+(Z znlg|4Gh(GHjmryWK<*&CG@kc56T3R&Ee%Rve_&@Gr2AJgqlui!Xm;pMFXkNbD6~YT~i`g2{QTA-9fkN<2pobNDvG}!=KElTfbkCR)yH;`QI@8JjMC8WXc6I)QQi2VIWxu_ zJm*8>Vy}L7ykt({Z;PckT_ttr)+5?WlZK3?ni5 zHJFCuwt#XX?e~VPe;sKwI-YOWGiB-Ux#7A~=V)B|bRL`?j;}UP=YMu#+3ArI8r4>> zv~y2C^OGbX)583kr;6KS$7dwmbNqA1gfE#nPhE#8Bka2bg!oGSjjpM|GhUq>;)h9X?SW-||*d4w^K zH0CjqdCa08u&@XZhl@qHd-eGu9FZp?FY4=0cIQ9Y9LsNY=X652;*2u)C# z$?zOibG7WUB=45&(e{id52^O$r;`oe#U_aNM9Q27T{%6tBWax3ikn zR*?|BIth=kUEUc$A_FP~(4xVL_egUZIiTGam_{D1j6Ncj?GX#AblPiweuaD79(An# zDBRf|Z6y!>?fj8nwQQUgkq;>w=ewg9tT@Fx3cJ4MD#V$se_Fv>)0@+Vo z<*Qu&nW7{jV%N#DUzd`9FLfyvkoT6V_DiW-8zYx&trV`|0ehb$WnX{wOD_3Z?tFk< z-S<0RM1F{LhLJFauxdqxni^LLN>&X;LFJG8&wzd zJOl?P!bnH6g+%YMFCD6(AOMjbQ6Qoq5(;|yorTB2K95Lq0@lKYJ7N8_fW47QxFu6L zP+lhS1WgipuSIu=9&8STeQVZ%`DaWo;81gNZRC}8QPHC6vfyAuA&5c|84!h$Wx?Ub zm!Ni4&#v|kFd~W|y#pdkBf$BG=&KO6QW^_ot|l#n&*p_fdz9E4Y*At#@WC`G)Bq3E zGJ_uwgffL)1UWyrr^7L|-WRHpB&pCigPRUAg~=DD{^Od$895s6Y*wekpWX>RQ2UBw z1`BQy0mmg)LEVuCQQau$IG=>RV=d*feyqz~LRNmAKkp>YA4 zD@2P_6)D}#pyBg`pwa1huxD+Q7Mhik9`L2R!JnEag)?P3Xp7NTr8Xrprs#w^l|7OH zzVJ=(g~U}e2|h!nR^(4kd&$Kjw!jtT{v+Q5g1Pn_Mr9PJuTG)$C(IViy!HtB=4 zU`}`F0alFxX;{ZK6Xpp{VCadKw0o;-Di|i~^vvQk{w8K|bzyqsXKzUw)RgH&;4#KM zjcA{o0*?*IJ2mCH-Vi+2Jq;|Ya5M{B;s-WAgB-3*WV=E8Hiro4NH%#u+fkVmFdZ78 z#0c}0-f$v{YE)p*aWK{hk28>tjv!NCbhj#?CJ2Qxe}e}zOS`{;;RkaseIjstkuhy6 za1-@SIt?21hF-K3*!m`@K}O&K3`-4xSU4Go#TsNVLwE(6uw`Z+aLz;!vNsBLM^ZM- z^{K1FamWp(Cw78{%t8%>#3ab!gh`MFvN(M_IL~8bJs9TGhshfv1(DX8;!{celiROw(sPzz_s2wKufc6A^AdN$N zv*`uuhgGa& z9D&vv2sMR;UbGJY?T-o?26K_?%qIF`hF+&P)VQNMV@^OA?MXTmEQ@r=MU>&@L=!R` z?GM^+bQENwIHO!zw?r4)J&hXLSD;90-io4&-b%w#otg14iWUj9y-ZTWqzvSp$6RhI z(OfPf%06&Kb{G_}xxa5$3?e7EK}Ube!&KBFJ9^uv@&Q|QE)MK1t|?HFogjiKYyA{Z z25KYNvJ(t+ezGGWY%(_kWc^SgqSViT_Wr28pw!QRK9&T3CiN)4aX$zTgB6nk!oZx* z_JjsPX9VZI0(0#&5f~GVR8aV(PIL*n3oVu zZ#|_}2<-#)C;dAVx*|PgxqKAXzqs!d=Kh`$ZS{K_-;V2bD%Nzh)J;05Mi2PtXCfx#x0K-mIu zP`4%wF8-dSqTP*@#8R1MhK_~eRN(Y=rRTy3+ZTRRXfU%>l$Z=u?wG+gS)Yb};KRCn zOB>zck?aeEtuI{*P|2B?5C_H1xm{gkuM#w#$zJcANJ}-J!_`zBH3PET7tCJC=t`N| z3?%Oa=2DX%Z1NT)f#EzJOnDq_-*mkgoOk58P&Fr%>Y@tLoPyr$#+m5VBtyq2g9Dh$ z6T+A^(JWTW6LgKXUBr7)NsS=5!P(^r1;tJli+}4@Rdrc9jgn2MH*>sIxkuP>>D{2dJ}} zI`z#H3|*(b^?N)B_FQ8#2R5g8B(O)L>^nabZ9bJ<(6$ogu5U3C+Bge&iO#s`vzd%j zPe!3fB`sVE2=-&%K90@P>ljJHb=(2=NYOf#bCEXc1%}Dxzvd!EoGofISU;pzqeU;# zbfPrRFvU?d5P5oyxHn^}rApsrYRg&_L6?o_gm3%@MYPO@v{1QJm*s%f-Nwam!$a90 zI%b>DSwYqNhUo_M6AL#xj48TQmuNnTf*37}J&7>|`w$fgyZ@+PCUsIMj`8TS$6BpV zV(iZ8bVVg;0h+Pu5_)AB2?<`*yU@ZeFQKAD*PPHf$RRYxWQOD7BKup;4CXCIQ)Tk$ z4ki&h3d&1Rp=~}BgTtGTsokQ~&timsnosdk`(<5}VBfDrsF?Nt3>{*0R$6QZPwMi$ zt5#cU^zP7hQtb^tEvAls^cn&PLkG}ueE>{3sm_7s@SIrKEkpwyoyceG621a#MUp6} zd5G?jI*#=5pn?&d6PI*x)M=kV4Wz>5W$HoDwmcyO?rlS_Xf=zu;e_F)2-^Ont_qi_ z$3x8(oflQ^)1hV^I!+8b#a`gk&tWLha3zRtfT05qB9ESqT+;@3dti&J@2-v_@2>6@ z^cmUrxZ_B1HTv%aL@|g=h++}-Mihsr52AQPW<&{y5)t)9)DKY-qGUuVh*A-yAxcM- zfhZGE7NTrK{SjFZNtj6+T{)bh zlA5%-sYoe>l5SEYMR&@}9H)3^_H-(*_x)?{&$FM;`abLT{MNH}lT@Qgs!`e|qMUxc zgcFl?mY&8J@EEiRcQ!Xlz)!Jv9rQTsumsEG2*MaVS0;-=jS|SeSaxgW>X$O&#ix>V z$pb9c?wkjG4DpL(T`i*`(ed2*9d9PDy46(|t?@=;m)!xx30t)#ZK7Kwv3_nPMJKg) zkzr1_bO_70e2v4q>rDUQthvRp`u`^ry9~hF~faPELXI4mb6|kwtO)=b9A81Q@@*T+%&y$J3JrBduB4|vu z7mdwa&)^H1_Ud^5v9D}Xdc^mDLfxv(vrFP)9AY#72~(pPJQi&upWkO@)G|M)L0SAs zYGUpk;$n4FO`;@XvO{=`2nJg~W4UrzbOtYH=1R;;XJmc9G#$SuA#CF-?lAVjy!0Ye72EVQi@E+}NmzF{l&JsPK!Y4=p1D;Rr(=hoIt290!s?w^v=6U#atNVZ zn7nzl7oDlkwl{X(-qY9>B2qy#0O$aX2fz+Py~?29oRZU-H`b+UDHy zez+v}G)t$&7LT7qNa7{P&*=Y>Dk3ELxJF!dYo8J zt>RtcKlPs;k(VswbE0@54B6iJ_ecqszezXFBBimI!HQEX3+q1pv*kdgrD_@{IQ&Pj zu#r(?wQ7)*#$)h*1m}qkYI?H-=Q0#a{)lT;pW2A6-!f?xrf&9C>FDC}5Ke@czSIaW zaRZys;b1TY0t4L46?{fQ8VDdGeKv>%lu;GYMn11ZD~AXo!72pG^zTb*#ErMhKZw+h*NKnY@9Lfr?W>tpRZ?#Z!+{QIG*>gD8Uo9LcCN4pdl> z53SxrS&goc#V^+Bnp0aFjs$$orvB`|euic2nJ(>1pFCE3RywCH7bgl5ap@W0fqUlz z92Fe`(=a@$0L&m;tsOAyy??oeSZH^>zZ$J?d*jcA><&7R|MpqGG9@<6}V?RWKTZ?yi^^`at9xg#~ZQj`M2h{{WOvNGkAe)~D<*UVmHLywZh`0G;dx832`cfiEQ7UJ8828^vRsqiLgSz|TVe;_Z+= zIibHiXRWX%%Yxm- zbQ`xt?|J_3_lQdCcC4-vcCr@}m6`-D>vnFg0a)T`d?6jEmCsD>*Z5 zApwlU-z+@)y4alnj^t^IH7tDZKG~10dHC^*p8}}j0H;EvHyutB&nSPN{X9h^8%kB#%n zfC{Re2h}yvOCPvoO#GbIXL~g_PK^-L1e^#jhJZ$=322I&VyP0jZ@$w_eIcC@tBCN+ z&v%vPk6O7$6i$n#`7ji9$Y%^cNJk^l!by@N3}-XHC##=V+g~XOQXr?xn4e*hP&{mQ4BJ%%cAz9WvXR@@=GHXfn3Mt+i z0QG~s8=X=-F0A#I-QbGbTfWu7VB>)}k!Nfsm&b@^a-#UI44NQHCI)4lZs)$F_Nr9b zyR2WuFCLB)H68#e!!K*ccxt-&hY7BD&^2i63slE6*N;)TF5=QcHqb)9|5nLSv!43- zk2pYsVlIyp8b#yL6_Zx}=}t*}S^L;~lm2@IxAZJj?elSQ!kt5)o>r6T%o7LFU*^S> zuMG734YuNWyFe*=b{o=_RUGVX>0BndUkRH?a=F%`1@&+M;0uDGCK_D>Ykx*nAxeG> zwU)#;2>&jZibYTUhpldpF4W2O)0+B=t&S_vTdFtLeH(78yWP%`8LvN2{>4^-blq6? zm}PE5Y!&C-X_Az3B5Sy?NN(P1x$-opEZvk29$F#a4y+yOoyje)Z9&qk!gK yP#=K~t7CJZ+)?IoKT(m74dw-a0g^c>4ntWM*d+|f{1ZGwl>^O4?kO^reQ69XF)9;%I-r4<~y_TyZ!RsI<$rW_rU zVRE;vzeW}gbWg*?SNEnI8{1eTkJ)fD@#D|TzVpb1U7DoY5U;9xjubM^v3Hep0A2-i z@9xw)&yJsSLq!KclDO&cZh(Xo<%xAp*^p3uT|l;re$P+a;;{S8G@_E($FW(t^*niE zUe)UZJ4^EhapI>jkKHP-$kjNJ(!I9NqVda*4*ciru7&QIGUAdF5fNq(#HyFVNQmks zwN-h)`jy`7I@ysGO<~Y}qH?%0DbLOvp7W-MC&~UA_KKylqbTtl1wvt7hB{}f0`hjm zV7_aR=wQnMlQlUsMmU=qO=WN?Q7+7=2r4_WIa1YJFL50bb7kI|KkoTj__1scB2(G$ zZJF4hd6#&s?^Oei2-s8>lg*t732b-W-JaQ#%04}Mu77a73mQWLrs7psvz!{o8Usm?SuC+l3nvVpvdTw-PvElhSO zrD5ZZ{smiu%hfZPVf3k>duMKAtoEj{Og5D>6?_=<-Y2oL{QCp4lvDAi<-kLf{$WFT zvGD@B-`?PwaAq_Tu~`o-bp;7nVHhxnsG$pZj_EQ$9KggJ@b#eSTbqtYU2bigrfJKq zW<@0>?P_^VO@xu6qCiDQT+;eudge*r!~myZB{ z%yJ?$EE0eMr`bTGop&3k8K zt@Jc2;h)Y$v0jDgrLuBWRbUA~bu=LtE7OK{im2l%Db#M(erKY7Q{*(L`x930r#zq2 z^3c!qq#5n6iNQED!B0SjA?uh?#q9vsu{QB477JwzMfnJJOzb|yx!FprhRRWr_ z0Fcm-C(r@4V8A1&(2}5sc_u?cFtMV1xd-M0R6P}1qTX`}BrG@n|Ne$=nP~cAc~U43 zp>Ubeo>VR+g2JW9uB6s7^S63-G$%m>HBJ`c7$}eS+!dKQ<W(}_EXGiGP} zOI{CkKtN~ECSM*XWixgA&%{g&CVa3>y!aUYR_vCStB}v3MKWj%bfg=qqJ{~ONP6h- zh`gu$v-ZTnG&Tyflnhl;o_sSz{{w8=+*D{1aJLl=ZGigz3pnAC`TA~tu$^Z@?@^ydnA?%V&1g{oQ>QqRVl1$<+n z?wz0CI&eeH0Jl@p54lA5Vh*l!bn4$ad-`nWk&;S4c diff --git a/others/lede-gui/.gradle/3.3/taskArtifacts/taskArtifacts.lock b/others/lede-gui/.gradle/3.3/taskArtifacts/taskArtifacts.lock index bc35d02806478ed9a86d37ff7f2764ed15b4a51f..9c87ff196ae65c12a98c176115ca7bd8de28baa0 100644 GIT binary patch literal 17 VcmZS9`S3+oonw&&0~mb#2>>n#1vCHv literal 17 VcmZS9`S3+oonw&&0~ow71OP331gZc4 diff --git a/others/lede-gui/.gradle/3.3/tasks/_compileDebugJavaWithJavac/localClassSetAnalysis/localClassSetAnalysis.lock b/others/lede-gui/.gradle/3.3/tasks/_compileDebugJavaWithJavac/localClassSetAnalysis/localClassSetAnalysis.lock index 3ede7c966997c72a1d9e739231ac4ac8408b3f28..737c618a6eabd33dae646fe3e3b41f3d174c007f 100644 GIT binary patch literal 17 VcmZQ(3#oel#^*#K0~j!^1pqTG1m^$% literal 17 VcmZQ(3#oel#^*#K0~j!^0su2A1mpk! diff --git a/others/lede-gui/.gradle/3.3/tasks/_compileDebugJavaWithJavac/localJarClasspathSnapshot/localJarClasspathSnapshot.lock b/others/lede-gui/.gradle/3.3/tasks/_compileDebugJavaWithJavac/localJarClasspathSnapshot/localJarClasspathSnapshot.lock index 24c9e46c2f7325d538839301dc03eb955384cd4e..560430cec7896fa816e3144d4c40123e10b17158 100644 GIT binary patch literal 17 VcmZR!;k^+3sJc0g0Sp+g0{|{G1eO2* literal 17 VcmZR!;k^+3sJc0g0Sp+g001sA1d{*& diff --git a/others/lede-gui/.idea/misc.xml b/others/lede-gui/.idea/misc.xml index 7e15d9d..b0a270f 100644 --- a/others/lede-gui/.idea/misc.xml +++ b/others/lede-gui/.idea/misc.xml @@ -27,7 +27,7 @@ - + diff --git a/others/lede-gui/.idea/workspace.xml b/others/lede-gui/.idea/workspace.xml index ce9efb8..e8ea71d 100644 --- a/others/lede-gui/.idea/workspace.xml +++ b/others/lede-gui/.idea/workspace.xml @@ -47,45 +47,69 @@ - - - - - + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + - - + + + + + - - + + - - - - - + + + - + - + @@ -95,7 +119,7 @@ - + @@ -114,25 +138,28 @@ - - - + + + - - - - - + + + + + + + + @@ -1227,7 +1254,7 @@ @@ -1256,11 +1283,11 @@ - + + - @@ -1427,12 +1454,12 @@ - + - - + + @@ -2047,7 +2074,7 @@ - + @@ -2056,13 +2083,14 @@ - - + + + - + @@ -2077,7 +2105,6 @@ - @@ -2141,14 +2168,14 @@ - - - + + + @@ -2187,17 +2214,6 @@ - - - - - - - - - - - @@ -2207,17 +2223,6 @@ - - - - - - - - - - - @@ -2248,78 +2253,78 @@ - - - - + - - - + + - - - - + + + + - - + + + + + - + - - + + + - + - - + + + + + - - - - + - - + + + + + - - - - - - - + + + + - + - - + + - - - + - - - + + + + + @@ -2332,50 +2337,76 @@ - - - + + + + + + + + + + + + + + + + - - + + + + + - - - - + + + + + + + - - - - + + + + + + + - - - - - - - + + + + + + + + - - - - + + + + + + + \ No newline at end of file diff --git a/others/lede-gui/lede-gui.iml b/others/lede-gui/lede-gui.iml index 288756d..6e6cf73 100644 --- a/others/lede-gui/lede-gui.iml +++ b/others/lede-gui/lede-gui.iml @@ -62,13 +62,6 @@ - - - - - - - @@ -76,14 +69,37 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/others/script/deploy.sh b/others/script/deploy.sh new file mode 100755 index 0000000..9fe8143 --- /dev/null +++ b/others/script/deploy.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +function usage { + echo -e "\nVigilia Application Deployment" + echo -e "\nUsage: $(basename $0) [OPTION] [PARAMETER]" + echo -e "\nOPTION:" + echo -e "\t-java\n" + echo -e "\t-cpp\n" +} + +case "$1" in +-java ) + cp ../interfaces/* ../../../../benchmarks/interfaces/ + cp interfaces/* ../../../../benchmarks/interfaces/ + echo -e "Transferred interface files..." + cp -r controller/* ../../../../benchmarks/Java/ + echo -e "Transferred controller files..." + cp -r drivers/* ../../../../benchmarks/drivers/Java/ + echo -e "Transferred driver files..." + ;; +-cpp ) + cp ../virtuals/* ../../../../benchmarks/virtuals/ + cp virtuals/* ../../../../benchmarks/virtuals/ + echo -e "Transferred interface files..." + cp -r controller/* ../../../../benchmarks/Cpp/ + echo -e "Transferred controller files..." + cp -r drivers/* ../../../../benchmarks/drivers/Cpp/ + echo -e "Transferred driver files..." + ;; +* ) + usage + ;; +esac diff --git a/others/tutorial/benchmarks/application/SmartLights/Makefile b/others/tutorial/benchmarks/application/SmartLights/Makefile new file mode 100644 index 0000000..ce4bbf5 --- /dev/null +++ b/others/tutorial/benchmarks/application/SmartLights/Makefile @@ -0,0 +1,31 @@ +BASE = ../../.. + +include $(BASE)/common.mk + +JFLAGS = -d $(BIN_DIR) -cp $(BIN_DIR):$(CHECKERJARS):. +JARFLAGS = cf +JARFLAGS_SMARTLIGHTS = cf SmartLights.jar + +# checker option +# +CHECKER_OPT = -processor iotchecker.IoTJavaChecker -AprintErrorStack + +ASTUBS = -Astubs=../../../checker/astubs/ + +all: smartlights + +check-all: check-smartlights + +PHONY += smartlights +smartlights: + $(JAVAC) $(JFLAGS) *.java + cp SmartLights.config $(BIN_DIR)/SmartLights + cd $(BIN_DIR)/SmartLights; $(JAR) $(JARFLAGS) SmartLights.jar ../SmartLights/SmartLights*.class ../SmartLights/LightBulb*.class ../iotcode/SmartLightBulb/*.class ../iotcode/interfaces/LightBulb*.class; mkdir tmp; mv SmartLights.class ./tmp; rm -rf *.class; mv ./tmp/* ./; rm -rf ./tmp + +PHONY += check-smartlights +check-smartlights: + $(JAVAC) $(JFLAGS) $(CHECKER_OPT) $(ASTUBS) *.java + cp SmartLights.config $(BIN_DIR)/SmartLights + cd $(BIN_DIR)/SmartLights; $(JAR) $(JARFLAGS) SmartLights.jar ../SmartLights/SmartLights*.class ../SmartLights/LightBulb*.class ../iotcode/SmartLightBulb/*.class ../iotcode/interfaces/LightBulb*.class; mkdir tmp; mv SmartLights.class ./tmp; rm -rf *.class; mv ./tmp/* ./; rm -rf ./tmp + +.PHONY: $(PHONY) diff --git a/others/tutorial/benchmarks/application/SmartLights/SmartLights.config b/others/tutorial/benchmarks/application/SmartLights/SmartLights.config new file mode 100644 index 0000000..28a4f80 --- /dev/null +++ b/others/tutorial/benchmarks/application/SmartLights/SmartLights.config @@ -0,0 +1,7 @@ +ADDITIONAL_ZIP_FILE=No + +# Language +LANGUAGE=Java + +# Tomoyo +ADDITIONAL_MAC_POLICY=Yes diff --git a/others/tutorial/benchmarks/application/SmartLights/SmartLights.java b/others/tutorial/benchmarks/application/SmartLights/SmartLights.java new file mode 100644 index 0000000..2a4eca0 --- /dev/null +++ b/others/tutorial/benchmarks/application/SmartLights/SmartLights.java @@ -0,0 +1,52 @@ +package SmartLights; + +import iotruntime.slave.IoTSet; +import iotruntime.slave.IoTRelation; +import iotruntime.slave.IoTDeviceAddress; +import iotruntime.IoTUDP; + +import java.io.IOException; +import java.net.*; +import iotcode.interfaces.LightBulbTest; +import iotcode.annotation.*; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import java.util.Map; + +import java.rmi.*; +import java.rmi.server.UnicastRemoteObject; + +public class Lifxtest { + + @config private IoTSet lightbulbs; + @config private IoTSet rooms; + @config private IoTRelation rooms2lightbulbs; + + public void init() throws InterruptedException { + + // Iterate over RoomSmart set + for(RoomSmart rm : rooms.values()) { + + System.out.println("Get room: " + rm.getRoomID()); + // Iterate over LightBulbTest set + for(LightBulbTest lb : rooms2lightbulbs.get(rm)) { + + lb.init(); + Thread.sleep(1000); + + for (int i = 0; i < 5; i++) { + lb.turnOff(); + System.out.println("Turning off!"); + Thread.sleep(1000); + lb.turnOn(); + System.out.println("Turning on!"); + Thread.sleep(1000); + } + + lb.turnOff(); + } + } + } +} diff --git a/others/tutorial/benchmarks/application/SmartLights/SmartLights.tomoyo b/others/tutorial/benchmarks/application/SmartLights/SmartLights.tomoyo new file mode 100644 index 0000000..974b883 --- /dev/null +++ b/others/tutorial/benchmarks/application/SmartLights/SmartLights.tomoyo @@ -0,0 +1,3 @@ +file create /tmp/imageio\*.tmp 0600 +file read/write/unlink /tmp/imageio\*.tmp + diff --git a/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.config b/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.config new file mode 100644 index 0000000..ec9c5d4 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.config @@ -0,0 +1,10 @@ +# Skeleton/original interface +INTERFACE_CLASS=Room +# Stub +INTERFACE_STUB_CLASS=RoomSmart + +# Language +LANGUAGE=Java + +# Tomoyo +ADDITIONAL_MAC_POLICY=No diff --git a/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.java b/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.java new file mode 100644 index 0000000..84e7833 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/HomeRoom/HomeRoom.java @@ -0,0 +1,14 @@ +package iotcode.HomeRoom; + +import iotcode.interfaces.Room; + +public class HomeRoom implements Room { + + public HomeRoom() { + + } + + public int getRoomID() { + return 0; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/BulbColor.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/BulbColor.java new file mode 100644 index 0000000..e069e74 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/BulbColor.java @@ -0,0 +1,67 @@ +package iotcode.LifxLightBulb; + +import java.security.InvalidParameterException; + +public class BulbColor { + + private int hue; + private int saturation; + private int brightness; + private int kelvin; + + public BulbColor(int _hue, int _saturation, int _brightness, int _kelvin) { + + if ((hue > 65535) || (hue < 0)) { + throw new InvalidParameterException("BulbColor: Invalid parameter value for _hue (0-65535)"); + } + + if ((saturation > 65535) || (saturation < 0)) { + throw new InvalidParameterException("BulbColor: Invalid parameter value for _saturation (0-65535)"); + } + + if ((brightness > 65535) || (brightness < 0)) { + throw new InvalidParameterException("BulbColor: Invalid parameter value for _brightness (0-65535)"); + } + + if ((kelvin > 65535) || (kelvin < 0)) { + throw new InvalidParameterException("BulbColor: Invalid parameter value for _kelvin (0-65535)"); + } + + hue = _hue; + saturation = _saturation; + brightness = _brightness; + kelvin = _kelvin; + } + + public BulbColor(byte[] data) { + hue = ((data[1] & 0xFF) << 8); + hue |= (data[0] & 0xFF); + + saturation = ((data[3] & 0xFF) << 8); + saturation |= (data[2] & 0xFF); + + brightness = ((data[5] & 0xFF) << 8); + brightness |= (data[4] & 0xFF); + + kelvin = ((data[7] & 0xFF) << 8); + kelvin |= (data[6] & 0xFF); + } + + public int getHue() { + return hue; + } + + public int getSaturation() { + return saturation; + } + + public int getBrightness() { + return brightness; + } + + public int getKelvin() { + return kelvin; + } +} + + diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateGroup.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateGroup.java new file mode 100644 index 0000000..9ed6c91 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateGroup.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateGroup { + byte[] group = new byte[16]; + final String label; + final long updatedAt; + + public DeviceStateGroup(byte[] _location, String _label, long _updatedAt) { + group = _location; + label = _label; + updatedAt = _updatedAt; + } + + public byte[] getGroup() { + return group; + } + + public String getLabel() { + return label; + } + + public long getUpdatedAt() { + return updatedAt; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostFirmware.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostFirmware.java new file mode 100644 index 0000000..4447ca0 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostFirmware.java @@ -0,0 +1,21 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateHostFirmware { + // time of build in nanosecond accuracy + // after some tests + final long build; + final long version; // firmware version + + public DeviceStateHostFirmware(long _build, long _version) { + build = _build; + version = _version; + } + + public long getBuild() { + return build; + } + + public long getVersion() { + return version; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostInfo.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostInfo.java new file mode 100644 index 0000000..a10213d --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateHostInfo.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateHostInfo { + final long signal; + final long tx; + final long rx; + + public DeviceStateHostInfo(long _signal, long _tx, long _rx) { + signal = _signal; + tx = _tx; + rx = _rx; + } + + public long getSignal() { + return signal; + } + + public long getTx() { + return tx; + } + + public long getRx() { + return rx; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateInfo.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateInfo.java new file mode 100644 index 0000000..6f8e397 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateInfo.java @@ -0,0 +1,26 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateInfo { + // all values are in nanoseconds + private final long time; + private final long upTime; + private final long downTime; + + public DeviceStateInfo(long _time, long _upTime, long _downTime) { + time = _time; + upTime = _upTime; + downTime = _downTime; + } + + public long getTime() { + return time; + } + + public long getUpTime() { + return upTime; + } + + public long getDownTime() { + return downTime; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateLocation.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateLocation.java new file mode 100644 index 0000000..e5d3e08 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateLocation.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateLocation { + byte[] location = new byte[16]; + final String label; + final long updatedAt; + + public DeviceStateLocation(byte[] _location, String _label, long _updatedAt) { + location = _location; + label = _label; + updatedAt = _updatedAt; + } + + public byte[] getLocation() { + return location; + } + + public String getLabel() { + return label; + } + + public long getUpdatedAt() { + return updatedAt; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateService.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateService.java new file mode 100644 index 0000000..22f34ac --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateService.java @@ -0,0 +1,19 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateService { + private final int service; + private final long port; + + public DeviceStateService(int _service, long _port) { + service = _service; + port = _port; + } + + public int getService() { + return service; + } + + public long getPort() { + return port; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateVersion.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateVersion.java new file mode 100644 index 0000000..f2f0200 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateVersion.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateVersion { + final long vender; + final long product; + final long version; + + public DeviceStateVersion(long _vender, long _product, long _version) { + vender = _vender; + product = _product; + version = _version; + } + + public long getVender() { + return vender; + } + + public long getProduct() { + return product; + } + + public long getVersion() { + return version; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiFirmware.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiFirmware.java new file mode 100644 index 0000000..50bafe9 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiFirmware.java @@ -0,0 +1,21 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateWifiFirmware { + // time of build in nanosecond accuracy + // after some tests + final long build; + final long version; // firmware version + + public DeviceStateWifiFirmware(long _build, long _version) { + build = _build; + version = _version; + } + + public long getBuild() { + return build; + } + + public long getVersion() { + return version; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiInfo.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiInfo.java new file mode 100644 index 0000000..b2d8e02 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/DeviceStateWifiInfo.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class DeviceStateWifiInfo { + final long signal; + final long tx; + final long rx; + + public DeviceStateWifiInfo(long _signal, long _tx, long _rx) { + signal = _signal; + tx = _tx; + rx = _rx; + } + + public long getSignal() { + return signal; + } + + public long getTx() { + return tx; + } + + public long getRx() { + return rx; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/LifxHeader.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/LifxHeader.java new file mode 100644 index 0000000..70d314f --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/LifxHeader.java @@ -0,0 +1,263 @@ +package iotcode.LifxLightBulb; + +import java.security.InvalidParameterException; + +public class LifxHeader { + // Frame Variables + private int size; + private int origin; + private boolean tagged; + private boolean addressable; + private int protocol; + private long source; + + //Frame Adress Variables + private byte[] macAddress = new byte[8]; + private boolean ack_required; + private boolean res_required; + private int sequence; + + //Protocol Header + private int type; + + public LifxHeader() { + // needed values as per spec + origin = 0; + addressable = true; + protocol = 1024; + } + + public void setSize(int _size) { + if (_size < 0) { + throw new InvalidParameterException("Header: size cannot be less than 0"); + } else if (_size > 65535) { + throw new InvalidParameterException("Header: size to large"); + } + size = _size; + } + + public void setOrigin(int _origin) { + if (_origin < 0) { + throw new InvalidParameterException("Header: origin cannot be less than 0"); + } else if (_origin > 3) { + throw new InvalidParameterException("Header: origin to large"); + } + + origin = _origin; + } + + public void setTagged(boolean _tagged) { + tagged = _tagged; + } + + public void setAddressable(boolean _addressable) { + addressable = _addressable; + } + + public void setProtocol(int _protocol) { + if (_protocol < 0) { + throw new InvalidParameterException("Header: protocol cannot be less than 0"); + } else if (_protocol > 4095) { + throw new InvalidParameterException("Header: protocol to large"); + } + + protocol = _protocol; + } + + public void setSource(long _source) { + if (_source < 0) { + throw new InvalidParameterException("Header: source cannot be less than 0"); + } else if (_source > (long)4294967295l) { + throw new InvalidParameterException("Header: source to large"); + } + source = _source; + } + + public void setSequence(int _sequence) { + if (_sequence < 0) { + throw new InvalidParameterException("Header: sequence cannot be less than 0"); + } else if (_sequence > 255) { + throw new InvalidParameterException("Header: sequence to large"); + } + sequence = _sequence; + } + + public void setType(int _type) { + if (_type < 0) { + throw new InvalidParameterException("Header: type cannot be less than 0"); + } else if (_type > 65535) { + throw new InvalidParameterException("Header: type to large"); + } + type = _type; + } + + public void setAck_required(boolean _ack_required) { + ack_required = _ack_required; + } + + public void setRes_required(boolean _res_required) { + res_required = _res_required; + } + + public void setMacAddress(byte[] _macAddress) { + macAddress = _macAddress; + } + + public int getSize() { + return size; + } + + public int getOrigin() { + return origin; + } + + public boolean getTagged() { + return tagged; + } + + public boolean getAddressable() { + return addressable; + } + + public int getProtocol() { + return protocol; + } + + public long getSource() { + return source; + } + + public int getSequence() { + return sequence; + } + + public int getType() { + return type; + } + + public byte[] getMacAddress() { + return macAddress; + } + + public boolean getAck_required() { + return ack_required; + } + + public boolean getRes_required() { + return res_required; + } + + public byte[] getHeaderBytes() { + byte[] headerBytes = new byte[36]; + headerBytes[0] = (byte)(size & 0xFF); + headerBytes[1] = (byte)((size >> 8) & 0xFF); + + + headerBytes[2] = (byte)(protocol & 0xFF); + headerBytes[3] = (byte)((protocol >> 8) & 0x0F); + + headerBytes[3] |= (byte)((origin & 0x03) << 6); + + if (tagged) { + headerBytes[3] |= (1 << 5); + } + + if (addressable) { + headerBytes[3] |= (1 << 4); + } + + headerBytes[4] = (byte)((source >> 0) & 0xFF); + headerBytes[5] = (byte)((source >> 8) & 0xFF); + headerBytes[6] = (byte)((source >> 16) & 0xFF); + headerBytes[7] = (byte)((source >> 24) & 0xFF); + + + // fix in a bit + headerBytes[8] = macAddress[0]; + headerBytes[9] = macAddress[1]; + headerBytes[10] = macAddress[2]; + headerBytes[11] = macAddress[3]; + headerBytes[12] = macAddress[4]; + headerBytes[13] = macAddress[5]; + headerBytes[14] = macAddress[6]; + headerBytes[15] = macAddress[7]; + + // Reserved and set to 0 + // headerBytes[16] = 0; + // headerBytes[17] = 0; + // headerBytes[18] = 0; + // headerBytes[19] = 0; + // headerBytes[20] = 0; + // headerBytes[21] = 0; + + if (ack_required) { + headerBytes[22] = (1 << 1); + } + + if (res_required) { + headerBytes[22] |= (1); + } + + headerBytes[23] = (byte)(sequence & 0xFF); + + // Reserved and set to 0 + //headerBytes[24] = 0; + //headerBytes[25] = 0; + //headerBytes[26] = 0; + //headerBytes[27] = 0; + //headerBytes[28] = 0; + //headerBytes[29] = 0; + //headerBytes[30] = 0; + //headerBytes[31] = 0; + + headerBytes[32] = (byte)((type >> 0) & 0xFF); + headerBytes[33] = (byte)((type >> 8) & 0xFF); + + // Reserved and set to 0 + //headerBytes[34] = 0; + //headerBytes[35] = 0; + + return headerBytes; + } + + public void setFromBytes(byte[] dataBytes) { + if (dataBytes.length != 36) { + throw new InvalidParameterException("Header: invalid number of bytes"); + } + + size = dataBytes[0] & 0xFF; + size |= ((dataBytes[1] & 0xFF) << 8); + size &= 0xFFFF; + + origin = (dataBytes[3] >> 6) & 0x03; + tagged = ((dataBytes[3] >> 5) & 0x01) == 1; + addressable = ((dataBytes[3] >> 4) & 0x01) == 1; + + + protocol = (dataBytes[3] & 0x0F) << 8; + protocol |= dataBytes[2]; + protocol &= 0x0FFF; + + source = (dataBytes[7] & 0xFFl) << 24; + source |= ((dataBytes[6] & 0xFFl) << 16); + source |= ((dataBytes[5] & 0xFFl) << 8); + source |= ((dataBytes[4] & 0xFFl)); + + macAddress[0] = dataBytes[8]; + macAddress[1] = dataBytes[9]; + macAddress[2] = dataBytes[10]; + macAddress[3] = dataBytes[11]; + macAddress[4] = dataBytes[12]; + macAddress[5] = dataBytes[13]; + macAddress[6] = dataBytes[14]; + macAddress[7] = dataBytes[15]; + + ack_required = (dataBytes[22] & 0x02) == 0x02; + res_required = (dataBytes[22] & 0x01) == 0x01; + + sequence = (dataBytes[23] & 0xFF); + + type = ((dataBytes[33] & 0xFF) << 8); + type |= (dataBytes[32] & 0xFF); + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/LightBulb_Skeleton.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/LightBulb_Skeleton.java new file mode 100644 index 0000000..3b808fa --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/LightBulb_Skeleton.java @@ -0,0 +1,520 @@ +package iotcode.LifxLightBulb; + +import java.io.IOException; +import java.util.List; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Map; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicBoolean; +import iotrmi.Java.IoTRMIComm; +import iotrmi.Java.IoTRMICommClient; +import iotrmi.Java.IoTRMICommServer; +import iotrmi.Java.IoTRMIUtil; + +import iotcode.interfaces.LightBulb; + +public class LightBulb_Skeleton implements LightBulb { + + private LightBulb mainObj; + private int objectId = 1; + // Communications and synchronizations + private IoTRMIComm rmiComm; + private AtomicBoolean didAlreadyInitWaitInvoke; + private AtomicBoolean methodReceived; + private byte[] methodBytes = null; + // Permissions + private static Integer[] object1Permission = { 2, 10, 1, 3, 11, 8, 12, 7, 13, 9, 6, 16, 17, 4, 0, 14, 15, 5 }; + private static List set1Allowed; + + + public LightBulb_Skeleton(LightBulb _mainObj, int _portSend, int _portRecv) throws Exception { + mainObj = _mainObj; + rmiComm = new IoTRMICommServer(_portSend, _portRecv); + set1Allowed = new ArrayList(Arrays.asList(object1Permission)); + IoTRMIUtil.mapSkel.put(_mainObj, this); + IoTRMIUtil.mapSkelId.put(_mainObj, objectId); + didAlreadyInitWaitInvoke = new AtomicBoolean(false); + methodReceived = new AtomicBoolean(false); + rmiComm.registerSkeleton(objectId, methodReceived); + Thread thread1 = new Thread() { + public void run() { + try { + ___waitRequestInvokeMethod(); + } + catch (Exception ex) + { + ex.printStackTrace(); + } + } + }; + thread1.start(); + } + + public LightBulb_Skeleton(LightBulb _mainObj, IoTRMIComm _rmiComm, int _objectId) throws Exception { + mainObj = _mainObj; + rmiComm = _rmiComm; + objectId = _objectId; + set1Allowed = new ArrayList(Arrays.asList(object1Permission)); + didAlreadyInitWaitInvoke = new AtomicBoolean(false); + methodReceived = new AtomicBoolean(false); + rmiComm.registerSkeleton(objectId, methodReceived); + } + + public boolean didAlreadyInitWaitInvoke() { + return didAlreadyInitWaitInvoke.get(); + } + + public void init() { + mainObj.init(); + } + + public void turnOff() { + mainObj.turnOff(); + } + + public void turnOn() { + mainObj.turnOn(); + } + + public boolean getState() { + return mainObj.getState(); + } + + public void setColor(double _hue, double _saturation, double _brightness) { + mainObj.setColor(_hue, _saturation, _brightness); + } + + public void setTemperature(int _temperature) { + mainObj.setTemperature(_temperature); + } + + public double getBrightness() { + return mainObj.getBrightness(); + } + + public double getHue() { + return mainObj.getHue(); + } + + public double getSaturation() { + return mainObj.getSaturation(); + } + + public int getTemperature() { + return mainObj.getTemperature(); + } + + public double getBrightnessRangeLowerBound() { + return mainObj.getBrightnessRangeLowerBound(); + } + + public double getBrightnessRangeUpperBound() { + return mainObj.getBrightnessRangeUpperBound(); + } + + public double getHueRangeLowerBound() { + return mainObj.getHueRangeLowerBound(); + } + + public double getHueRangeUpperBound() { + return mainObj.getHueRangeUpperBound(); + } + + public double getSaturationRangeLowerBound() { + return mainObj.getSaturationRangeLowerBound(); + } + + public double getSaturationRangeUpperBound() { + return mainObj.getSaturationRangeUpperBound(); + } + + public int getTemperatureRangeLowerBound() { + return mainObj.getTemperatureRangeLowerBound(); + } + + public int getTemperatureRangeUpperBound() { + return mainObj.getTemperatureRangeUpperBound(); + } + + public void ___init() { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + init(); + } + + public void ___turnOff() { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + turnOff(); + } + + public void ___turnOn() { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + turnOn(); + } + + public void ___getState() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getState(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___setColor() { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { double.class, double.class, double.class }, new Class[] { null, null, null }, localMethodBytes); + setColor((double) paramObj[0], (double) paramObj[1], (double) paramObj[2]); + } + + public void ___setTemperature() { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { int.class }, new Class[] { null }, localMethodBytes); + setTemperature((int) paramObj[0]); + } + + public void ___getBrightness() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getBrightness(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getHue() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getHue(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getSaturation() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getSaturation(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getTemperature() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getTemperature(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getBrightnessRangeLowerBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getBrightnessRangeLowerBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getBrightnessRangeUpperBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getBrightnessRangeUpperBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getHueRangeLowerBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getHueRangeLowerBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getHueRangeUpperBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getHueRangeUpperBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getSaturationRangeLowerBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getSaturationRangeLowerBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getSaturationRangeUpperBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getSaturationRangeUpperBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getTemperatureRangeLowerBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getTemperatureRangeLowerBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___getTemperatureRangeUpperBound() throws IOException { + byte[] localMethodBytes = methodBytes; + rmiComm.setGetMethodBytes(); + Object[] paramObj = rmiComm.getMethodParams(new Class[] { }, new Class[] { }, localMethodBytes); + Object retObj = getTemperatureRangeUpperBound(); + rmiComm.sendReturnObj(retObj, localMethodBytes); + } + + public void ___waitRequestInvokeMethod() throws IOException { + didAlreadyInitWaitInvoke.compareAndSet(false, true); + while (true) { + if (!methodReceived.get()) { + continue; + } + methodBytes = rmiComm.getMethodBytes(); + methodReceived.set(false); + int _objectId = IoTRMIComm.getObjectId(methodBytes); + int methodId = IoTRMIComm.getMethodId(methodBytes); + if (_objectId == objectId) { + if (!set1Allowed.contains(methodId)) { + throw new Error("Object with object Id: " + _objectId + " is not allowed to access method: " + methodId); + } + } + else { + continue; + } + switch (methodId) { + case 0: + new Thread() { + public void run() { + try { + ___init(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 1: + new Thread() { + public void run() { + try { + ___turnOff(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 2: + new Thread() { + public void run() { + try { + ___turnOn(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 3: + new Thread() { + public void run() { + try { + ___getState(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 4: + new Thread() { + public void run() { + try { + ___setColor(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 5: + new Thread() { + public void run() { + try { + ___setTemperature(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 6: + new Thread() { + public void run() { + try { + ___getBrightness(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 7: + new Thread() { + public void run() { + try { + ___getHue(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 8: + new Thread() { + public void run() { + try { + ___getSaturation(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 9: + new Thread() { + public void run() { + try { + ___getTemperature(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 10: + new Thread() { + public void run() { + try { + ___getBrightnessRangeLowerBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 11: + new Thread() { + public void run() { + try { + ___getBrightnessRangeUpperBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 12: + new Thread() { + public void run() { + try { + ___getHueRangeLowerBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 13: + new Thread() { + public void run() { + try { + ___getHueRangeUpperBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 14: + new Thread() { + public void run() { + try { + ___getSaturationRangeLowerBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 15: + new Thread() { + public void run() { + try { + ___getSaturationRangeUpperBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 16: + new Thread() { + public void run() { + try { + ___getTemperatureRangeLowerBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + case 17: + new Thread() { + public void run() { + try { + ___getTemperatureRangeUpperBound(); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.start(); + break; + default: + throw new Error("Method Id " + methodId + " not recognized!"); + } + } + } + +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/LightState.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/LightState.java new file mode 100644 index 0000000..6d8a1f7 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/LightState.java @@ -0,0 +1,25 @@ +package iotcode.LifxLightBulb; + +public class LightState { + private final BulbColor color; + private final int power; + private final String label; + + public LightState(BulbColor _color, int _power, String _label) { + color = _color; + power = _power; + label = _label; + } + + public BulbColor getColor() { + return color; + } + + public int getPower() { + return power; + } + + public String getLabel() { + return label; + } +} diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.config b/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.config new file mode 100644 index 0000000..f18d3d8 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.config @@ -0,0 +1,22 @@ +# Skeleton/original interface +INTERFACE_CLASS=LightBulb +# Stub +INTERFACE_STUB_CLASS=LightBulbTest + +# For C++ instrumentation +FIELD_NUMBER=1 +FIELD_0=lb_addresses +FIELD_CLASS_0=IoTDeviceAddress +FIELD_TYPE_0=IoTSet + +# Language +LANGUAGE=Java +#LANGUAGE=C++ +# Language (fine-grained flags) +#LANGUAGE_LifxLightBulbLB1=C++ +#LANGUAGE_LifxLightBulbLB1=Java +#LANGUAGE_LifxLightBulbLB2=C++ +#LANGUAGE_LifxLightBulbLB2=Java + +# Tomoyo +ADDITIONAL_MAC_POLICY=No diff --git a/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.java b/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.java new file mode 100644 index 0000000..4551e25 --- /dev/null +++ b/others/tutorial/benchmarks/drivers/SmartLightBulb/SmartLightBulb.java @@ -0,0 +1,1228 @@ +package iotcode.SmartLightBulb; + +// Standard Java Packages +import java.io.*; +import java.net.*; +import java.util.concurrent.Semaphore; +import java.security.InvalidParameterException; +import java.util.Date; +import java.util.Iterator; +import java.util.concurrent.atomic.AtomicBoolean; + +import java.util.Arrays; +import java.util.Set; +import java.util.HashSet; + +// IoT Packages +import iotcode.annotation.*; +import iotcode.interfaces.LightBulb; +import iotruntime.IoTUDP; +import iotruntime.slave.IoTDeviceAddress; +import iotruntime.slave.IoTSet; + +// String to byte conversion +import javax.xml.bind.DatatypeConverter; + +public class SmartLightBulb implements LightBulb { + + /******************************************************************************************************************************************* + ** + ** Constants + ** + *******************************************************************************************************************************************/ + public static final long GET_BULB_VERSION_RESEND_WAIT_SECONDS = 10; + + + + /******************************************************************************************************************************************* + ** + ** Variables + ** + *******************************************************************************************************************************************/ + private IoTUDP communicationSockect; + private byte[] bulbMacAddress = new byte[8]; + static Semaphore socketMutex = new Semaphore(1); + static boolean sendSocketFlag = false; + private long lastSentGetBulbVersionRequest = 0; // time last request sent + + // Current Bulb Values + private int currentHue = 0; + private int currentSaturation = 0; + private int currentBrightness = 65535; + private int currentTemperature = 9000; + private boolean bulbIsOn = false; + + + + private AtomicBoolean didAlreadyInit = new AtomicBoolean(false); + + private AtomicBoolean didGetBulbVersion = new AtomicBoolean(false); + static Semaphore settingBulbColorMutex = new Semaphore(1); + static Semaphore settingBulbTempuraturerMutex = new Semaphore(1); + static Semaphore bulbStateMutex = new Semaphore(1); + + // color and temperature ranges for the bulbs + private int hueLowerBound = 0; + private int hueUpperBound = 0; + private int saturationLowerBound = 0; + private int saturationUpperBound = 0; + private int brightnessLowerBound = 0; + private int brightnessUpperBound = 0; + private int temperatureLowerBound = 2500; + private int temperatureUpperBound = 9000; + + + + // Check if a state change was requested, used to poll the bulb for if the bulb did + // preform the requested state change + private boolean stateDidChange = false; + + /******************************************************************************************************************************************* + ** + ** Threads + ** + *******************************************************************************************************************************************/ + + // Main worker thread will do the receive loop + Thread workerThread = null; + + /******************************************************************************************************************************************* + ** + ** IoT Sets and Relations + ** + *******************************************************************************************************************************************/ + + // IoTSet of Device Addresses. + // Will be filled with only 1 address. + @config private IoTSet lb_addresses; + + /** + * Used for testing only + */ + /*public SmartLightBulb(IoTUDP udp, byte[] macAddress) { + communicationSockect = udp; + bulbMacAddress = macAddress; + }*/ + + public SmartLightBulb(IoTSet _lb_addresses, String macAddress) { + this(macAddress); + lb_addresses = _lb_addresses; + } + + public SmartLightBulb(String macAddress) { + communicationSockect = null; + + // Set the Mac Address to a default value + // Probably not needed for anything + /*bulbMacAdd[0] = (byte)0x00; + bulbMacAdd[1] = (byte)0x00; + bulbMacAdd[2] = (byte)0x00; + bulbMacAdd[3] = (byte)0x00; + bulbMacAdd[4] = (byte)0x00; + bulbMacAdd[5] = (byte)0x00; + bulbMacAdd[6] = (byte)0x00; + bulbMacAdd[7] = (byte)0x00;*/ + + bulbMacAddress = DatatypeConverter.parseHexBinary(macAddress); + } + + + + /******************************************************************************************************************************************* + ** Sending + ** Device Messages + ** + *******************************************************************************************************************************************/ + private void sendGetServicePacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(true); + header.setMacAddress(bulbMacAddress); + header.setSource(0); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(2); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetHostInfoPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(12); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetHostFirmwarePacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(14); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetWifiInfoPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(16); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetWifiFirmwarePacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(18); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetPowerPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(20); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendSetPowerPacket(int level) { + // Currently only 0 and 65535 are supported + // This is a fix for now + if ((level != 65535) && (level != 0)) { + throw new InvalidParameterException("Invalid parameter values"); + } + + if ((level > 65535) || (level < 0)) { + throw new InvalidParameterException("Invalid parameter values"); + } + + byte[] packetBytes = new byte[38]; + + LifxHeader header = new LifxHeader(); + header.setSize(38); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(21); + byte[] headerBytes = header.getHeaderBytes(); + + for (int i = 0; i < 36; i++) { + packetBytes[i] = headerBytes[i]; + } + + packetBytes[36] = (byte)(level & 0xFF); + packetBytes[37] = (byte)((level >> 8) & 0xFF); + + sendPacket(packetBytes); + } + + private void sendGetLabelPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(23); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendSetLabelPacket(String label) { + // Currently only 0 and 65535 are supported + // This is a fix for now + if (label.length() != 32) { + throw new InvalidParameterException("Invalid parameter values, label must be 32 bytes long"); + } + + byte[] packetBytes = new byte[68]; + + LifxHeader header = new LifxHeader(); + header.setSize(68); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(24); + byte[] headerBytes = header.getHeaderBytes(); + + for (int i = 0; i < 36; i++) { + packetBytes[i] = headerBytes[i]; + } + + for (int i = 0; i < 32; i++) { + packetBytes[i + 36] = label.getBytes()[i]; + } + + sendPacket(packetBytes); + } + + private void sendGetVersionPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(32); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetInfoPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(34); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetLocationPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(34); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendGetGroupPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(51); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + + /******************************************************************************************************************************************* + ** Sending + ** Light Messages + ** + *******************************************************************************************************************************************/ + private void sendGetLightStatePacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(101); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendSetLightColorPacket(BulbColor bulbColor, long duration) { + + if ((duration > 4294967295l) || (duration < 0)) { + throw new InvalidParameterException("Invalid parameter value, duration out of range (0 - 4294967295)"); + } + + byte[] packetBytes = new byte[49]; + + LifxHeader header = new LifxHeader(); + header.setSize(49); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(102); + byte[] headerBytes = header.getHeaderBytes(); + + for (int i = 0; i < 36; i++) { + packetBytes[i] = headerBytes[i]; + } + + // 1 reserved packet + packetBytes[37] = (byte)(bulbColor.getHue() & 0xFF); + packetBytes[38] = (byte)((bulbColor.getHue() >> 8) & 0xFF); + + packetBytes[39] = (byte)(bulbColor.getSaturation() & 0xFF); + packetBytes[40] = (byte)((bulbColor.getSaturation() >> 8) & 0xFF); + + packetBytes[41] = (byte)(bulbColor.getBrightness() & 0xFF); + packetBytes[42] = (byte)((bulbColor.getBrightness() >> 8) & 0xFF); + + packetBytes[43] = (byte)(bulbColor.getKelvin() & 0xFF); + packetBytes[44] = (byte)((bulbColor.getKelvin() >> 8) & 0xFF); + + packetBytes[45] = (byte)((duration >> 0) & 0xFF); + packetBytes[46] = (byte)((duration >> 8) & 0xFF); + packetBytes[47] = (byte)((duration >> 16) & 0xFF); + packetBytes[48] = (byte)((duration >> 24) & 0xFF); + + sendPacket(packetBytes); + } + + private void sendGetLightPowerPacket() { + LifxHeader header = new LifxHeader(); + header.setSize(36); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(116); + + byte[] dataBytes = header.getHeaderBytes(); + sendPacket(dataBytes); + } + + private void sendSetLightPowerPacket(int level, long duration) { + + if ((level > 65535) || (duration > 4294967295l) + || (level < 0) || (duration < 0)) { + throw new InvalidParameterException("Invalid parameter values"); + } + + byte[] packetBytes = new byte[42]; + + + LifxHeader header = new LifxHeader(); + header.setSize(42); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(117); + byte[] headerBytes = header.getHeaderBytes(); + + for (int i = 0; i < 36; i++) { + packetBytes[i] = headerBytes[i]; + } + + packetBytes[36] = (byte)(level & 0xFF); + packetBytes[37] = (byte)((level >> 8) & 0xFF); + + packetBytes[38] = (byte)((duration >> 0) & 0xFF); + packetBytes[39] = (byte)((duration >> 8) & 0xFF); + packetBytes[40] = (byte)((duration >> 16) & 0xFF); + packetBytes[41] = (byte)((duration >> 24) & 0xFF); + + System.out.println(Arrays.toString(packetBytes)); + + sendPacket(packetBytes); + } + + private void sendEchoRequestPacket(byte[] data) { + // Currently only 0 and 65535 are supported + // This is a fix for now + if (data.length != 64) { + throw new InvalidParameterException("Invalid parameter values, must have 64 bytes"); + } + + byte[] packetBytes = new byte[100]; + + LifxHeader header = new LifxHeader(); + header.setSize(100); + header.setTagged(false); + header.setMacAddress(bulbMacAddress); + header.setSource(10); // randomly picked + header.setAck_required(false); + header.setRes_required(false); + header.setSequence(0); + header.setType(58); + byte[] headerBytes = header.getHeaderBytes(); + + for (int i = 0; i < 36; i++) { + packetBytes[i] = headerBytes[i]; + } + + for (int i = 0; i < 64; i++) { + packetBytes[i + 36] = data[i]; + } + + sendPacket(packetBytes); + } + + + /******************************************************************************************************************************************* + ** Receiving + ** Device Messages + ** + *******************************************************************************************************************************************/ + private DeviceStateService parseDeviceStateServiceMessage(LifxHeader header, byte[] payloadData) { + int service = payloadData[0]; + long port = ((payloadData[3] & 0xFF) << 24); + port |= ((payloadData[2] & 0xFF) << 16); + port |= ((payloadData[1] & 0xFF) << 8); + port |= (payloadData[0] & 0xFF); + + return new DeviceStateService(service, port); + } + + private DeviceStateHostInfo parseDeviceStateHostInfoMessage(LifxHeader header, byte[] payloadData) { + long signal = ((payloadData[3] & 0xFF) << 24); + signal |= ((payloadData[2] & 0xFF) << 16); + signal |= ((payloadData[1] & 0xFF) << 8); + signal |= (payloadData[0] & 0xFF); + + long tx = ((payloadData[7] & 0xFF) << 24); + tx |= ((payloadData[6] & 0xFF) << 16); + tx |= ((payloadData[5] & 0xFF) << 8); + tx |= (payloadData[4] & 0xFF); + + long rx = ((payloadData[11] & 0xFF) << 24); + rx |= ((payloadData[10] & 0xFF) << 16); + rx |= ((payloadData[9] & 0xFF) << 8); + rx |= (payloadData[8] & 0xFF); + + return new DeviceStateHostInfo(signal, tx, rx); + } + + private DeviceStateHostFirmware parseDeviceStateHostFirmwareMessage(LifxHeader header, byte[] payloadData) { + long build = 0; + for (int i = 0; i < 8; i++) { + build += ((long) payloadData[i] & 0xffL) << (8 * i); + } + + // 8 reserved bytes + + long version = ((payloadData[19] & 0xFF) << 24); + version |= ((payloadData[18] & 0xFF) << 16); + version |= ((payloadData[17] & 0xFF) << 8); + version |= (payloadData[16] & 0xFF); + + return new DeviceStateHostFirmware(build, version); + } + + private DeviceStateWifiInfo parseDeviceStateWifiInfoMessage(LifxHeader header, byte[] payloadData) { + long signal = ((payloadData[3] & 0xFF) << 24); + signal |= ((payloadData[2] & 0xFF) << 16); + signal |= ((payloadData[1] & 0xFF) << 8); + signal |= (payloadData[0] & 0xFF); + + long tx = ((payloadData[7] & 0xFF) << 24); + tx |= ((payloadData[6] & 0xFF) << 16); + tx |= ((payloadData[5] & 0xFF) << 8); + tx |= (payloadData[4] & 0xFF); + + long rx = ((payloadData[11] & 0xFF) << 24); + rx |= ((payloadData[10] & 0xFF) << 16); + rx |= ((payloadData[9] & 0xFF) << 8); + rx |= (payloadData[8] & 0xFF); + + return new DeviceStateWifiInfo(signal, tx, rx); + } + + private DeviceStateWifiFirmware parseDeviceStateWifiFirmwareMessage(LifxHeader header, byte[] payloadData) { + long build = 0; + for (int i = 0; i < 8; i++) { + build += ((long) payloadData[i] & 0xffL) << (8 * i); + } + + // 8 reserved bytes + + long version = ((payloadData[19] & 0xFF) << 24); + version |= ((payloadData[18] & 0xFF) << 16); + version |= ((payloadData[17] & 0xFF) << 8); + version |= (payloadData[16] & 0xFF); + + return new DeviceStateWifiFirmware(build, version); + } + + private int parseStatePowerMessage(LifxHeader header, byte[] payloadData) { + int level = ((payloadData[1] & 0xFF) << 8); + level |= (payloadData[0] & 0xFF); + return level; + } + + private String parseStateLabelMessage(LifxHeader header, byte[] payloadData) { + return new String(payloadData); + } + + + private DeviceStateVersion parseDeviceStateVersionMessage(LifxHeader header, byte[] payloadData) { + long vender = ((payloadData[3] & 0xFF) << 24); + vender |= ((payloadData[2] & 0xFF) << 16); + vender |= ((payloadData[1] & 0xFF) << 8); + vender |= (payloadData[0] & 0xFF); + + long product = ((payloadData[7] & 0xFF) << 24); + product |= ((payloadData[6] & 0xFF) << 16); + product |= ((payloadData[5] & 0xFF) << 8); + product |= (payloadData[4] & 0xFF); + + long version = ((payloadData[11] & 0xFF) << 24); + version |= ((payloadData[10] & 0xFF) << 16); + version |= ((payloadData[9] & 0xFF) << 8); + version |= (payloadData[8] & 0xFF); + + return new DeviceStateVersion(vender, product, version); + } + + private DeviceStateInfo parseDeviceStateInfoMessage(LifxHeader header, byte[] payloadData) { + long time = 0; + long upTime = 0; + long downTime = 0; + for (int i = 0; i < 8; i++) { + time += ((long) payloadData[i] & 0xffL) << (8 * i); + upTime += ((long) payloadData[i + 8] & 0xffL) << (8 * i); + downTime += ((long) payloadData[i + 16] & 0xffL) << (8 * i); + } + + return new DeviceStateInfo(time, upTime, downTime); + } + + private DeviceStateLocation parseDeviceStateLocationMessage(LifxHeader header, byte[] payloadData) { + byte[] location = new byte[16]; + for (int i = 0; i < 16; i++) { + location[i] = payloadData[i]; + } + + byte[] labelBytes = new byte[32]; + for (int i = 0; i < 32; i++) { + labelBytes[i] = payloadData[i + 16]; + } + + long updatedAt = 0; + for (int i = 0; i < 8; i++) { + updatedAt += ((long) payloadData[48] & 0xffL) << (8 * i); + } + + return new DeviceStateLocation(location, new String(labelBytes), updatedAt); + } + + private DeviceStateGroup parseDeviceStateGroupMessage(LifxHeader header, byte[] payloadData) { + byte[] group = new byte[16]; + for (int i = 0; i < 16; i++) { + group[i] = payloadData[i]; + } + + byte[] labelBytes = new byte[32]; + for (int i = 0; i < 32; i++) { + labelBytes[i] = payloadData[i + 16]; + } + + long updatedAt = 0; + for (int i = 0; i < 8; i++) { + updatedAt += ((long) payloadData[48] & 0xffL) << (8 * i); + } + + return new DeviceStateGroup(group, new String(labelBytes), updatedAt); + } + + private byte[] parseDeviceEchoResponseMessage(LifxHeader header, byte[] payloadData) { + return payloadData; + } + + /******************************************************************************************************************************************* + ** Receiving + ** Light Messages + ** + *******************************************************************************************************************************************/ + private LightState parseLightStateMessage(LifxHeader header, byte[] payloadData) { + + byte[] colorData = new byte[8]; + for (int i = 0; i < 8; i++) { + colorData[i] = payloadData[i]; + } + BulbColor color = new BulbColor(colorData); + + int power = ((payloadData[11] & 0xFF) << 8); + power |= (payloadData[10] & 0xFF); + + String label = new String(payloadData); + + byte[] labelArray = new byte[32]; + for (int i = 0; i < 32; i++) { + labelArray[i] = payloadData[12 + i]; + } + + return new LightState(color, power, label); + } + + private int parseLightStatePowerMessage(LifxHeader header, byte[] payloadData) { + int level = ((payloadData[1] & 0xFF) << 8); + level |= (payloadData[0] & 0xFF); + return level; + } + + + /******************************************************************************************************************************************* + ** + ** Private Handlers + ** + *******************************************************************************************************************************************/ + private void handleStateVersionMessageRecieved(LifxHeader header, byte[] payloadData) { + + DeviceStateVersion deviceState = parseDeviceStateVersionMessage(header, payloadData); + int productNumber = (int)deviceState.getProduct(); + + boolean isColor = false; + + if (productNumber == 1) {// Original 1000 + isColor = true; + } else if (productNumber == 3) {//Color 650 + isColor = true; + } else if (productNumber == 10) {// White 800 (Low Voltage) + isColor = false; + } else if (productNumber == 11) {// White 800 (High Voltage) + isColor = false; + } else if (productNumber == 18) {// White 900 BR30 (Low Voltage) + isColor = false; + } else if (productNumber == 20) {// Color 1000 BR30 + isColor = true; + } else if (productNumber == 22) {// Color 1000 + isColor = true; + } + + if (isColor) { + hueLowerBound = 0; + hueUpperBound = 65535; + saturationLowerBound = 0; + saturationUpperBound = 65535; + brightnessLowerBound = 0; + brightnessUpperBound = 65535; + temperatureLowerBound = 2500; + temperatureUpperBound = 9000; + } else { + hueLowerBound = 0; + hueUpperBound = 0; + saturationLowerBound = 0; + saturationUpperBound = 0; + brightnessLowerBound = 0; + brightnessUpperBound = 65535;// still can dim bulb + temperatureLowerBound = 2500; + temperatureUpperBound = 9000; + } + + didGetBulbVersion.set(true); + + } + + private void handleLightStateMessageRecieved(LifxHeader header, byte[] payloadData) { + LightState lightState = parseLightStateMessage(header, payloadData); + + BulbColor color = lightState.getColor(); + int power = lightState.getPower(); + + boolean bulbWrongColor = false; + bulbWrongColor = bulbWrongColor || (color.getHue() != currentHue); + bulbWrongColor = bulbWrongColor || (color.getSaturation() != currentSaturation); + bulbWrongColor = bulbWrongColor || (color.getBrightness() != currentBrightness); + bulbWrongColor = bulbWrongColor || (color.getKelvin() != currentTemperature); + + + // gets set to true if any of the below if statements are taken + stateDidChange = false; + + if (bulbWrongColor) { + BulbColor newColor = new BulbColor(currentHue, currentSaturation, currentBrightness, currentTemperature); + sendSetLightColorPacket(newColor, 250); + // System.out.println("Failed Check 1"); + } + + try { + bulbStateMutex.acquire(); + } catch (Exception e) { + e.printStackTrace(); + } + boolean bulbIsOnTmp = bulbIsOn; + bulbStateMutex.release(); + + if ((!bulbIsOnTmp) && (power != 0)) { + turnOff(); + // System.out.println("Failed Check 2: " + Integer.toString(power)); + + } + + if (bulbIsOnTmp && (power < 65530)) { + turnOn(); + // System.out.println("Failed Check 3: " + Integer.toString(power)); + + } + } + + /******************************************************************************************************************************************* + ** + ** Light Bulb Interface Methods + ** + *******************************************************************************************************************************************/ + public double getHue() { + double tmp = 0; + try { + settingBulbColorMutex.acquire(); + tmp = ((double)currentHue / 65535.0) * 360.0; + } catch (Exception e) { + e.printStackTrace(); + } + settingBulbColorMutex.release(); + + + return tmp; + } + + public double getSaturation() { + double tmp = 0; + try { + settingBulbColorMutex.acquire(); + tmp = ((double)currentSaturation / 65535.0) * 360.0; + } catch (Exception e) { + e.printStackTrace(); + } + settingBulbColorMutex.release(); + + + return tmp; + } + + public double getBrightness() { + double tmp = 0; + try { + settingBulbColorMutex.acquire(); + tmp = ((double)currentBrightness / 65535.0) * 360.0; + } catch (Exception e) { + e.printStackTrace(); + } + settingBulbColorMutex.release(); + + return tmp; + } + + public int getTemperature() { + + int tmp = 0; + try { + settingBulbTempuraturerMutex.acquire(); + tmp = currentTemperature; + } catch (Exception e) { + e.printStackTrace(); + } + settingBulbTempuraturerMutex.release(); + + return tmp; + } + + public double getHueRangeLowerBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)hueLowerBound / 65535.0) * 360.0; + } + + public double getHueRangeUpperBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)hueUpperBound / 65535.0) * 360.0; + } + + public double getSaturationRangeLowerBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)saturationLowerBound / 65535.0) * 100.0; + } + + public double getSaturationRangeUpperBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)saturationUpperBound / 65535.0) * 100.0; + } + + public double getBrightnessRangeLowerBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)brightnessLowerBound / 65535.0) * 100.0; + } + + public double getBrightnessRangeUpperBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return ((double)brightnessUpperBound / 65535.0) * 100.0; + } + + public int getTemperatureRangeLowerBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return temperatureLowerBound; + } + + public int getTemperatureRangeUpperBound() { + if (!didGetBulbVersion.get()) { + return -1; + } + return temperatureUpperBound; + } + + public void setTemperature(int _temperature) { + + try { + settingBulbTempuraturerMutex.acquire(); + } catch (Exception e) { + e.printStackTrace(); + } + + BulbColor newColor = new BulbColor(currentHue, currentSaturation, currentBrightness, _temperature); + sendSetLightColorPacket(newColor, 250); + + currentTemperature = _temperature; + stateDidChange = true; + + settingBulbTempuraturerMutex.release(); + } + + public void setColor(double _hue, double _saturation, double _brightness) { + + try { + settingBulbColorMutex.acquire(); + } catch (Exception e) { + e.printStackTrace(); + } + + + _hue /= 360.0; + _saturation /= 100.0; + _brightness /= 100.0; + + + int newHue = (int)(_hue * 65535.0); + int newSaturation = (int)(_saturation * 65535.0); + int newBrightness = (int)(_brightness * 65535.0); + + BulbColor newColor = new BulbColor(newHue, newSaturation, newBrightness, currentTemperature); + sendSetLightColorPacket(newColor, 250); + + currentHue = newHue; + currentSaturation = newSaturation; + currentBrightness = newBrightness; + stateDidChange = true; + + settingBulbColorMutex.release(); + } + + + public void turnOff() { + + try { + bulbStateMutex.acquire(); + bulbIsOn = false; + sendSetLightPowerPacket(0, 0); + stateDidChange = true; + } catch (Exception e) { + e.printStackTrace(); + } + + bulbStateMutex.release(); + } + + public void turnOn() { + try { + bulbStateMutex.acquire(); + bulbIsOn = true; + sendSetLightPowerPacket(65535, 0); + stateDidChange = true; + + } catch (Exception e) { + e.printStackTrace(); + } + + + bulbStateMutex.release(); + } + + public boolean getState() { + + boolean tmp = false; + try { + bulbStateMutex.acquire(); + tmp = bulbIsOn; + } catch (Exception e) { + e.printStackTrace(); + } + + bulbStateMutex.release(); + + return tmp; + } + + + /******************************************************************************************************************************************* + ** + ** Communication Helpers + ** + *******************************************************************************************************************************************/ + private void recievedPacket(byte[] packetData) { + + byte[] headerBytes = new byte[36]; + for (int i = 0; i < 36; i++) { + headerBytes[i] = packetData[i]; + } + + LifxHeader recHeader = new LifxHeader(); + recHeader.setFromBytes(headerBytes); + + // load the payload bytes (strip away the header) + byte[] payloadBytes = new byte[recHeader.getSize()]; + for (int i = 36; i < recHeader.getSize(); i++) { + payloadBytes[i - 36] = packetData[i]; + } + + System.out.println("Received: " + Integer.toString(recHeader.getType())); + + switch (recHeader.getType()) { + case 3: + DeviceStateService dat = parseDeviceStateServiceMessage(recHeader, payloadBytes); + // System.out.println("Service: " + Integer.toString(dat.getService())); + // System.out.println("Port : " + Long.toString(dat.getPort())); + break; + + + case 33: + handleStateVersionMessageRecieved(recHeader, payloadBytes); + break; + + case 35: + parseDeviceStateInfoMessage(recHeader, payloadBytes); + break; + + + case 107: + handleLightStateMessageRecieved(recHeader, payloadBytes); + break; + + default: + // System.out.println("unknown packet Type"); + } + + } + + private void sendPacket(byte[] packetData) { + // System.out.println("About to send"); + sendSocketFlag = true; + + try { + socketMutex.acquire(); + } catch (InterruptedException e) { + System.out.println("mutex Error"); + } + + try { + communicationSockect.sendData(packetData); + + } catch (IOException e) { + System.out.println("Socket Send Error"); + } + + sendSocketFlag = false; + socketMutex.release(); + } + + + /** + * Worker function which runs the while loop for receiving data from the bulb. + * Is blocking + */ + private void workerFunction() { + LifxHeader h = new LifxHeader(); + + try { + // Need timeout on receives since we are not sure if a packet will be available + // for processing so don't block waiting + communicationSockect.setSoTimeout(50); + } catch (IOException e) { + } + + // Start the bulb in the off state + turnOff(); + + while (true) { + + // Check if we got the bulb version yet + // could have requested it but message could have gotten lost (UDP) + if (!didGetBulbVersion.get()) { + long currentTime = (new Date().getTime()) / 1000; + if ((currentTime - lastSentGetBulbVersionRequest) > GET_BULB_VERSION_RESEND_WAIT_SECONDS) { + // Get the bulb version so we know what type of bulb this is. + sendGetVersionPacket(); + lastSentGetBulbVersionRequest = currentTime; + } + } + + // Communication resource is busy so try again later + if (sendSocketFlag) { + continue; + } + + try { + socketMutex.acquire(); + } catch (InterruptedException e) { + } + + byte[] dat = null; + try { + dat = communicationSockect.recieveData(1024); + } catch (java.net.SocketTimeoutException e) { + // Timeout occurred + + } catch (IOException e) { + // Problem but might be able to recover?? + e.printStackTrace(); + + } + + // Never forget to release! + socketMutex.release(); + + // A packed arrived + if (dat != null) { + recievedPacket(dat); + } + + // If a state change occurred then request the bulb state to ensure that the + // bulb did indeed change its state to the correct state + if (stateDidChange) { + sendGetLightStatePacket(); + } + + // Wait a bit as to not tie up system resources + try { + Thread.sleep(100); + } catch (Exception e) { + + } + + + } + } + + + public void init() { + + if (didAlreadyInit.compareAndSet(false, true) == false) { + return; // already init + } + + try { + // Get the bulb address from the IoTSet + Iterator itr = lb_addresses.iterator(); + IoTDeviceAddress deviceAddress = (IoTDeviceAddress)itr.next(); + + System.out.println("Address: " + deviceAddress.getCompleteAddress()); + + // Create the communication channel + communicationSockect = new IoTUDP(deviceAddress); + + } catch (IOException e) { + e.printStackTrace(); + } + + // Launch the worker function in a separate thread. + workerThread = new Thread(new Runnable() { + public void run() { + workerFunction(); + } + }); + workerThread.start(); + + } + + + /* TODO: Uncomment this part to do light bulb test + public static void main(String[] args) throws Exception { + + System.out.println("Executing main function!"); + IoTDeviceAddress iotDevAdd = new IoTDeviceAddress(args[0], 12345, 56700, false, false); + Set set = new HashSet(); + set.add(iotDevAdd); + IoTSet iotset = new IoTSet(set); + SmartLightBulb lb = new SmartLightBulb(iotset, "D073D5128E300000"); + try { + lb.init(); + Thread.sleep(1000); + for (int i = 0; i < 2; i++) { + lb.turnOff(); + System.out.println("Turning off!"); + Thread.sleep(1000); + lb.turnOn(); + System.out.println("Turning on!"); + Thread.sleep(1000); + } + lb.turnOff(); + } catch(Exception ex) { + ex.printStackTrace(); + } + }*/ +} diff --git a/others/tutorial/iotpolicy/HomeRoom/room.pol b/others/tutorial/iotpolicy/HomeRoom/room.pol new file mode 100644 index 0000000..17f3bbd --- /dev/null +++ b/others/tutorial/iotpolicy/HomeRoom/room.pol @@ -0,0 +1,11 @@ +public interface Room { + + public int getRoomID(); + + capability Basic { + description = "Get room ID"; + method = "getRoomID()"; + } +} + + diff --git a/others/tutorial/iotpolicy/HomeRoom/roomsmart.req b/others/tutorial/iotpolicy/HomeRoom/roomsmart.req new file mode 100644 index 0000000..71de3c9 --- /dev/null +++ b/others/tutorial/iotpolicy/HomeRoom/roomsmart.req @@ -0,0 +1,3 @@ + +requires Room with Basic as interface RoomSmart; + diff --git a/others/tutorial/iotpolicy/SmartLightBulb/smartlightbulb.pol b/others/tutorial/iotpolicy/SmartLightBulb/smartlightbulb.pol new file mode 100644 index 0000000..1aa759e --- /dev/null +++ b/others/tutorial/iotpolicy/SmartLightBulb/smartlightbulb.pol @@ -0,0 +1,62 @@ +public interface LightBulb { + + public void init(); + public void turnOff(); + public void turnOn(); + public boolean getState(); + public void setColor(double _hue, double _saturation, double _brightness); + public void setTemperature(int _temperature); + public double getBrightness(); + public double getHue(); + public double getSaturation(); + public int getTemperature(); + public double getBrightnessRangeLowerBound(); + public double getBrightnessRangeUpperBound(); + public double getHueRangeLowerBound(); + public double getHueRangeUpperBound(); + public double getSaturationRangeLowerBound(); + public double getSaturationRangeUpperBound(); + public int getTemperatureRangeLowerBound(); + public int getTemperatureRangeUpperBound(); + + capability Initialize { + description = "Initialize object"; + method = "init()"; + } + + capability Power { + description = "Turn on/off"; + method = "turnOff()"; + method = "turnOn()"; + method = "getState()"; + } + + capability SetColorProperties { + description = "Get color properties"; + method = "setColor(double _hue, double _saturation, double _brightness)"; + method = "setTemperature(int _temperature)"; + } + + capability GetColorProperties { + description = "Set color properties"; + method = "getBrightness()"; + method = "getHue()"; + method = "getSaturation()"; + method = "getTemperature()"; + } + + capability GetColorPropertiesRange { + description = "Get upper and lower bounds of color properties"; + method = "setColor(double _hue, double _saturation, double _brightness)"; + method = "getBrightnessRangeLowerBound()"; + method = "getBrightnessRangeUpperBound()"; + method = "getHueRangeLowerBound()"; + method = "getHueRangeUpperBound()"; + method = "getSaturationRangeLowerBound()"; + method = "getSaturationRangeUpperBound()"; + method = "getTemperatureRangeLowerBound()"; + method = "getTemperatureRangeUpperBound()"; + } +} + + diff --git a/others/tutorial/iotpolicy/SmartLightBulb/smartlightsbulb.req b/others/tutorial/iotpolicy/SmartLightBulb/smartlightsbulb.req new file mode 100644 index 0000000..f7344b0 --- /dev/null +++ b/others/tutorial/iotpolicy/SmartLightBulb/smartlightsbulb.req @@ -0,0 +1,3 @@ + +requires LightBulb with Initialize, Power, SetColorProperties, GetColorProperties, GetColorPropertiesRange as interface LightBulbTest; + -- 2.34.1