Is it possible to send multiple sensors data (accelerometer + gyro +magnetomer) simultaneously using android wear? I understand that we can send multiple sensors data but not at the exact same timestamp. Any suggestions are welcome!
If your problem is that you have a collection of data points (sensor data in this case) and you want to sync them across all connected devices in one shot, then can't you simply use a DataMap to put all the data points in there and then use PutDataMapRequest to sync that data as shown here? If you don't want to sync across all the nodes on your network and only want to target a subset of devices (phone seems to be your target in this case), then you can actually use MessageApi to do that; you define a capability for the target node and then on any other node, you first search for the node(s) that have the desired capability and then you send a message to them. The payload for a message is a byte array so you can have all the data points that you want put together in a su=ingle byte array (for example, create a simple json like string from your data points and convert the string to a byte array).
Related
I have some highly variable time series data and are looking for an efficient way to store it. It only needs to be queried based on timestamp and two tags (type and device).
A device typically logs a set of 15-20 values (from a possible pool of around 200) and this set of values will generally never change over the entire life of the device, so it seems inefficient to have all these extra fields(columns) for values I'll likely never use.
Because of the above, I'm considering protocol buffers as an efficient way to store this data, but struggling with a way to store this data in influxDB.
Is it possible to store either protocol buffers OR binary data in InfluxDB? I really don't want to use an encoding scheme (eg: base64) to store it as a string.
Would it be possible to utilize the data that comes out of the Tango on a computer? I noticed that the datasets that are recorded are just ROS bags, but I'm not sure what the message types contain in each topic. Is there a resource that allows us to access the information contained in the bag?
EDIT: I'm talking about using the key: TANGO_DATASETRCORDING_MODE_ALL (https://developers.google.com/tango/apis/java/reference/TangoConfig.html#TANGO_DATASETRECORDING_MODE_ALL)
I don't know about recording the data on the Tango and exporting the dataset to a computer afterwards, but it's very much possible to stream the data to a .csv file over a WiFi connection.
As a simplified example, in the Tango's onPoseAvailable() callback, you can build a string that contains the x, y and z position of the Tango and fire off an ASyncTask class to write the position string to a WiFi port on your computer. On your computer you can have a simple script listening to that port which then writes whatever it receives into a .csv file. The WiFi write from the Tango's side will be triggered whenever onPoseAvailable() is called so you are effectively streaming the Tango's position in real-time.
What is the best way to pass slice and map structure over channel that is distributed over network? I need to distribute the application running over several EC2 instances and wonder how I can achieve this by communicating each application by Go channel.
Here's the workflow that I would like to run:
1. Process data in one application
2. Distribute the data into 10 replica applications
3. Each 10 application does its job in a separate EC2 instance
4. Once they are all done, they send the result back to the original program
5. This is sent over the channel
Please let me know. Thanks!
If depends on the format you will chose for the serialization.
One well-suited for over-the-network communication is MessagePack (an efficient binary serialization format. It lets you exchange data among multiple languages like JSON. But it's faster and smaller)
A Go library like philhofer/msgp can serializaze any struct (like one with a map), including composite types like maps and arrays.
However, it uses Go1.4 go generate command. (go 1.4rc1 is already out)
From there, a library like docker/libchan can help: Libchan is an ultra-lightweight networking library which lets network services communicate in the same way that goroutines communicate using channels.
Lets say I have four beacons configured with same UUID , same major value and different minor values.Then I am monitoring the regions using only the UUID and imagine the a scenario where the four beacons overlaps with each other, assume when entering the store. Will I get four locationManager:didEnterRegion callbacks for each beacon or will it be only one ?
You will only get one. (Small caveat: iOS sometimes sends multiple callbacks, but this is rare, and can be considered a glitch in CoreLocation. These glitches have nothing to do with multiple beacons in a region being detected.)
Also note that you won't know which of the iBeacons is visible when you get the entry notification. To get the specific identifier, you will need to start ranging.
I need your advice on Redis datatypes for my project. The project is a torrent-tracker (ruby, simple sinatra-based) with pure in-memory data store for current information about peers. I feel like this is what Redis is made for. But I'm stuck at choosing proper data types for this. For now I tend to the following setup:
Use list for seeders. Actually I'd better need a ring buffer to get a sequential range of seeders (with given size and start position) and save new start position for the next time.
Use sorted set for leechers. Score for each leecher is downloaded/(downloaded+left) so I can also extract a range for any specific case.
All string values in set and list are string (bencoded) representation of peer data.
What I actually lack in the setup above is:
Necessity to store offset for seeders so data access needs synchronization.
Unknown method of finding a specific seeder in list. Here I may benefit from set but then I won't be able to extract a range of items at once.
(General problem) Need TTL for set/list members (if client shuts down without sending any data before this). Possible option is to make each peer an ordinary string key/value (string or hash), give it TTL, subscribe on destroy and delete it in corresponding list or set.
What could you suggest? Any practical advice?