Archive for the Pervasive Computing Category

Simple Solution to getting Mote Datafeeds using CrossBow Netbridge

Posted in Pervasive Computing with tags , , , , , , , , , , on May 29, 2008 by Ben

I just got my hands on a few motes and a Crossbow Stargate Netbridge (runs debian!) to manage them all. It’s too late in the day to really explain motes, but in the simplest sense they are little wireless sensors that can be theoretically be combined to form a wireless sensor network. The CrossBow Netbridge serves as a bridge between the (Zigbee?) Motes and a normal TC/IP network — Xserve is what they call their bridge/server application.

In any case out of the box they come with a nice management console Mote Explorer, which let’s you view data from the motes, graph it, and.. that’s about it, — although it does have a pretty slick Flash/Flex interface. Stanza ( http://www.stanza.co.uk/emergentcity/?tag=motes ) has written pretty extensively on his trouble using motes, I sent him an email requesting source code — as it is really hard to find any meaningful source code that uses both motes, and the Xserve (especially because of Apple’s Xserve).

Apparently there is some method of reading the current status of MOTES, or at least tapping into a MOTE sensor feed using the Xserve’s sensor bridge. It appears that you can make XMLRPC calls to the Crossbox Xserve, but these XMLRPC calls are not over standard HTTP (like normal XMLRPC) and require you to write your own custom client. It doesn’t look that hard to do, but I couldn’t actually find an XMLRPC call to read values from a sensor, so decided it wasn’t worth it to write CrossBow Python XMLRPC libraries.

Long story short I found another place to hook into the mote sensor feeds that is very easy to implement, and pretty clean. [ I am sure there is a nice way to accomplish this using XSERVE, but there documentation includes no examples, and thus is not -- quick hack friendly]

So here’s the trick. We get the sensor feed directly from the XSERVE console. (I think I may also be using an older version of XSERVE, they might have a newer edition now I am using 2.4.10)

We SSH as too to the StarGate and create a FIFO to handle the console output from the XSERVE

ssh root@____
mkfifo /tmp/mote_feed
chmod 777 /tmp/mote_feed

Then we create our own little startup script for XSERVE that will write to our FIFO


export LD_LIBRARY_PATH=/usr/xserve/bin
export XSERVE_PARAMETER_FILE=/usr/xserve/xparams.properties
export XSERVE_ARGS_FILE=/usr/xserve/xparams.args
/usr/xserve/bin/xserve  -u=user -s=/dev/ttyUSB1 > /tmp/mote_feed

Finally we write a quick parser for the output from the log file that can be dropped into another piece of code to send the data to a remote server, or do whatever you plan on doing with the data. The below parser is sort of ugly, but gets the job done. I prefer ruby or perl for parsing, but Python will get the job done.


#!/usr/bin/python2.5
import re
f = open("/tmp/mote_feed")
try:
  a = "q"
  good_entry = False
  item = {}
  while( a != ''):
    a = f.readline()
    if( re.search("^\[", a)):
      good_entry = False
      # print the entry I suppose
      if(item != {}):
        print item
      item = {}
    if(good_entry):
      if(a.find(":")):
        #print a
        d = a.split(":")
        #print d
        if(len(d) > 1 and d[1] !=”):
          if(d[0].strip(”\t\n “) == “health”):
            d[1] = d[1].replace(”parent=0″,”")
            d[0] = “node”
          item[d[0].strip(”\t\n “)] = re.sub(”[^\d\.]“,”", d[1].strip(”\t\n “))
      #print a
    if( re.search(”^\[[^\]]+\] MTS”, a)):
      good_entry = True
finally:
  f.close()

The Resulting output looks like:

{’node’: ‘272′, ‘battery’: ‘438′, ‘mic’: ‘438′, ‘light’: ‘756′}
{’node’: ‘272′, ‘battery’: ‘2.859251′, ‘mic’: ‘438′, ‘light’: ‘2112′}
{’node’: ‘272′, ‘battery’: ‘438′, ‘mic’: ‘437′, ‘light’: ‘757′}
{’node’: ‘272′, ‘battery’: ‘2.859251′, ‘mic’: ‘437′, ‘light’: ‘2115′}
{’node’: ‘272′, ‘battery’: ‘438′, ‘mic’: ‘438′, ‘light’: ‘757′}
{’node’: ‘272′, ‘battery’: ‘2.859251′, ‘mic’: ‘438′, ‘light’: ‘2115′}

Before parsing the data appears in the below format. So the batter level is in Volts?, temperature in degrees centigrade, light in mV ??, and microphone is in ‘counts??’. I also have no idea why the battery level is fluctuating between 438 and 2.859 — and light is fluctuating between 757 and 2115. It seems like there is some sort of error with the sensors, because it’s not with the parsing.

battery: = 2.859251 V
temperature=25.436247 degC
light: = 2112 mV
mic: = 437 counts

Semi-public displays

Posted in Pervasive Computing, lit review on March 20, 2008 by kmouly

While I was looking for papers on collaborative  reminder systems, I found the paper titled:  Semi-Public Displays for Small, Co-located Groups. This paper discussed the applications developed by the authors for small collocated groups. The public displays in this setting are meant to be source of ambient information about the group members.

  • Reminders - slide show style display of reminders, requests and frequently emailed documents like status reports. Requests were extracted from status reports using a Perl parser
  • Collaboration space - allows anyone to enter test in freeform text and images. Supports asynchronous group work.
  • Active Portrait - shows a group  photo. The brightness of a group member indicates his/her activity. Less active members are shown as silhouette thereby accentuating their absence.
  • Attendance panel - an abstract visualization to depict attendance of upcoming events as a flower. The color of the flowers would indicate the response rate of a event.

I liked the idea of extracting reminders and help requests from the status reports. For my project I can extract requests or event reminders sent to si distribution lists and bounce it off our display.

The authors have completely dodged privacy questions, claiming that the semi-public display acts an quick and accessible source for information available within the group. The  argument doesn’t seem convincing to me. The authors tested the applications in academic labs, that can be secluded, like our SI North. But in a corporate environment small team don’t share a cozy space, hence a system without any privacy control may not be deployable.

Architecture for Privacy-Sensitive Ubicomp - Intro

Posted in Pervasive Computing, lit review on March 6, 2008 by kmouly

Another paper on handling privacy in Ubicomp applications.T he objective of Ubiquitous Computing is: Technology should be extended in a fundamental manner that removes any conscious awareness of technology.

With the advancement in technology there is natural push towards developing a Ubiquitous Computing environment. But these technologies are introducing privacy risks faster than the time required to develop legal and social norms, to handle these privacy risks. Consequently many Ubicomp systems are being rejected due to privacy concerns. Example: Active Badges for location sensing for locating nurses in hospital is considered to be a surveillance mechanism, albeit they have some advantages. For similar privacy concerns many Ubicomp apps are not being deployed in spite of having the technical capability to implement them.

Earlier research work in privacy concentrated on providing anonymity and securing the personal data. In Ubicomp environment, users are willing to share their data but need control over what is being shared.

The authors have developed Confab toolkit which is “based on analysis of user needs and interaction design for ubicomp privacy”. It provides foundation for developers to build privacy sensitive applications.

Problems with personal privacy:
* It is hard to analyze privacy needs. The paper presents end user needs gathered from various sources which should help us understand privacy needs.
* UI for privacy: List of pitfalls in designing UI for privacy - that are still being made.
* Implementation of privacy sensitive systems: Design, implementation, and evaluation of confab toolkit

Three layers in Confab toolkit:
* Physical/sensor layer
* Infrastructure layer
* Presentation layer

* Privacy is often thought after the applicaitons are developed
* Privacy is inhibiting deployment of ubicomp technologies
* Little support guidance exists
* Privacy uses are likely to increase from ubicomp technologies

Interactive Public Ambient Display

Posted in Pervasive Computing with tags on January 31, 2008 by Ben

There’s a guy at Toronto who built a pretty awesome public ambient display, and also tried to emphasize a few zones of interaction.

http://www.nonsequitoria.com/v.php?s=research&f=interactive_public_ambient_displays&i=phases.gif

I don’t know if he’s still working on it, as his CV hasn’t been updated in a while.

Project Oxygen

Posted in Pervasive Computing with tags , on January 31, 2008 by Ben

It would be worthwhile to take a look at Project Oxygen to get some context on work that’s been done in the past.

Publish-Subscribe for Sensor Networks

Posted in Pervasive Computing with tags , , , on January 30, 2008 by Ben

I’ve been doing a good amount of research trying to figure out if the publish-subscribe model I have been working on for pervasive computing systems is novel in any way. So far it is at least novel in I can’t find anyone that has released source-code — so far. [correction I was wrong]

Papers focused on Systems: 

PLIM Context Aware System - Jabber based approach, Jabber works well for high level data, but it creates a lot of centralized overhead if it’s used as the primary transport.

Thirunavukkarasu Sivaharan, Gordon S. Blair, Geoff Coulson: GREEN: A Configurable and Re-configurable Publish-Subscribe Middleware for Pervasive Computing. OTM Conferences (1) 2005: 732-749 (I could not find a research group page for this system)

MundoCore -  is a pretty complete low level core for sending messages around in a UbiComp environment.  It was built as part of a larger Mundo Project at Technische Universitat Darmstadt in Germany.  This group look like they have a lot of recent releases and lot of systems style research for Ubicomp.

Aitenbichler, E., Kangasharju, J., and Mühlhäuser, M. 2007. MundoCore: A light-weight infrastructure for pervasive computing. Pervasive Mob. Comput. 3, 4 (Aug. 2007), 332-361. DOI= http://dx.doi.org/10.1016/j.pmcj.2007.04.002

Aitenbichler, E., Lyardet, F., Austaller, G., Kangasharju, J., and Mühlhäuser, M. 2007. Engineering intuitive and self-explanatory smart products. In Proceedings of the 2007 ACM Symposium on Applied Computing (Seoul, Korea, March 11 - 15, 2007). SAC ‘07. ACM, New York, NY, 1632-1637. DOI= http://doi.acm.org.proxy.lib.umich.edu/10.1145/1244002.1244348

[ This claims to be a user oriented paper, but in my opinion lacks evaluation of some of their important claims -- i.e. the complex interactions they claim their system is useful for are not really talked about ]

Papers more focused on attributes of systems:

Taherian, Salman; Bacon, Jean, “State-Filters for Enhanced Filtering in Sensor-Based Publish/Subscribe Systems,” Mobile Data Management, 2007 International Conference on , vol., no., pp.346-350, 1-1 May 2007
URL: http://ieeexplore.ieee.org.proxy.lib.umich.edu/iel5/4417106/4417107/04417180.pdf?isnumber=4417107∏=STD&arnumber=4417180&arnumber=4417180&arSt=346&ared=350&arAuthor=Taherian%2C+Salman%3B+Bacon%2C+Jean

[This paper emphasizes that state-filters are pretty important, we use state-filters in our system, although, probably abstract the statefullness in a let elegant way then these researchers would recommend.  The authors also talk about the difference between Source-Side and Scoped filtering -- Both important concepts for building scalable pervasive systems. (Worth citing down the road) ]

Cilia, M., Fiege, L., Haul, C., Zeidler, A., and Buchmann, A. P. 2003. Looking into the past: enhancing mobile publish/subscribe middleware. In Proceedings of the 2nd international Workshop on Distributed Event-Based Systems (San Diego, California, June 08 - 08, 2003). DEBS ‘03. ACM, New York, NY, 1-8. DOI= http://doi.acm.org.proxy.lib.umich.edu/10.1145/966618.966631

[ This paper has a nice look at the problems people run into in publish-subscribe architectures with mobile devices.  The authors propose the buffer + replay of old events model, which seems to be a good approach in many situations]