From 896b7490c3e307bb39b8455f82b464f852a5162f Mon Sep 17 00:00:00 2001 From: xuanthanh18 Date: Sat, 22 Aug 2009 08:33:04 +0000 Subject: [PATCH] original files for testing dhv --- apps/tests/TestDhv/DhvInject.java | 71 +++ apps/tests/TestDhv/Makefile | 53 ++ apps/tests/TestDhv/README | 59 +++ apps/tests/TestDhv/TestDhv.h | 8 + apps/tests/TestDhv/TestDhvC-Master.nc | 29 ++ apps/tests/TestDhv/TestDhvC.nc | 284 +++++++++++ apps/tests/TestDhv/TestDhvP-Master.nc | 93 ++++ apps/tests/TestDhv/TestDhvP.nc | 674 ++++++++++++++++++++++++++ apps/tests/TestDhv/TestDipP.nc | 674 ++++++++++++++++++++++++++ apps/tests/TestDhv/gentest.py | 61 +++ 10 files changed, 2006 insertions(+) create mode 100644 apps/tests/TestDhv/DhvInject.java create mode 100644 apps/tests/TestDhv/Makefile create mode 100644 apps/tests/TestDhv/README create mode 100644 apps/tests/TestDhv/TestDhv.h create mode 100644 apps/tests/TestDhv/TestDhvC-Master.nc create mode 100644 apps/tests/TestDhv/TestDhvC.nc create mode 100644 apps/tests/TestDhv/TestDhvP-Master.nc create mode 100644 apps/tests/TestDhv/TestDhvP.nc create mode 100644 apps/tests/TestDhv/TestDipP.nc create mode 100644 apps/tests/TestDhv/gentest.py diff --git a/apps/tests/TestDhv/DhvInject.java b/apps/tests/TestDhv/DhvInject.java new file mode 100644 index 00000000..5867b925 --- /dev/null +++ b/apps/tests/TestDhv/DhvInject.java @@ -0,0 +1,71 @@ + +import java.io.*; +import net.tinyos.message.*; +import net.tinyos.util.*; + +public class DhvInject implements MessageListener +{ + MoteIF mote; + + DhvInject(DhvMsg dhvmsg) { + mote = new MoteIF(PrintStreamMessenger.err); + mote.registerListener(dhvmsg, this); + } + + public synchronized void messageReceived(int dest_addr, Message message) + { + // do nothing for now + } + + void sendDhvDataMsg(int key, long version, short[] data) { + int totalsize = DhvMsg.DEFAULT_MESSAGE_SIZE + + DhvDataMsg.DEFAULT_MESSAGE_SIZE + + DhvData.DEFAULT_MESSAGE_SIZE; + DhvMsg dm = new DhvMsg(totalsize); + dm.set_type((short)3); + + DhvDataMsg ddm = new DhvDataMsg(dm, DhvMsg.DEFAULT_MESSAGE_SIZE); + ddm.set_key(key); + ddm.set_version(version << 16); + ddm.set_size((short)data.length); + + DhvData dd = new DhvData(ddm, DhvDataMsg.DEFAULT_MESSAGE_SIZE); + dd.set_data(data); + + try { + mote.send(MoteIF.TOS_BCAST_ADDR, dd); + } + catch(IOException e) { + System.err.println("Cannot send message"); + } + } + + public static void main(String args[]) { + int i; + + System.out.println("Usage: java DhvInject [key] [version] [hex data delimit space in quotes]"); + int k = Integer.parseInt(args[0], 16); + long v = Long.parseLong(args[1]); + String hexdata[] = args[2].split(" "); + short d[]; + + if(hexdata.length > 16) { + System.err.println("Data too long, keep it <= 16 bytes please"); + } + + d = new short[hexdata.length]; + for(i = 0; i < d.length; i++) + d[i] = Short.parseShort(hexdata[i], 16); + + System.out.println("Key: " + k); + System.out.println("Version: " + v); + System.out.print("Data: "); + for(i = 0; i < d.length; i++) { + System.out.print(d[i] + " "); + } + System.out.println(); + + DhvInject dhvinject = new DhvInject(new DhvMsg()); + dhvinject.sendDhvDataMsg(k, v, d); + } +} diff --git a/apps/tests/TestDhv/Makefile b/apps/tests/TestDhv/Makefile new file mode 100644 index 00000000..7a8241c2 --- /dev/null +++ b/apps/tests/TestDhv/Makefile @@ -0,0 +1,53 @@ +COMPONENT=TestDhvC +BUILD_EXTRA_DEPS = DhvMsg.py DhvDataMsg.py DhvMsg.class DhvDataMsg.class DhvData.class DhvInject.class DhvTestMsg.class +CFLAGS += -I$(TOSDIR)/lib/net +#CFLAGS += -DLOW_POWER_LISTENING +#CFLAGS += -DLPL_DEF_LOCAL_SLEEP=512 +#CFLAGS += -DLPL_DEF_RX_SLEEP=512 +#CFLAGS += -DDELAY_AFTER_RECEIVE=20 +CFLAGS += -I$(TOSDIR)/lib/net/dhv -I$(TOSDIR)/lib/net/dhv/interfaces +#CFLAGS += -I$(TOSDIR)/lib/net/dhv -I$(TOSDIR)/lib/net/dhv/interfaces +#CFLAGS += -I$(TOSDIR)/lib/net/drip + +CONSTANTS += -DTOSH_DATA_LENGTH=32 +CFLAGS += $(CONSTANTS) + +CLEAN_EXTRA += DhvMsg.py DhvDataMsg.py DhvData.py DhvMsg.java DhvDataMsg.java DhvData.java DhvMsg.class DhvDataMsg.class DhvData.class DhvInject.class DhvTestMsg.class DhvTestMsg.java + +DhvMsg.py: + mig python -target=$(PLATFORM) -python-classname=DhvMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_msg -o $@ + +DhvDataMsg.py: + mig python -target=$(PLATFORM) -python-classname=DhvDataMsg -python-extends=DhvMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_data_msg -o $@ + +DhvData.py: + mig python -target=$(PLATFORM) -python-classname=DhvData -python-extends=DhvDataMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_data -o $@ + +DhvTestMsg.class: DhvTestMsg.java + javac DhvTestMsg.java + +DhvMsg.class: DhvMsg.java + javac DhvMsg.java + +DhvDataMsg.class: DhvDataMsg.java + javac DhvDataMsg.java + +DhvData.class: DhvData.java + javac DhvData.java + +DhvTestMsg.java: + mig java -target=null -java-classname=DhvTestMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_test_msg -o $@ + +DhvMsg.java: + mig java -target=null -java-classname=DhvMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_msg -o $@ + +DhvDataMsg.java: + mig java -target=null -java-classname=DhvDataMsg -java-extends=DhvMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_data_msg -o $@ + +DhvData.java: + mig java -target=null -java-classname=DhvData -java-extends=DhvDataMsg $(CFLAGS) $(TOSDIR)/lib/net/dhv/Dhv.h dhv_data -o $@ + +DhvInject.class: + javac DhvInject.java + +include $(MAKERULES) diff --git a/apps/tests/TestDhv/README b/apps/tests/TestDhv/README new file mode 100644 index 00000000..a1542d8c --- /dev/null +++ b/apps/tests/TestDhv/README @@ -0,0 +1,59 @@ + +Title: TestDhv Application +Author: Thanh Dang, Sweungweon Park +adopted from TestDip + +1. SETTING UP THE TEST + +You need to first generate the code for compilation. The gentest.py +script reads in the Master files and creates TestDhvC.nc (the +configuration) and TestDhvP.nc (the module). It takes two parameters, +the total number of items and the number of new items. The items that +are random are chosen randomly. + +If you want 128 total items in the dissemination set, where 96 of +those 128 items are new, you would type: + +python gentest.py 128 96 + +After the configuration and module have been generated, you can use +the normal compilation method (e.g. make telosb). + +2, READING THE LEDS + +When an node receives a new item, it toggles LED0. When a node +completes all items, it turns all LEDs on. + +3. SERIAL MESSAGES + +typedef nx_struct dhv_test_msg_t { + nx_am_addr_t id; + nx_uint8_t count; + nx_uint8_t isOk; +} dhv_test_msg_t; + +When a node receives a new item, it sends a dhv_test_msg_t through the +serial interface. + +id is the node id +count is how many new items it has received so far +isOk will be true if the data value was as expected + +4. PACKET INJECTOR + +You can also use the injector to send data packets via a +basestation. The syntax to do that is: + +java DhvInject [key] [version] [data in quotes delimited by space] + +key is the data key in hexadecimal +version is the version number in decimal +data is the actual data in quotes delimited by space + +For example, if you want to send key 10, version 2, and data "ab cd +ef". You would type: + +java DipInject 0a 2 "ab cd ef" + +For this specific test application, your data needs to be "ef be". You +will need a SerialForwarder running for this work. diff --git a/apps/tests/TestDhv/TestDhv.h b/apps/tests/TestDhv/TestDhv.h new file mode 100644 index 00000000..05535879 --- /dev/null +++ b/apps/tests/TestDhv/TestDhv.h @@ -0,0 +1,8 @@ +#ifndef __TESTDHV_H__ +#define __TESTDHV_H__ + +/*enum { + AM_DHV_TEST_MSG = 0xAB +};*/ + +#endif diff --git a/apps/tests/TestDhv/TestDhvC-Master.nc b/apps/tests/TestDhv/TestDhvC-Master.nc new file mode 100644 index 00000000..94cf293a --- /dev/null +++ b/apps/tests/TestDhv/TestDhvC-Master.nc @@ -0,0 +1,29 @@ +#include "TestDhv.h" + +configuration TestDhvC { + +} + +implementation { + components TestDhvP; + components LedsC as LedsC; + TestDhvP.Leds -> LedsC; + + components DisseminationC; + TestDhvP.StdControl -> DisseminationC; + /* + components new DisseminatorC(uint32_t, 0x1) as Dissem1; + TestDhvP.DisseminationValue1 -> Dissem1; + TestDhvP.DisseminationUpdate1 -> Dissem1; + */ + + // ... DISSEMINATORS + + components MainC; + TestDhvP.Boot -> MainC; + + components SerialActiveMessageC; + components new SerialAMSenderC(AM_DHV_TEST_MSG); + TestDhvP.SerialSend -> SerialAMSenderC; + TestDhvP.SerialControl -> SerialActiveMessageC; +} diff --git a/apps/tests/TestDhv/TestDhvC.nc b/apps/tests/TestDhv/TestDhvC.nc new file mode 100644 index 00000000..44ee2bc3 --- /dev/null +++ b/apps/tests/TestDhv/TestDhvC.nc @@ -0,0 +1,284 @@ +#include "TestDhv.h" + +configuration TestDhvC { + +} + +implementation { + components TestDhvP; + components LedsC as LedsC; + TestDhvP.Leds -> LedsC; + + components DisseminationC; + TestDhvP.StdControl -> DisseminationC; + /* + components new DisseminatorC(uint32_t, 0x1) as Dissem1; + TestDhvP.DisseminationValue1 -> Dissem1; + TestDhvP.DisseminationUpdate1 -> Dissem1; + */ + + components new DisseminatorC(uint16_t, 1) as Dissem1; + TestDhvP.DisseminationUpdate1 -> Dissem1; + TestDhvP.DisseminationValue1 -> Dissem1; + + components new DisseminatorC(uint16_t, 2) as Dissem2; + TestDhvP.DisseminationUpdate2 -> Dissem2; + TestDhvP.DisseminationValue2 -> Dissem2; + + components new DisseminatorC(uint16_t, 3) as Dissem3; + TestDhvP.DisseminationUpdate3 -> Dissem3; + TestDhvP.DisseminationValue3 -> Dissem3; + + components new DisseminatorC(uint16_t, 4) as Dissem4; + TestDhvP.DisseminationUpdate4 -> Dissem4; + TestDhvP.DisseminationValue4 -> Dissem4; + + components new DisseminatorC(uint16_t, 5) as Dissem5; + TestDhvP.DisseminationUpdate5 -> Dissem5; + TestDhvP.DisseminationValue5 -> Dissem5; + + components new DisseminatorC(uint16_t, 6) as Dissem6; + TestDhvP.DisseminationUpdate6 -> Dissem6; + TestDhvP.DisseminationValue6 -> Dissem6; + + components new DisseminatorC(uint16_t, 7) as Dissem7; + TestDhvP.DisseminationUpdate7 -> Dissem7; + TestDhvP.DisseminationValue7 -> Dissem7; + + components new DisseminatorC(uint16_t, 8) as Dissem8; + TestDhvP.DisseminationUpdate8 -> Dissem8; + TestDhvP.DisseminationValue8 -> Dissem8; + + components new DisseminatorC(uint16_t, 9) as Dissem9; + TestDhvP.DisseminationUpdate9 -> Dissem9; + TestDhvP.DisseminationValue9 -> Dissem9; + + components new DisseminatorC(uint16_t, 10) as Dissem10; + TestDhvP.DisseminationUpdate10 -> Dissem10; + TestDhvP.DisseminationValue10 -> Dissem10; + + components new DisseminatorC(uint16_t, 11) as Dissem11; + TestDhvP.DisseminationUpdate11 -> Dissem11; + TestDhvP.DisseminationValue11 -> Dissem11; + + components new DisseminatorC(uint16_t, 12) as Dissem12; + TestDhvP.DisseminationUpdate12 -> Dissem12; + TestDhvP.DisseminationValue12 -> Dissem12; + + components new DisseminatorC(uint16_t, 13) as Dissem13; + TestDhvP.DisseminationUpdate13 -> Dissem13; + TestDhvP.DisseminationValue13 -> Dissem13; + + components new DisseminatorC(uint16_t, 14) as Dissem14; + TestDhvP.DisseminationUpdate14 -> Dissem14; + TestDhvP.DisseminationValue14 -> Dissem14; + + components new DisseminatorC(uint16_t, 15) as Dissem15; + TestDhvP.DisseminationUpdate15 -> Dissem15; + TestDhvP.DisseminationValue15 -> Dissem15; + + components new DisseminatorC(uint16_t, 16) as Dissem16; + TestDhvP.DisseminationUpdate16 -> Dissem16; + TestDhvP.DisseminationValue16 -> Dissem16; + + components new DisseminatorC(uint16_t, 17) as Dissem17; + TestDhvP.DisseminationUpdate17 -> Dissem17; + TestDhvP.DisseminationValue17 -> Dissem17; + + components new DisseminatorC(uint16_t, 18) as Dissem18; + TestDhvP.DisseminationUpdate18 -> Dissem18; + TestDhvP.DisseminationValue18 -> Dissem18; + + components new DisseminatorC(uint16_t, 19) as Dissem19; + TestDhvP.DisseminationUpdate19 -> Dissem19; + TestDhvP.DisseminationValue19 -> Dissem19; + + components new DisseminatorC(uint16_t, 20) as Dissem20; + TestDhvP.DisseminationUpdate20 -> Dissem20; + TestDhvP.DisseminationValue20 -> Dissem20; + + components new DisseminatorC(uint16_t, 21) as Dissem21; + TestDhvP.DisseminationUpdate21 -> Dissem21; + TestDhvP.DisseminationValue21 -> Dissem21; + + components new DisseminatorC(uint16_t, 22) as Dissem22; + TestDhvP.DisseminationUpdate22 -> Dissem22; + TestDhvP.DisseminationValue22 -> Dissem22; + + components new DisseminatorC(uint16_t, 23) as Dissem23; + TestDhvP.DisseminationUpdate23 -> Dissem23; + TestDhvP.DisseminationValue23 -> Dissem23; + + components new DisseminatorC(uint16_t, 24) as Dissem24; + TestDhvP.DisseminationUpdate24 -> Dissem24; + TestDhvP.DisseminationValue24 -> Dissem24; + + components new DisseminatorC(uint16_t, 25) as Dissem25; + TestDhvP.DisseminationUpdate25 -> Dissem25; + TestDhvP.DisseminationValue25 -> Dissem25; + + components new DisseminatorC(uint16_t, 26) as Dissem26; + TestDhvP.DisseminationUpdate26 -> Dissem26; + TestDhvP.DisseminationValue26 -> Dissem26; + + components new DisseminatorC(uint16_t, 27) as Dissem27; + TestDhvP.DisseminationUpdate27 -> Dissem27; + TestDhvP.DisseminationValue27 -> Dissem27; + + components new DisseminatorC(uint16_t, 28) as Dissem28; + TestDhvP.DisseminationUpdate28 -> Dissem28; + TestDhvP.DisseminationValue28 -> Dissem28; + + components new DisseminatorC(uint16_t, 29) as Dissem29; + TestDhvP.DisseminationUpdate29 -> Dissem29; + TestDhvP.DisseminationValue29 -> Dissem29; + + components new DisseminatorC(uint16_t, 30) as Dissem30; + TestDhvP.DisseminationUpdate30 -> Dissem30; + TestDhvP.DisseminationValue30 -> Dissem30; + + components new DisseminatorC(uint16_t, 31) as Dissem31; + TestDhvP.DisseminationUpdate31 -> Dissem31; + TestDhvP.DisseminationValue31 -> Dissem31; + + components new DisseminatorC(uint16_t, 32) as Dissem32; + TestDhvP.DisseminationUpdate32 -> Dissem32; + TestDhvP.DisseminationValue32 -> Dissem32; + + components new DisseminatorC(uint16_t, 33) as Dissem33; + TestDhvP.DisseminationUpdate33 -> Dissem33; + TestDhvP.DisseminationValue33 -> Dissem33; + + components new DisseminatorC(uint16_t, 34) as Dissem34; + TestDhvP.DisseminationUpdate34 -> Dissem34; + TestDhvP.DisseminationValue34 -> Dissem34; + + components new DisseminatorC(uint16_t, 35) as Dissem35; + TestDhvP.DisseminationUpdate35 -> Dissem35; + TestDhvP.DisseminationValue35 -> Dissem35; + + components new DisseminatorC(uint16_t, 36) as Dissem36; + TestDhvP.DisseminationUpdate36 -> Dissem36; + TestDhvP.DisseminationValue36 -> Dissem36; + + components new DisseminatorC(uint16_t, 37) as Dissem37; + TestDhvP.DisseminationUpdate37 -> Dissem37; + TestDhvP.DisseminationValue37 -> Dissem37; + + components new DisseminatorC(uint16_t, 38) as Dissem38; + TestDhvP.DisseminationUpdate38 -> Dissem38; + TestDhvP.DisseminationValue38 -> Dissem38; + + components new DisseminatorC(uint16_t, 39) as Dissem39; + TestDhvP.DisseminationUpdate39 -> Dissem39; + TestDhvP.DisseminationValue39 -> Dissem39; + + components new DisseminatorC(uint16_t, 40) as Dissem40; + TestDhvP.DisseminationUpdate40 -> Dissem40; + TestDhvP.DisseminationValue40 -> Dissem40; + + components new DisseminatorC(uint16_t, 41) as Dissem41; + TestDhvP.DisseminationUpdate41 -> Dissem41; + TestDhvP.DisseminationValue41 -> Dissem41; + + components new DisseminatorC(uint16_t, 42) as Dissem42; + TestDhvP.DisseminationUpdate42 -> Dissem42; + TestDhvP.DisseminationValue42 -> Dissem42; + + components new DisseminatorC(uint16_t, 43) as Dissem43; + TestDhvP.DisseminationUpdate43 -> Dissem43; + TestDhvP.DisseminationValue43 -> Dissem43; + + components new DisseminatorC(uint16_t, 44) as Dissem44; + TestDhvP.DisseminationUpdate44 -> Dissem44; + TestDhvP.DisseminationValue44 -> Dissem44; + + components new DisseminatorC(uint16_t, 45) as Dissem45; + TestDhvP.DisseminationUpdate45 -> Dissem45; + TestDhvP.DisseminationValue45 -> Dissem45; + + components new DisseminatorC(uint16_t, 46) as Dissem46; + TestDhvP.DisseminationUpdate46 -> Dissem46; + TestDhvP.DisseminationValue46 -> Dissem46; + + components new DisseminatorC(uint16_t, 47) as Dissem47; + TestDhvP.DisseminationUpdate47 -> Dissem47; + TestDhvP.DisseminationValue47 -> Dissem47; + + components new DisseminatorC(uint16_t, 48) as Dissem48; + TestDhvP.DisseminationUpdate48 -> Dissem48; + TestDhvP.DisseminationValue48 -> Dissem48; + + components new DisseminatorC(uint16_t, 49) as Dissem49; + TestDhvP.DisseminationUpdate49 -> Dissem49; + TestDhvP.DisseminationValue49 -> Dissem49; + + components new DisseminatorC(uint16_t, 50) as Dissem50; + TestDhvP.DisseminationUpdate50 -> Dissem50; + TestDhvP.DisseminationValue50 -> Dissem50; + + components new DisseminatorC(uint16_t, 51) as Dissem51; + TestDhvP.DisseminationUpdate51 -> Dissem51; + TestDhvP.DisseminationValue51 -> Dissem51; + + components new DisseminatorC(uint16_t, 52) as Dissem52; + TestDhvP.DisseminationUpdate52 -> Dissem52; + TestDhvP.DisseminationValue52 -> Dissem52; + + components new DisseminatorC(uint16_t, 53) as Dissem53; + TestDhvP.DisseminationUpdate53 -> Dissem53; + TestDhvP.DisseminationValue53 -> Dissem53; + + components new DisseminatorC(uint16_t, 54) as Dissem54; + TestDhvP.DisseminationUpdate54 -> Dissem54; + TestDhvP.DisseminationValue54 -> Dissem54; + + components new DisseminatorC(uint16_t, 55) as Dissem55; + TestDhvP.DisseminationUpdate55 -> Dissem55; + TestDhvP.DisseminationValue55 -> Dissem55; + + components new DisseminatorC(uint16_t, 56) as Dissem56; + TestDhvP.DisseminationUpdate56 -> Dissem56; + TestDhvP.DisseminationValue56 -> Dissem56; + + components new DisseminatorC(uint16_t, 57) as Dissem57; + TestDhvP.DisseminationUpdate57 -> Dissem57; + TestDhvP.DisseminationValue57 -> Dissem57; + + components new DisseminatorC(uint16_t, 58) as Dissem58; + TestDhvP.DisseminationUpdate58 -> Dissem58; + TestDhvP.DisseminationValue58 -> Dissem58; + + components new DisseminatorC(uint16_t, 59) as Dissem59; + TestDhvP.DisseminationUpdate59 -> Dissem59; + TestDhvP.DisseminationValue59 -> Dissem59; + + components new DisseminatorC(uint16_t, 60) as Dissem60; + TestDhvP.DisseminationUpdate60 -> Dissem60; + TestDhvP.DisseminationValue60 -> Dissem60; + + components new DisseminatorC(uint16_t, 61) as Dissem61; + TestDhvP.DisseminationUpdate61 -> Dissem61; + TestDhvP.DisseminationValue61 -> Dissem61; + + components new DisseminatorC(uint16_t, 62) as Dissem62; + TestDhvP.DisseminationUpdate62 -> Dissem62; + TestDhvP.DisseminationValue62 -> Dissem62; + + components new DisseminatorC(uint16_t, 63) as Dissem63; + TestDhvP.DisseminationUpdate63 -> Dissem63; + TestDhvP.DisseminationValue63 -> Dissem63; + + components new DisseminatorC(uint16_t, 64) as Dissem64; + TestDhvP.DisseminationUpdate64 -> Dissem64; + TestDhvP.DisseminationValue64 -> Dissem64; + + + components MainC; + TestDhvP.Boot -> MainC; + + components SerialActiveMessageC; + components new SerialAMSenderC(AM_DHV_TEST_MSG); + TestDhvP.SerialSend -> SerialAMSenderC; + TestDhvP.SerialControl -> SerialActiveMessageC; +} diff --git a/apps/tests/TestDhv/TestDhvP-Master.nc b/apps/tests/TestDhv/TestDhvP-Master.nc new file mode 100644 index 00000000..d4cbdb26 --- /dev/null +++ b/apps/tests/TestDhv/TestDhvP-Master.nc @@ -0,0 +1,93 @@ + +module TestDhvP { + uses interface Leds; + uses interface StdControl; + + /* + uses interface DisseminationUpdate as DisseminationUpdate1; + uses interface DisseminationValue as DisseminationValue1; + */ + + // ... INTERFACES + + uses interface Boot; + uses interface AMSend as SerialSend; + uses interface SplitControl as SerialControl; +} + +implementation { + typedef nx_struct dhv_test_msg_t { + nx_am_addr_t id; + nx_uint8_t count; + nx_uint8_t isOk; + } dhv_test_msg_t; + + message_t testMsg; + + uint8_t okBit = 1; + uint16_t data; + uint8_t count = 0; + /* + uint8_t newCount = N; + */ + // ... NEWCOUNT + + void bookkeep(); + + event void SerialControl.startDone(error_t err) { + call StdControl.start(); + if(TOS_NODE_ID == 1) { + data = 0xBEEF; + dbg("TestDhvP","Updating data items\n"); + /* + call DisseminationUpdate1.change(&data); + */ + // ... CHANGES + } + } + + event void SerialControl.stopDone(error_t err) { + + } + + event void Boot.booted() { + call SerialControl.start(); + dbg("TestDhvP", "Booted at %s\n", sim_time_string()); + } + /* + event void DisseminationValue1.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue1.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + */ + + // ... EVENTS + + void bookkeep() { + dhv_test_msg_t* dhvTestMsgPtr; + + if(count < newCount) { + count++; + } + dbg("TestDhvP", "Got an update, %u complete now at %s\n", count, sim_time_string()); + call Leds.led0Toggle(); + + dhvTestMsgPtr = (dhv_test_msg_t*) call SerialSend.getPayload(&testMsg, 0); + dhvTestMsgPtr->id = TOS_NODE_ID; + dhvTestMsgPtr->count = count; + dhvTestMsgPtr->isOk = okBit; + call SerialSend.send(0, &testMsg, sizeof(dhv_test_msg_t)); + + + if(newCount == count) { + dbg("TestDhvP","Dissemination COMPLETE!\n"); + call Leds.set(7); + } + + } + + event void SerialSend.sendDone(message_t* message, error_t err) { + + } +} diff --git a/apps/tests/TestDhv/TestDhvP.nc b/apps/tests/TestDhv/TestDhvP.nc new file mode 100644 index 00000000..5c75d2f9 --- /dev/null +++ b/apps/tests/TestDhv/TestDhvP.nc @@ -0,0 +1,674 @@ + +module TestDhvP { + uses interface Leds; + uses interface StdControl; + + /* + uses interface DisseminationUpdate as DisseminationUpdate1; + uses interface DisseminationValue as DisseminationValue1; + */ + + uses interface DisseminationUpdate as DisseminationUpdate1; + uses interface DisseminationValue as DisseminationValue1; + + uses interface DisseminationUpdate as DisseminationUpdate2; + uses interface DisseminationValue as DisseminationValue2; + + uses interface DisseminationUpdate as DisseminationUpdate3; + uses interface DisseminationValue as DisseminationValue3; + + uses interface DisseminationUpdate as DisseminationUpdate4; + uses interface DisseminationValue as DisseminationValue4; + + uses interface DisseminationUpdate as DisseminationUpdate5; + uses interface DisseminationValue as DisseminationValue5; + + uses interface DisseminationUpdate as DisseminationUpdate6; + uses interface DisseminationValue as DisseminationValue6; + + uses interface DisseminationUpdate as DisseminationUpdate7; + uses interface DisseminationValue as DisseminationValue7; + + uses interface DisseminationUpdate as DisseminationUpdate8; + uses interface DisseminationValue as DisseminationValue8; + + uses interface DisseminationUpdate as DisseminationUpdate9; + uses interface DisseminationValue as DisseminationValue9; + + uses interface DisseminationUpdate as DisseminationUpdate10; + uses interface DisseminationValue as DisseminationValue10; + + uses interface DisseminationUpdate as DisseminationUpdate11; + uses interface DisseminationValue as DisseminationValue11; + + uses interface DisseminationUpdate as DisseminationUpdate12; + uses interface DisseminationValue as DisseminationValue12; + + uses interface DisseminationUpdate as DisseminationUpdate13; + uses interface DisseminationValue as DisseminationValue13; + + uses interface DisseminationUpdate as DisseminationUpdate14; + uses interface DisseminationValue as DisseminationValue14; + + uses interface DisseminationUpdate as DisseminationUpdate15; + uses interface DisseminationValue as DisseminationValue15; + + uses interface DisseminationUpdate as DisseminationUpdate16; + uses interface DisseminationValue as DisseminationValue16; + + uses interface DisseminationUpdate as DisseminationUpdate17; + uses interface DisseminationValue as DisseminationValue17; + + uses interface DisseminationUpdate as DisseminationUpdate18; + uses interface DisseminationValue as DisseminationValue18; + + uses interface DisseminationUpdate as DisseminationUpdate19; + uses interface DisseminationValue as DisseminationValue19; + + uses interface DisseminationUpdate as DisseminationUpdate20; + uses interface DisseminationValue as DisseminationValue20; + + uses interface DisseminationUpdate as DisseminationUpdate21; + uses interface DisseminationValue as DisseminationValue21; + + uses interface DisseminationUpdate as DisseminationUpdate22; + uses interface DisseminationValue as DisseminationValue22; + + uses interface DisseminationUpdate as DisseminationUpdate23; + uses interface DisseminationValue as DisseminationValue23; + + uses interface DisseminationUpdate as DisseminationUpdate24; + uses interface DisseminationValue as DisseminationValue24; + + uses interface DisseminationUpdate as DisseminationUpdate25; + uses interface DisseminationValue as DisseminationValue25; + + uses interface DisseminationUpdate as DisseminationUpdate26; + uses interface DisseminationValue as DisseminationValue26; + + uses interface DisseminationUpdate as DisseminationUpdate27; + uses interface DisseminationValue as DisseminationValue27; + + uses interface DisseminationUpdate as DisseminationUpdate28; + uses interface DisseminationValue as DisseminationValue28; + + uses interface DisseminationUpdate as DisseminationUpdate29; + uses interface DisseminationValue as DisseminationValue29; + + uses interface DisseminationUpdate as DisseminationUpdate30; + uses interface DisseminationValue as DisseminationValue30; + + uses interface DisseminationUpdate as DisseminationUpdate31; + uses interface DisseminationValue as DisseminationValue31; + + uses interface DisseminationUpdate as DisseminationUpdate32; + uses interface DisseminationValue as DisseminationValue32; + + uses interface DisseminationUpdate as DisseminationUpdate33; + uses interface DisseminationValue as DisseminationValue33; + + uses interface DisseminationUpdate as DisseminationUpdate34; + uses interface DisseminationValue as DisseminationValue34; + + uses interface DisseminationUpdate as DisseminationUpdate35; + uses interface DisseminationValue as DisseminationValue35; + + uses interface DisseminationUpdate as DisseminationUpdate36; + uses interface DisseminationValue as DisseminationValue36; + + uses interface DisseminationUpdate as DisseminationUpdate37; + uses interface DisseminationValue as DisseminationValue37; + + uses interface DisseminationUpdate as DisseminationUpdate38; + uses interface DisseminationValue as DisseminationValue38; + + uses interface DisseminationUpdate as DisseminationUpdate39; + uses interface DisseminationValue as DisseminationValue39; + + uses interface DisseminationUpdate as DisseminationUpdate40; + uses interface DisseminationValue as DisseminationValue40; + + uses interface DisseminationUpdate as DisseminationUpdate41; + uses interface DisseminationValue as DisseminationValue41; + + uses interface DisseminationUpdate as DisseminationUpdate42; + uses interface DisseminationValue as DisseminationValue42; + + uses interface DisseminationUpdate as DisseminationUpdate43; + uses interface DisseminationValue as DisseminationValue43; + + uses interface DisseminationUpdate as DisseminationUpdate44; + uses interface DisseminationValue as DisseminationValue44; + + uses interface DisseminationUpdate as DisseminationUpdate45; + uses interface DisseminationValue as DisseminationValue45; + + uses interface DisseminationUpdate as DisseminationUpdate46; + uses interface DisseminationValue as DisseminationValue46; + + uses interface DisseminationUpdate as DisseminationUpdate47; + uses interface DisseminationValue as DisseminationValue47; + + uses interface DisseminationUpdate as DisseminationUpdate48; + uses interface DisseminationValue as DisseminationValue48; + + uses interface DisseminationUpdate as DisseminationUpdate49; + uses interface DisseminationValue as DisseminationValue49; + + uses interface DisseminationUpdate as DisseminationUpdate50; + uses interface DisseminationValue as DisseminationValue50; + + uses interface DisseminationUpdate as DisseminationUpdate51; + uses interface DisseminationValue as DisseminationValue51; + + uses interface DisseminationUpdate as DisseminationUpdate52; + uses interface DisseminationValue as DisseminationValue52; + + uses interface DisseminationUpdate as DisseminationUpdate53; + uses interface DisseminationValue as DisseminationValue53; + + uses interface DisseminationUpdate as DisseminationUpdate54; + uses interface DisseminationValue as DisseminationValue54; + + uses interface DisseminationUpdate as DisseminationUpdate55; + uses interface DisseminationValue as DisseminationValue55; + + uses interface DisseminationUpdate as DisseminationUpdate56; + uses interface DisseminationValue as DisseminationValue56; + + uses interface DisseminationUpdate as DisseminationUpdate57; + uses interface DisseminationValue as DisseminationValue57; + + uses interface DisseminationUpdate as DisseminationUpdate58; + uses interface DisseminationValue as DisseminationValue58; + + uses interface DisseminationUpdate as DisseminationUpdate59; + uses interface DisseminationValue as DisseminationValue59; + + uses interface DisseminationUpdate as DisseminationUpdate60; + uses interface DisseminationValue as DisseminationValue60; + + uses interface DisseminationUpdate as DisseminationUpdate61; + uses interface DisseminationValue as DisseminationValue61; + + uses interface DisseminationUpdate as DisseminationUpdate62; + uses interface DisseminationValue as DisseminationValue62; + + uses interface DisseminationUpdate as DisseminationUpdate63; + uses interface DisseminationValue as DisseminationValue63; + + uses interface DisseminationUpdate as DisseminationUpdate64; + uses interface DisseminationValue as DisseminationValue64; + + + uses interface Boot; + uses interface AMSend as SerialSend; + uses interface SplitControl as SerialControl; +} + +implementation { + typedef nx_struct dhv_test_msg_t { + nx_am_addr_t id; + nx_uint8_t count; + nx_uint8_t isOk; + } dhv_test_msg_t; + + message_t testMsg; + + uint8_t okBit = 1; + uint16_t data; + uint8_t count = 0; + /* + uint8_t newCount = N; + */ + uint8_t newCount = 8; + + void bookkeep(); + + event void SerialControl.startDone(error_t err) { + call StdControl.start(); + if(TOS_NODE_ID == 1) { + data = 0xBEEF; + dbg("TestDhvP","Updating data items\n"); + /* + call DisseminationUpdate1.change(&data); + */ + call DisseminationUpdate18.change(&data); + call DisseminationUpdate61.change(&data); + call DisseminationUpdate21.change(&data); + call DisseminationUpdate53.change(&data); + call DisseminationUpdate17.change(&data); + call DisseminationUpdate19.change(&data); + call DisseminationUpdate11.change(&data); + call DisseminationUpdate36.change(&data); + } + } + + event void SerialControl.stopDone(error_t err) { + + } + + event void Boot.booted() { + call SerialControl.start(); + dbg("TestDhvP", "Booted at %s\n", sim_time_string()); + } + /* + event void DisseminationValue1.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue1.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + */ + + event void DisseminationValue1.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue1.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue2.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue2.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue3.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue3.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue4.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue4.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue5.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue5.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue6.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue6.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue7.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue7.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue8.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue8.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue9.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue9.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue10.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue10.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue11.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue11.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue12.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue12.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue13.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue13.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue14.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue14.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue15.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue15.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue16.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue16.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue17.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue17.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue18.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue18.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue19.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue19.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue20.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue20.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue21.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue21.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue22.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue22.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue23.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue23.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue24.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue24.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue25.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue25.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue26.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue26.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue27.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue27.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue28.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue28.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue29.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue29.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue30.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue30.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue31.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue31.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue32.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue32.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue33.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue33.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue34.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue34.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue35.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue35.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue36.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue36.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue37.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue37.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue38.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue38.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue39.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue39.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue40.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue40.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue41.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue41.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue42.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue42.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue43.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue43.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue44.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue44.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue45.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue45.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue46.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue46.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue47.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue47.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue48.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue48.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue49.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue49.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue50.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue50.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue51.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue51.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue52.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue52.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue53.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue53.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue54.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue54.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue55.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue55.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue56.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue56.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue57.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue57.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue58.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue58.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue59.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue59.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue60.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue60.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue61.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue61.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue62.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue62.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue63.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue63.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue64.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue64.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + + void bookkeep() { + dhv_test_msg_t* dhvTestMsgPtr; + + if(count < newCount) { + count++; + } + dbg("TestDhvP", "Got an update, %u complete now at %s\n", count, sim_time_string()); + call Leds.led0Toggle(); + + dhvTestMsgPtr = (dhv_test_msg_t*) call SerialSend.getPayload(&testMsg, 0); + dhvTestMsgPtr->id = TOS_NODE_ID; + dhvTestMsgPtr->count = count; + dhvTestMsgPtr->isOk = okBit; + call SerialSend.send(0, &testMsg, sizeof(dhv_test_msg_t)); + + + if(newCount == count) { + dbg("TestDhvP","Dissemination COMPLETE!\n"); + call Leds.set(7); + } + + } + + event void SerialSend.sendDone(message_t* message, error_t err) { + + } +} diff --git a/apps/tests/TestDhv/TestDipP.nc b/apps/tests/TestDhv/TestDipP.nc new file mode 100644 index 00000000..f26d6520 --- /dev/null +++ b/apps/tests/TestDhv/TestDipP.nc @@ -0,0 +1,674 @@ + +module TestDipP { + uses interface Leds; + uses interface StdControl; + + /* + uses interface DisseminationUpdate as DisseminationUpdate1; + uses interface DisseminationValue as DisseminationValue1; + */ + + uses interface DisseminationUpdate as DisseminationUpdate1; + uses interface DisseminationValue as DisseminationValue1; + + uses interface DisseminationUpdate as DisseminationUpdate2; + uses interface DisseminationValue as DisseminationValue2; + + uses interface DisseminationUpdate as DisseminationUpdate3; + uses interface DisseminationValue as DisseminationValue3; + + uses interface DisseminationUpdate as DisseminationUpdate4; + uses interface DisseminationValue as DisseminationValue4; + + uses interface DisseminationUpdate as DisseminationUpdate5; + uses interface DisseminationValue as DisseminationValue5; + + uses interface DisseminationUpdate as DisseminationUpdate6; + uses interface DisseminationValue as DisseminationValue6; + + uses interface DisseminationUpdate as DisseminationUpdate7; + uses interface DisseminationValue as DisseminationValue7; + + uses interface DisseminationUpdate as DisseminationUpdate8; + uses interface DisseminationValue as DisseminationValue8; + + uses interface DisseminationUpdate as DisseminationUpdate9; + uses interface DisseminationValue as DisseminationValue9; + + uses interface DisseminationUpdate as DisseminationUpdate10; + uses interface DisseminationValue as DisseminationValue10; + + uses interface DisseminationUpdate as DisseminationUpdate11; + uses interface DisseminationValue as DisseminationValue11; + + uses interface DisseminationUpdate as DisseminationUpdate12; + uses interface DisseminationValue as DisseminationValue12; + + uses interface DisseminationUpdate as DisseminationUpdate13; + uses interface DisseminationValue as DisseminationValue13; + + uses interface DisseminationUpdate as DisseminationUpdate14; + uses interface DisseminationValue as DisseminationValue14; + + uses interface DisseminationUpdate as DisseminationUpdate15; + uses interface DisseminationValue as DisseminationValue15; + + uses interface DisseminationUpdate as DisseminationUpdate16; + uses interface DisseminationValue as DisseminationValue16; + + uses interface DisseminationUpdate as DisseminationUpdate17; + uses interface DisseminationValue as DisseminationValue17; + + uses interface DisseminationUpdate as DisseminationUpdate18; + uses interface DisseminationValue as DisseminationValue18; + + uses interface DisseminationUpdate as DisseminationUpdate19; + uses interface DisseminationValue as DisseminationValue19; + + uses interface DisseminationUpdate as DisseminationUpdate20; + uses interface DisseminationValue as DisseminationValue20; + + uses interface DisseminationUpdate as DisseminationUpdate21; + uses interface DisseminationValue as DisseminationValue21; + + uses interface DisseminationUpdate as DisseminationUpdate22; + uses interface DisseminationValue as DisseminationValue22; + + uses interface DisseminationUpdate as DisseminationUpdate23; + uses interface DisseminationValue as DisseminationValue23; + + uses interface DisseminationUpdate as DisseminationUpdate24; + uses interface DisseminationValue as DisseminationValue24; + + uses interface DisseminationUpdate as DisseminationUpdate25; + uses interface DisseminationValue as DisseminationValue25; + + uses interface DisseminationUpdate as DisseminationUpdate26; + uses interface DisseminationValue as DisseminationValue26; + + uses interface DisseminationUpdate as DisseminationUpdate27; + uses interface DisseminationValue as DisseminationValue27; + + uses interface DisseminationUpdate as DisseminationUpdate28; + uses interface DisseminationValue as DisseminationValue28; + + uses interface DisseminationUpdate as DisseminationUpdate29; + uses interface DisseminationValue as DisseminationValue29; + + uses interface DisseminationUpdate as DisseminationUpdate30; + uses interface DisseminationValue as DisseminationValue30; + + uses interface DisseminationUpdate as DisseminationUpdate31; + uses interface DisseminationValue as DisseminationValue31; + + uses interface DisseminationUpdate as DisseminationUpdate32; + uses interface DisseminationValue as DisseminationValue32; + + uses interface DisseminationUpdate as DisseminationUpdate33; + uses interface DisseminationValue as DisseminationValue33; + + uses interface DisseminationUpdate as DisseminationUpdate34; + uses interface DisseminationValue as DisseminationValue34; + + uses interface DisseminationUpdate as DisseminationUpdate35; + uses interface DisseminationValue as DisseminationValue35; + + uses interface DisseminationUpdate as DisseminationUpdate36; + uses interface DisseminationValue as DisseminationValue36; + + uses interface DisseminationUpdate as DisseminationUpdate37; + uses interface DisseminationValue as DisseminationValue37; + + uses interface DisseminationUpdate as DisseminationUpdate38; + uses interface DisseminationValue as DisseminationValue38; + + uses interface DisseminationUpdate as DisseminationUpdate39; + uses interface DisseminationValue as DisseminationValue39; + + uses interface DisseminationUpdate as DisseminationUpdate40; + uses interface DisseminationValue as DisseminationValue40; + + uses interface DisseminationUpdate as DisseminationUpdate41; + uses interface DisseminationValue as DisseminationValue41; + + uses interface DisseminationUpdate as DisseminationUpdate42; + uses interface DisseminationValue as DisseminationValue42; + + uses interface DisseminationUpdate as DisseminationUpdate43; + uses interface DisseminationValue as DisseminationValue43; + + uses interface DisseminationUpdate as DisseminationUpdate44; + uses interface DisseminationValue as DisseminationValue44; + + uses interface DisseminationUpdate as DisseminationUpdate45; + uses interface DisseminationValue as DisseminationValue45; + + uses interface DisseminationUpdate as DisseminationUpdate46; + uses interface DisseminationValue as DisseminationValue46; + + uses interface DisseminationUpdate as DisseminationUpdate47; + uses interface DisseminationValue as DisseminationValue47; + + uses interface DisseminationUpdate as DisseminationUpdate48; + uses interface DisseminationValue as DisseminationValue48; + + uses interface DisseminationUpdate as DisseminationUpdate49; + uses interface DisseminationValue as DisseminationValue49; + + uses interface DisseminationUpdate as DisseminationUpdate50; + uses interface DisseminationValue as DisseminationValue50; + + uses interface DisseminationUpdate as DisseminationUpdate51; + uses interface DisseminationValue as DisseminationValue51; + + uses interface DisseminationUpdate as DisseminationUpdate52; + uses interface DisseminationValue as DisseminationValue52; + + uses interface DisseminationUpdate as DisseminationUpdate53; + uses interface DisseminationValue as DisseminationValue53; + + uses interface DisseminationUpdate as DisseminationUpdate54; + uses interface DisseminationValue as DisseminationValue54; + + uses interface DisseminationUpdate as DisseminationUpdate55; + uses interface DisseminationValue as DisseminationValue55; + + uses interface DisseminationUpdate as DisseminationUpdate56; + uses interface DisseminationValue as DisseminationValue56; + + uses interface DisseminationUpdate as DisseminationUpdate57; + uses interface DisseminationValue as DisseminationValue57; + + uses interface DisseminationUpdate as DisseminationUpdate58; + uses interface DisseminationValue as DisseminationValue58; + + uses interface DisseminationUpdate as DisseminationUpdate59; + uses interface DisseminationValue as DisseminationValue59; + + uses interface DisseminationUpdate as DisseminationUpdate60; + uses interface DisseminationValue as DisseminationValue60; + + uses interface DisseminationUpdate as DisseminationUpdate61; + uses interface DisseminationValue as DisseminationValue61; + + uses interface DisseminationUpdate as DisseminationUpdate62; + uses interface DisseminationValue as DisseminationValue62; + + uses interface DisseminationUpdate as DisseminationUpdate63; + uses interface DisseminationValue as DisseminationValue63; + + uses interface DisseminationUpdate as DisseminationUpdate64; + uses interface DisseminationValue as DisseminationValue64; + + + uses interface Boot; + uses interface AMSend as SerialSend; + uses interface SplitControl as SerialControl; +} + +implementation { + typedef nx_struct dip_test_msg_t { + nx_am_addr_t id; + nx_uint8_t count; + nx_uint8_t isOk; + } dip_test_msg_t; + + message_t testMsg; + + uint8_t okBit = 1; + uint16_t data; + uint8_t count = 0; + /* + uint8_t newCount = N; + */ + uint8_t newCount = 8; + + void bookkeep(); + + event void SerialControl.startDone(error_t err) { + call StdControl.start(); + if(TOS_NODE_ID == 1) { + data = 0xBEEF; + dbg("TestDipP","Updating data items\n"); + /* + call DisseminationUpdate1.change(&data); + */ + call DisseminationUpdate50.change(&data); + call DisseminationUpdate25.change(&data); + call DisseminationUpdate47.change(&data); + call DisseminationUpdate7.change(&data); + call DisseminationUpdate43.change(&data); + call DisseminationUpdate58.change(&data); + call DisseminationUpdate48.change(&data); + call DisseminationUpdate45.change(&data); + } + } + + event void SerialControl.stopDone(error_t err) { + + } + + event void Boot.booted() { + call SerialControl.start(); + dbg("TestDipP", "Booted at %s\n", sim_time_string()); + } + /* + event void DisseminationValue1.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue1.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + */ + + event void DisseminationValue1.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue1.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue2.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue2.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue3.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue3.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue4.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue4.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue5.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue5.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue6.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue6.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue7.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue7.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue8.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue8.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue9.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue9.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue10.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue10.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue11.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue11.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue12.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue12.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue13.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue13.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue14.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue14.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue15.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue15.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue16.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue16.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue17.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue17.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue18.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue18.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue19.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue19.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue20.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue20.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue21.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue21.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue22.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue22.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue23.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue23.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue24.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue24.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue25.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue25.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue26.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue26.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue27.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue27.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue28.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue28.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue29.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue29.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue30.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue30.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue31.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue31.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue32.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue32.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue33.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue33.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue34.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue34.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue35.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue35.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue36.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue36.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue37.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue37.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue38.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue38.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue39.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue39.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue40.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue40.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue41.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue41.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue42.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue42.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue43.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue43.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue44.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue44.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue45.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue45.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue46.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue46.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue47.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue47.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue48.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue48.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue49.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue49.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue50.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue50.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue51.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue51.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue52.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue52.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue53.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue53.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue54.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue54.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue55.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue55.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue56.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue56.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue57.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue57.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue58.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue58.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue59.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue59.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue60.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue60.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue61.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue61.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue62.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue62.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue63.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue63.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + event void DisseminationValue64.changed() { + uint16_t val = *(uint16_t*) call DisseminationValue64.get(); + if(val != 0xBEEF) { return; } + bookkeep(); + } + + + void bookkeep() { + dip_test_msg_t* dipTestMsgPtr; + + if(count < newCount) { + count++; + } + dbg("TestDipP", "Got an update, %u complete now at %s\n", count, sim_time_string()); + call Leds.led0Toggle(); + + dipTestMsgPtr = (dip_test_msg_t*) call SerialSend.getPayload(&testMsg, 0); + dipTestMsgPtr->id = TOS_NODE_ID; + dipTestMsgPtr->count = count; + dipTestMsgPtr->isOk = okBit; + call SerialSend.send(0, &testMsg, sizeof(dip_test_msg_t)); + + + if(newCount == count) { + dbg("TestDipP","Dissemination COMPLETE!\n"); + call Leds.set(7); + } + + } + + event void SerialSend.sendDone(message_t* message, error_t err) { + + } +} diff --git a/apps/tests/TestDhv/gentest.py b/apps/tests/TestDhv/gentest.py new file mode 100644 index 00000000..ff3e2172 --- /dev/null +++ b/apps/tests/TestDhv/gentest.py @@ -0,0 +1,61 @@ +#!/usr/bin/python + +import sys +import re +import os +import random + +print "Usage: python gentest.py [numitems] [newitems]" + +items = sys.argv[1] +newitems = sys.argv[2] + +print "Generating Configurations" + +fin = open("TestDhvC-Master.nc", "r") +fout = open("TestDhvC.nc", "w") +lines = fin.readlines() +for line in lines: + if(line.find("... DISSEMINATORS") != -1): + for i in range(1, int(items)+1): + fout.write(" components new DisseminatorC(uint16_t, ") + fout.write(str(i)) + fout.write(") as Dissem" + str(i) + ";\n") + fout.write(" TestDhvP.DisseminationUpdate" + str(i)) + fout.write(" -> Dissem" + str(i) + ";\n") + fout.write(" TestDhvP.DisseminationValue" + str(i)) + fout.write(" -> Dissem" + str(i) + ";\n\n") + else: + fout.write(line) + +fin.close() +fout.close() + +print "Generating Modules" + +fin = open("TestDhvP-Master.nc", "r") +fout = open("TestDhvP.nc", "w") +lines = fin.readlines() +for line in lines: + if(line.find("... INTERFACES") != -1): + for i in range(1, int(items)+1): + fout.write(" uses interface DisseminationUpdate as DisseminationUpdate") + fout.write(str(i) + ";\n") + fout.write(" uses interface DisseminationValue as DisseminationValue") + fout.write(str(i) + ";\n\n") + elif(line.find("... NEWCOUNT") != -1): + fout.write(" uint8_t newCount = " + str(newitems) + ";\n") + elif(line.find("... CHANGES") != -1): + for i in random.sample(range(1, int(items)+1), int(newitems)): + fout.write(" call DisseminationUpdate" + str(i) + ".change(&data);\n") + elif(line.find("... EVENTS") != -1): + for i in range(1, int(items)+1): + fout.write(" event void DisseminationValue" + str(i)) + fout.write(".changed() {\n") + fout.write(" uint16_t val = *(uint16_t*) call DisseminationValue" + str(i) + ".get();\n") + fout.write(" if(val != 0xBEEF) { return; }\n") + fout.write(" bookkeep();\n") + fout.write(" }\n\n") + else: + fout.write(line) + -- 2.39.2