https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Connected Devices sorted by most viewed. https://community.wolfram.com/groups/-/m/t/170725 Sous vide is the method of cooking food in airtight bags using a water bath at a precise temperature. The method is fantastic to get the meat and seafood cooked evenly at the cooking point you love most. [url=http://modernistcuisine.com/2013/01/why-cook-sous-vide/]http://modernistcuisine.com/2013/01/why-cook-sous-vide/[/url] [url=http://www.douglasbaldwin.com/sous-vide.html]http://www.douglasbaldwin.com/sous-vide.html [/url] Buying an off the shelf sous vide can run for several hundreds of dollars. One of the many ways you can explore the world of modernist cooking is with your raspberry pi / some sensors and extra electronics/mathematica and a crock pot.   This initial posting will cover the very basic building blocks necessary for connecting to temperature gauges needed + turning on/off the crock pot. I hope that through the community postings we can all develop a full fledge solution using the Raspberry Pi that can allow you to monitor the temperature of the water bath, food, setting up the off/on temperatures, chart the cooking process, send SMS text /email when food is done, etc. Let's start with the basics. We'll need to turn on/off the water bath (crock pot). For that we'll need to control a relay. You can build your own circuit. Gaven McDonald's instructional video is a great starting point to build your own circuit and check how to connect the relay to your Raspberry Pi. [url=https://www.youtube.com/watch?v=b6ZagKRnRdM]https://www.youtube.com/watch?v=b6ZagKRnRdM[/url] You can buy a 2-relay module that works for Arduino/Raspberry just like this one. [url=http://www.sainsmart.com/arduino/arduino-components/relays/arduino-pro-mini.html]http://www.sainsmart.com/arduino/arduino-components/relays/arduino-pro-mini.html[/url] [url=http://www.sainsmart.com/arduino/arduino-components/relays/arduino-pro-mini.html][img=width: 500px; height: 500px;]/c/portal/getImageAttachment?filename=e11b1280bd72caccef99cdb9d60d4685.jpg&userId=11733[/img][/url] Opening/Closing the relay is straightforward with Mathematica. Using one of the available pins (ie PIN 17) you can power on /off the crockpot by using the command [mcode]DeviceWrite["GPIO",17->1][/mcode] Things get a little bit more challenging with taking temperature readings from the thermocouples. As BobtheChemist pointed out in his blog[mcode]http://www.bobthechemist.com/index.php/10-stuff/24-thanksgiving-pi[/mcode] The raspberryPi does not have analog pins in its GPIO (General Purpose Input Output). In his blog entry Bob shows how to overcome this limitation by using a capacitor and measuring how long it takes to charge it. For this entry, I decided to document the use of an analog to digital converter (ADC).  Checking out the web I found from several discussions and postings that the MCP 3008 would do the job. [url=http://www.adafruit.com/products/856]http://www.adafruit.com/products/856 [/url] We can use this transistor to hook up up to 8 analog sensors into our project. In our case, we'll only need two. One for the water bath probe and another for the food probe. The following wire diagram covers how to connect the MCP 3008 to the GPIO (Please focus on the right side of the MCP3008 wiring). [url=http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi/connecting-the-cobbler-to-a-mcp3008]http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi/connecting-the-cobbler-to-a-mcp3008[/url] For the thermocouples, you need to watch out on the type of thermocouples you get. For this specific project the replacement probes for the Maverick ET-73 will work just fine. [url=http://www.amazon.com/gp/product/B004W8B3PC/ref=oh_details_o00_s00_i00?ie=UTF8&psc=1]http://www.amazon.com/gp/product/B004W8B3PC/ref=oh_details_o00_s00_i00?ie=UTF8&psc=1[/url] The thermocouples must be connected to the MCP3008 channels CH0 and CH1 in the following manner. [img=width: 240px; height: 320px;]/c/portal/getImageAttachment?filename=photo.JPG&userId=78214[/img] We do need to determine the value needed for the fixed resistance. The best value would be equal to the one expected when we reach the cooking temperatures. As I like my steaks medium I chose 60C as the point to use. Using a thermometer, the thermocouples and a multimeter, I measured the temperature of a ice water glass, hot water and warm water. Using the three points, we can find the function that represents the temperature based on the resistance of the thermocouple.[mcode]temp = {20.6, 42, 83.3} + 273.15 resistance = {220650., 95800., 26340.} data = Transpose[{Log@resistance, Log@temp}] lm = LinearModelFit[data, x, x] lm[{"RSquared"}][/mcode]The model fits very well R^2=0.998 What is the expected resistance at 60C? [mcode]invdata = Transpose[{Log@temp, Log@resistance}] Fit[invdata, {1, x}, x] (*74.3895 - 10.9297 x*) f[x_] := 74.38949510675315` - 10.929736543045369` x Exp[f[Log[60 + 273.15]]] (*54344.9*)[/mcode]Thus I used 56K Resistors for the thermocouples. Now, to the function needed to read the thermocouples value. We have to probe the analog inputs from the MCP 3008 via the GPIO.  We can use the library for the MCP 3008 developed by Gabriel Perez-Cerezo [url=http://gpcf.eu/projects/embedded/adc/]http://gpcf.eu/projects/embedded/adc/[/url] There are two libraries needed gpio.h and mcp3008.h.  Dropped them both into /usr/include directory in the Raspberry Pi The other very important step necessary is exporting the GPIO pins into /sys/class/GPIO, Gabriel also provides the script needed in hist web page. Please make sure to follow his intructions found in the comment section of the script. I forgot to run the [b]update-rc.d -f gpio defaults [/b]command after the installation and spent quite of bit of time after rebooting the equipment several days later. Was getting an error in Mathematica (and a c program to check if the reading was working, kept getting a segmentation fault error) all because the step needed for the script to run at startup was not in place. Once we have the libraries in place we can address building a function with MathLink to get the readings from the MCP 3008 Please refer to the mathlink developer guide for more details in how it works [url=http://reference.wolfram.com/mathematica/tutorial/MathLinkDeveloperGuide-Unix.html]http://reference.wolfram.com/mathematica/tutorial/MathLinkDeveloperGuide-Unix.html[/url] Built the two files needed for the function adc.tm[code]:Begin: adc :Pattern: adc[adc_Integer, clock_Integer, in_Integer, out_Integer, cs_Integer] :Arguments: {adc, clock, in, out, cs} :ArgumentTypes: {Integer, Integer, Integer, Integer, Integer} :ReturnType: Integer :End: [/code]adc.c [code]#include <mathlink.h> #include <mcp3008.h> int adc(int adc, int clock, int in, int out, int cs) { return mcp3008_value(adc, clock, in, out, cs); } int main(int argc, char *argv[]) { return MLMain(argc, argv); }[/code]After creating both files, I proceeded to compile the program with the following command. This generated the necessary function that can now be invoked from Mathematica or the wolfram engine as follows. [mcode]Install["/home/pi/mathematica/adc/adc"]; (*We can now call function adc to read the voltage drop at the thermocouple The voltage reading will be read by the MCP as a value between 0 (0V)to 1023 (3.3V) *) (* Analog Channel = 0, ClockPin = 18, In = 23, Out =24, CS = 25 *) adc[0, 18, 23, 24, 25] (*The following function translates the voltage reading to temperature in Celsius*) temp[channel_] := Module[{R2 = 56000, a = -0.0913946, b = 6.80504, R1, x = adc[channel, 18, 23, 24, 25]}, R1 = (1024 - x) R2/x ; Exp[a Log[R1] + b] - 273.15] (*Function datapoints is used to collect temperature readings in a matrix of length maxPoints. It also controls the relay to turn on the crockpot when the temperature reading is below the setpoint and turn it on when above the set point*) datapoints[myList_List, fn_, maxLength_Integer, setPoint_Integer] := Module[{x, val = fn}, x = Append[myList, {DateList[], fn}]; If[val < setPoint, DeviceWrite["GPIO", 17 -> 0], DeviceWrite["GPIO", 17 -> 1]]; If[Length[x] > maxLength, x = Take[x, -maxLength], x]] data={}; (*Using a Chart to establish the setpoint and graph the temperature trend *) Manipulate[ DateListPlot[Refresh[data = datapoints[data, temp[0], 300, setPoint], UpdateInterval -> 15, TrackedSymbols -> {}], Joined -> True, PlotRange -> {Automatic, {20, 100}}, GridLines -> {Automatic, {setPoint}}], {{setPoint, 60}, 30, 80, 1, Appearance -> "Labeled"}] [/mcode][img=width: 407px; height: 336px;]/c/portal/getImageAttachment?filename=7.png&userId=78214[/img] This is a link to the video that shows the program running and controlling the relay. [url=http://youtu.be/4ae42ctVZuk]http://youtu.be/4ae42ctVZuk[/url] Next challenge will be to use the Web Server functionality of the Raspi to interact with Mathematica so as to control the set point and chart the temperature curve via a web page. ... to be continued. Diego Zviovich 2013-12-14T07:37:04Z https://community.wolfram.com/groups/-/m/t/418132 *NOTE: the main tutorial notebook is attached at the end of this post and [can be downloaded by clicking here][1].* ---------- I wanted to share the attached *Mathematica* notebook that I created for teaching kids (ages 9-14) about the Wolfram Language on the Raspberry Pi. It has a simplified (and colorful) interface for students and easy editing tools for teachers to create new content (even those with little or no experience using *Mathematica*). I am extremely grateful for the efforts of Anna Musser who very patiently helped me refine the interface over many iterations and piloted the first workshops using this notebook at Empow Studios! It includes a self-paced tutorial designed for beginning programmers who are young or young-at-heart. It also includes instructions for authoring your own tutorials. The interface is minimally dynamic so the tutorial will run as smooth as possible on the Raspberry Pi model B; if there is interest, then we could build a prettier dynamic interface for more powerful hardware. Please comment below with any improvements/changes that you would like to see and of course please comment or upvote if you find this useful or interesting :) ---------- ## Sample of the attached tutorial: ![enter image description here][2] **COMPLETE TUTORIAL NOTEBOOK ATTACHED BELOW** [1]: https://www.dropbox.com/s/mddbex45h7ynao3/FirstCourseOnRPI.nb?dl=1 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-12-05at11.46.57AM.png&userId=11733 Kyle Keane 2015-01-07T18:16:20Z https://community.wolfram.com/groups/-/m/t/246929 Triggered by a leak in my hot water boiler at home I built a thermal imaging camera using an Arduino and interfacing it with Mathematica. I tried to make up for the "one-pixel-resolution" by using Mathematica's powerful image analysis abilities. This is a work in progress and I would be delighted to get some comments/suggestions from the Community. In this project, I had a lot of help from [url=http://community.wolfram.com/web/bschelter/home]Bjoern Schelter[/url], who has recently joined this Community. If you have the components and use the programs below, you should have a "working" one-pixel thermal camera after 30 minutes or so of DIY. Here's a sneak peek of what we want to get out (this one is a "selfie"): [img=width: 426px; height: 270px;]/c/portal/getImageAttachment?filename=asdwefasdcsdvvafe2345QT.PNG&userId=11733[/img] I use the following components:[list=1] [*]Arduino Uno R3 [*][url=http://www.amazon.co.uk/XINTE-MLX90614ESF-DCI-non-contact-Infrared-Temperature/dp/B00IMU0LXG/ref=sr_1_2?ie=UTF8&qid=1399153918&sr=8-2&keywords=Melexis]MELEXIS / MLX90614ESF-DCI / DS Digital non-contact Infrared Temperature Sensor[/url]  (~ £35 and more or less the same in USD) [*][url=http://www.amazon.co.uk/MG995-Servo-Sensor-Mount-Black/dp/B00EZIYCUW/ref=sr_1_3?ie=UTF8&qid=1399153991&sr=8-3&keywords=Pan+tilt]MG995 Servo Sensor Mount Kit 2 DOF Pan and Tilt Black[/url] (~ £24, similar in USD) [*]Two 4.7 kOhm resistors. [*]One 0.1 uF capacitor. [*]One small breadboard. [*]5V power source. [*]Wires.  [/list]The idea is illustrated in this [url=http://www.youtube.com/watch?v=rcTKVOzxCmw]Youtube video[/url]. To my best knowledge, the original idea comes from a [url=http://www.theimagingsource.com/en_US/blog/posts/20090622/]project of Steffen Strobel in the German science competition "Jugend Forscht"[/url]. The main idea is to mount a non-contact temperature sensor on a pan and tilt mechanism (i.e. two servos) on a tripod. An Arduino microcontroller is then used to communicate via the serial port with Mathematica, which is used to control the servos and triggers the measurements. After the data acquisition Mathematica cleans the data and produces some thermal images (see below). We use the following wiring diagram to connect the servos and the temperature sensor to the Arduino. [center][img=width: 300px; height: 203px;]/c/portal/getImageAttachment?filename=ThermoCam.jpg&userId=48754[/img][/center] The resistors are 4.7kOhm and the capacitor is 0.1uF. The sensor part is taken from the [url=http://bildr.org/2011/02/mlx90614-arduino/]bildr.blog[/url], which also shows how to make Arduino talk to the sensor. The Melexis sensor that we chose has a temperature resolution of 0.02 degrees Celsius and a rather narrow field of view, which is important for our application.  For the servo part, we use the standard servo.h library; an example of its application can be found [url=http://arduino.cc/en/Tutorial/sweep]here[/url]. Here is a photo of the sensor/head of the device. [center][img=width: 320px; height: 240px;]/c/portal/getImageAttachment?filename=photo.JPG&userId=48754[/img][/center] The entire device looks like this. [center][img=width: 240px; height: 320px;]/c/portal/getImageAttachment?filename=7033photo4.JPG&userId=48754[/img][/center] The idea is to use Mathematica to send instructions to the servos and to initiate the measurements. To interface Mathematica with Arduino we use the [url=http://library.wolfram.com/infocenter/Demos/5726/]SerialIO package[/url]. I found [url=http://williamjturkel.net/2011/12/25/connecting-arduino-to-mathematica-on-mac-os-x-with-serialio/]this website by William Turkel[/url] very useful to make SerialIO work on my Mac; following the steps and adapting some directories makes the package work without any problems. At that point, we have everything in place, and only need to put the bits together. We first need to upload this piece of code (also attached at the bottom) to the Arduino. [code]#include <i2cmaster.h> #include <Servo.h> //Servo setup int servoPin1 = 9; int servoPin2 = 10; Servo servo1; Servo servo2; int angle1 = 40; // servo start positions in degrees int angle2 = 50; //Melexis setup int sensor = 0; int inByte = 0; void setup() { Serial.begin(9600); // attach pan-tilt servos servo1.attach(servoPin1); servo2.attach(servoPin2); servo1.write(angle1); servo2.write(angle2); //Initialise the i2c bus i2c_init(); PORTC = (1 << PORTC4) | (1 << PORTC5);//enable pullups establishContact(); } void loop() { if (Serial.available() > 0) { inByte = Serial.read(); int dev = 0x5A<<1; int data_low = 0; int data_high = 0; int pec = 0; i2c_start_wait(dev+I2C_WRITE); i2c_write(0x07); // read i2c_rep_start(dev+I2C_READ); data_low = i2c_readAck(); //Read 1 byte and then send ack data_high = i2c_readAck(); //Read 1 byte and then send ack pec = i2c_readNak(); i2c_stop(); //This converts high and low bytes together and processes temperature, MSB is a error bit and is ignored for temps double tempFactor = 0.02; // 0.02 degrees per LSB (measurement resolution of the MLX90614) double tempData = 0x0000; // zero out the data int frac; // data past the decimal point // Serial.print(tempData); // Serial.write(inByte); // This masks off the error bit of the high byte, then moves it left 8 bits and adds the low byte. tempData = (double)(((data_high & 0x007F) << 8) + data_low); tempData = (tempData * tempFactor)-0.01; //inByte = (float)(((data_high & 0x007F) << 8) + data_low); float celsius = tempData - 273.15; sensor=(int)(celsius*100); //float fahrenheit = (celsius*1.8) + 32; Serial.print(sensor); // horizontal "H"-> 72; reverse "R"-> 82; vertical "V"-> 86; end "E"-> 69 if(inByte==72) { angle1=angle1+1; servo1.write(angle1); } if(inByte==82) { angle1=40; servo1.write(angle1); } if(inByte==86) { angle2=angle2+1; servo2.write(angle2); } if(inByte==69) { angle1 = 40; // servo back to start angle2 = 50; servo1.write(angle1); servo2.write(angle2); } delay(15); // 15 works; wait 15 milliseconds before printing again } } void establishContact() { while (Serial.available() <= 0) { Serial.print('A'); delay(100); } } [/code] The idea is to make Mathematica communicate with the Arduino via the serial connection. The Arduino sketch shows that Ardunio is waiting for instructions, e.g. "H" to move horizontally, "V" to move vertically and "E" to go to the end position.  [mcode](*First we load the SerialIO package. See instructions above.*) << SerialIO` (*We test whether Mathematica's applications folder is in the Path. On some Macs Mathematica will be in the /Library directory - used in this example- and in others in the /Users/username/Library directory, where "username" needs to be replaced by the correct user name.*) MemberQ[$Path, "/Library/Mathematica/Applications"] (*If this gives True all is fine. If it evaluates to False execute AppendTo[$Path, "/Library/Mathematica/Applications"] *) (*Connect to the Arduino*) myArduino = SerialOpen[Quiet[FileNames["tty.usb*", {"/dev"}, Infinity]][[1]]]; SerialSetOptions[myArduino, "BaudRate" -> 9600]; While[SerialReadyQ[myArduino] == False, Pause[0.1]]; (*Data collection, in this case 40 vertical and 70 horizontal pixels; runtime 2-3 minutes; pauses cannot be reduced much further.*) pixels = {}; SerialRead[myArduino]; For[j = 1, j < 41, j++, For[i = 1, i < 71, i++, SerialWrite[myArduino, "H"]; AppendTo[pixels, (SerialRead[myArduino] // ToExpression)/100.]; Pause[0.1]]; SerialWrite[myArduino, "R"]; SerialWrite[myArduino, "V"]; SerialRead[myArduino]; Pause[0.1];]; SerialWrite[myArduino, "E"]; (*After the data aquisition close the connection to Arduino*) SerialClose[myArduino] (*Now we can use several different ways to represent the data, note that some point at the beginning/end of the scanned lines are removed; there were too many measurements errors just after the "carriage return"*) ArrayPlot[Partition[Reverse[pixels], 70][[All, 2 ;; -10]],  ColorFunction -> "Rainbow"] (*here's another colour scheme.*) ArrayPlot[Partition[Reverse[pixels], 70][[All, 2 ;; -10]], (*Occasionally there are some outliers in the measurements; here we clean them out.*) ArrayPlot[ Partition[Reverse[pixels /. x_ /; x > 35. -> 35.], 70][[All,  2 ;; -10]], ColorFunction -> "Temperature"] ColorFunction -> "Temperature"] (*This last one uses interpolation to make the image smoother.*) ListContourPlot[ Partition[Reverse[Log /@ pixels /. x_ /; x > 35. -> 35.], 70][[-1 ;; 1 ;; -1, 1 ;; -10]], AspectRatio -> 0.9, ColorFunction -> "Rainbow", PlotRange -> All, InterpolationOrder -> 2, Contours -> 60, ContourStyle -> None][/mcode][center][/center]So here's a photo of my broken boiler and its scan: [center][img=width: 518px; height: 257px;]/c/portal/getImageAttachment?filename=BoilerScan.jpg&userId=48754[/img][/center] Because of the scanning procedure (which just looks at the angle and does not use any projection), the scan is slightly distorted, but it is possible to recognize the main features and even the sticker on the front! It appears that this rather primitive device can also be used to analyse electrical components. Here is an image of my MacBook Pro. [center][img=width: 450px; height: 306px;]/c/portal/getImageAttachment?filename=Laptop1.jpg&userId=48754[/img][/center]  The position of the CPU becomes quite obvious. There are many things that need to be improved: (i) First, there is the projection issue. The scanner does scan angles. It needs to be projected to a 2D plane. One might use an ultrasonic distance sensor to get better results. (ii) The device needs to be calibrated. (iii) A user interface is needed. It would be useful to click on the image and get the temperature reading. (iv) The communication between Mathematica and the Arduino need to be improved. The starting position of 40/50 degrees is hard-coded into the Arduino sketch. It should be done by the Mathematica code. (v) We have not even started to use Mathematica's features on this. Much image processing could be done. The image should be overlayed to a normal photo of the object that is scanned. Manipulate could be used to change thresholds, i.e. the threshold to cut-off outliers, which is currently set to 35 degrees.  (vi) The speed might be improved. I suppose that the scanning time of 3 minutes or so is typical for these devices, but one might improve that a bit. Also, Mathematica could use edge-detection to determine regions where a higher scan density would be helpful to get a better resolution. This only makes sense if the servos could be directed to a certain position much more precisely; alternatively, we could use random positions, which then are precisely determined using an accelerometer or so. There is of course much more to do. In spite of this being work in progress, I wanted to share this project, and hope for helpful comments. I attach the Mathematica notebook. I have a movie of the scanning process and the actual arduino sketch which I cannot upload directly. Here are links to the [url=https://www.dropbox.com/s/sm2prb5w0wrqexp/ThermoCamera_Forum.zip]arduino sketch[/url] and the [url=https://www.dropbox.com/s/wpgpww8a7jhjfn0/Scan.MOV]scanning movie[/url]. M. Marco Thiel 2014-05-04T00:48:33Z https://community.wolfram.com/groups/-/m/t/315748 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/4d655a10-832e-4ace-b937-6d5a702289a3 Ian Johnson 2014-08-10T17:56:06Z https://community.wolfram.com/groups/-/m/t/344278 Many fantastic posts in this community describe how to connect external devices to Mathematica and how to read the data. Connecting Mathematica to an Arduino for example allows you to read and then work with data from all kinds of sensors. In most of the cases, when we speak about connected devices, additional hardware is necessary. Smart phones, on the other hand, are our permanent companions and they host a wide array of sensors that we can tap into with Mathematica. For this post, I will be using an iPhone 5 - but a similar approach can be taken with many other smart phones. [Björn Schelter][1] and myself have worked on this together. The first thing we need in order to be able to read the iPhone is a little App which can be purchased on the iTunes App store: it is called [Sensor Data][2]. When you open the app you see a screen like this one. ![enter image description here][3] At the top of the screen you see an IP address and a port number (after the colon!). These numbers will be important to connect to the phone and either download data or stream sensor data directly. If you click on the "start capture" the iPhone's data will be stored on the phone and can be downloaded into Mathematica. In this post we are rather interested in the "Streaming" function. If you click on the respective button on the bottom you get to a screen like this: ![enter image description here][4] There you can choose a frequency for the measurements and start the streaming. In fact we also can choose which sensors we want to use with the Config button. ![enter image description here][5] The following Mathematica code will work when all (!) sensors are switched on. Now we are ready to connect to the iPhone. Switch the streaming on and execute the following commands: ClearAll["Global`*"]; For[i = 1, i < 3, i++, Quiet[InstallJava[]]]; Needs["JLink`"] and then LoadJavaClass["java.util.Arrays"]; packet = JavaNew["java.net.DatagramPacket", JavaNew["[B", 1024], 1024]; socket = JavaNew["java.net.DatagramSocket", 10552]; socket@setSoTimeout[10]; listen[] := If[$Failed =!= Quiet[socket@receive[packet], Java::excptn], record =JavaNew["java.lang.String", java`util`Arrays`copyOfRange @@ packet /@ {getData[], getOffset[], getLength[]}]@toString[] // Sow]; Next we have to define a ScheduledTask to read the sensors: RemoveScheduledTask[ScheduledTasks[]]; results = {}; RunScheduledTask[AppendTo[results, Quiet[Reap[listen[]][[2, 1]]]]; If[Length[results] > 1200, Drop[results, 150]], 0.01]; We also need to define a streaming function: stream := Refresh[ToExpression[StringSplit[#[[1]], ","]] & /@ Select[results[[-1000 ;;]], Head[#] == List &], UpdateInterval -> 0.01] Alright. Now comes the interesting part. Using (*Compass*) While[Length[results] < 1000, Pause[2]]; Dynamic[AngularGauge[Refresh[stream[[-1, 30]], UpdateInterval -> 0.01], {360, 0}, ScaleDivisions -> None, GaugeLabels -> {Placed["N", Top], Placed["S", Bottom], Placed["E", Right], Placed["W", Left]}, ScaleOrigin -> {{5 Pi/2, Pi/2}, 1}, ScalePadding -> All, ImageSize -> Medium], SynchronousUpdating -> False] we can measure the bearing of our iPhone. The resulting compass moves as we move the iPhone: ![enter image description here][6] We can also read the (x-,y-,z-) accelerometers (*Plot Ascelerometers*) While[Length[results] < 1000, Pause[2]]; Dynamic[Refresh[ListLinePlot[{stream[[All, 2]], stream[[All, 3]], stream[[All, 4]]}, PlotRange -> All], UpdateInterval -> 0.1]] which gives plots like this one: ![enter image description here][7] The update is a bit bumpy, because the data is only sent every second or so from the iPhone; the measurements, however, are taken with a frequency of up to 100Hz. We can also represent the FFT of the streamed data like so: (*Plot FFT of accelorometers*) While[Length[results] < 1000, Pause[2]]; Dynamic[ Refresh[ListLinePlot[ Log /@ {Abs[Fourier[Standardize[stream[[All, 2]]]]], Abs[Fourier[Standardize[stream[[All, 3]]]]], Abs[Fourier[Standardize[stream[[All, 4]]]]]}, PlotRange -> {{0, 200}, {-5, 2.5}}, ImageSize -> Large], UpdateInterval -> 0.1]] Adding a "real time" scale is also quite straight forward: (*Measurements with time scale*) While[Length[results] < 1000, Pause[2]]; starttime = IntegerPart[stream[[2, 1]]]; Dynamic[Refresh[ ListLinePlot[ Transpose[{(stream[[Max[-300, -Length[stream]] ;;, 1]] - starttime), stream[[Max[-300, -Length[stream]] ;;, 2]]}], PlotRange -> All, ImageSize -> Large], UpdateInterval -> 0.01]] Well, then. We can also plot our iPhone's position in space (*3d Motion*) While[Length[results] < 1000, Pause[2]]; Dynamic[ Refresh[ListLinePlot[{stream[[All, 5]], stream[[All, 6]], stream[[All, 7]]}, PlotRange -> All], UpdateInterval -> 0.1]] While[Length[results] < 1000, Pause[2]]; Dynamic[ Graphics3D[{Black, Rotate[Rotate[ Rotate[Cuboid[{-2, -1, -0.2}, {2, 1, 0.2}], stream[[-1, 7]], {0, 0, 1}], -1*stream[[-1, 6]], {0, 1, 0}], stream[[-1, 5]], {1, 0, 0}]}, PlotRange -> {{-3, 3}, {-3, 3}, {-3, 3}}, Boxed -> True], UpdateInterval -> 0.1, SynchronousUpdating -> False] This looks like so: ![enter image description here][8] Last but not least we can write a little GUI to access all different sensors. (This does run a bit slow though!) (*GUI all sensors*) sensororder = {"Timestamp", "Accel_X", "Accel_Y", "Accel_Z", "Roll", "Pitch", "Yaw", "Quat.X", "Quat.Y", "Quat.Z", "Quat.W", "RM11", "RM12", "RM13", "RM21", "RM22", "RM23", "RM31", "RM32", "RM33", "GravAcc_X", "GravAcc_Y", "GravAcc_Z", "UserAcc_X", "UserAcc_Y", "UserAcc_Z", "RotRate_X", "RotRate_Y", "RotRate_Z", "MagHeading", "TrueHeading", "HeadingAccuracy", "MagX", "MagY", "MagZ", "Lat", "Long", "LocAccuracy", "Course", "Speed", "Altitude", "Proximity"}; While[Length[results] < 1000, Pause[2]]; Manipulate[ Dynamic[Refresh[ ListLinePlot[{stream[[All, Position[sensororder, a][[1, 1]]]], stream[[All, Position[sensororder, b][[1, 1]]]], stream[[All, Position[sensororder, c][[1, 1]]]]}, PlotRange -> All, ImageSize -> Full], UpdateInterval -> 0.01]], {{a, "Accel_X"}, sensororder}, {{b, "Accel_Y"}, sensororder}, {{c, "Accel_Z"}, sensororder}, ControlPlacement -> Left, SynchronousUpdating -> False] This gives a user interface which looks like this: ![enter image description here][9] In the drop down menu we can choose three out of all sensors. These are all available sensors: > "Timestamp", "Accel_X", "Accel_Y", "Accel_Z", "Roll", "Pitch", "Yaw", > "Quat.X", "Quat.Y", "Quat.Z", "Quat.W", "RM11", "RM12", "RM13", > "RM21", "RM22", "RM23", "RM31", "RM32", "RM33", "GravAcc_X", > "GravAcc_Y", "GravAcc_Z", "UserAcc_X", "UserAcc_Y", "UserAcc_Z", > "RotRate_X", "RotRate_Y", "RotRate_Z", "MagHeading", "TrueHeading", > "HeadingAccuracy", "MagX", "MagY", "MagZ", "Lat", "Long", > "LocAccuracy", "Course", "Speed", "Altitude", "Proximity" There are certainly any things that can and should be improved. The main problem seems to be that the data, even if sampled at 100Hz, is sent to the iPhone only every second or so. So it is not really real time. I hope that someone who is better at iPhone programming than I am - I am really rubbish at it- could help and write an iPhone program to stream the data in a more convenient way: one by one rather than in packets. There are many potential applications for this. Here are some I could come up with: 1. You can carry the iPhone around and measure your movements (acceleration). Attached to your hand you can measure your tremor. 2. The magnetometer is really cool. You can use it to find metal bars in the walls an also electric cables. 3. You can collect GPS data for all sorts of applications; there are ideas to use this for the detection of certain diseases. For example if it takes you longer than usual to find your car when you come from shopping that might hint at early stages of dementia --- or sleep deprivation. 4. When you put the phone on a machine, like a running motor, you can measure the vibrations. When you perform a frequency analysis you can check whether the motor runs alright. 5. Using the accelerometers I was able to measure my breathing (putting the phone on my chest). I think that there might also be quite some potential for using the Wolfram Cloud here. Deploying a program in the cloud and reading from your phone is certainly quite interesting. The problem is that this particular app only works via WiFi. It would be nice to have one that works via 3G. So, in summary, it might be quite useful to use the iPhone's sensors. The advantage is that nearly everyone carries a smartphone with them all the time. Making more of your smart phone's sensors with Mathematica seems to be a nice playground for applications. I'd love to hear about your ideas... Cheers, Marco PS: When you are done with the streaming you should execute these commands: (*Remove Scheduled Tasks and close link*) RemoveScheduledTask[ScheduledTasks[]]; socket@close[]; [1]: http://community.wolfram.com/web/bschelter [2]: https://itunes.apple.com/gb/app/sensor-data/id397619802?mt=8 [3]: /c/portal/getImageAttachment?filename=sensorwelcome.PNG&userId=48754 [4]: /c/portal/getImageAttachment?filename=sensorstreaming.PNG&userId=48754 [5]: /c/portal/getImageAttachment?filename=Allsensors.PNG&userId=48754 [6]: /c/portal/getImageAttachment?filename=Compass.gif&userId=48754 [7]: /c/portal/getImageAttachment?filename=Accelerometer.gif&userId=48754 [8]: /c/portal/getImageAttachment?filename=Iphonemovement.gif&userId=48754 [9]: /c/portal/getImageAttachment?filename=ScreenShot2014-09-15at23.52.46.png&userId=48754 Marco Thiel 2014-09-15T23:53:14Z https://community.wolfram.com/groups/-/m/t/1028536 Hi all, Mathematica 11.0.1 is now available for the Raspberry Pi on Raspbian. If you already have Mathematica installed on your Raspberry Pi, you can update with the following: sudo apt-get update && sudo apt-get upgrade wolfram-engine If you don't already have Mathematica installed you can run the following commands to install it: sudo apt-get update && sudo apt-get install wolfram-engine New features for the Raspberry Pi include : - Neural Network features including constructing custom nets : http://reference.wolfram.com/language/guide/NeuralNetworks.html - Audio processing features including out of core streaming of large sounds as well as advanced audio processing : http://reference.wolfram.com/language/guide/AudioProcessing.html - Travel based path plan functions including path finding from one city to another : http://reference.wolfram.com/language/guide/LocationsPathsAndRouting.html - Channel based communication for sending and receiving messages : http://reference.wolfram.com/language/guide/Channel-BasedCommunication.html - Powerful and easy scripting through WolframScript : http://reference.wolfram.com/language/ref/program/wolframscript.html - And many more : http://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn11.html Additionally, with the new release of WolframScript on the Raspberry Pi, you can install WolframScript standalone and run it without a local kernel against the cloud using the `-cloud` option. This means you can use the Wolfram Language through WolframScript on the Raspberry Pi without having wolfram-engine installed by running it against the cloud. See the documentation page for WolframScript for more details. Ian Johnson 2017-03-09T21:02:49Z https://community.wolfram.com/groups/-/m/t/1057588 My project, Parallel Mathematica Environment on the RaspberryPi using OOP, is a sample application of **Object Oriented Programming for the Mathematica** cluster computing, implemented with a Mac and three RaspberryPi Zero connected with a USB hub and three USB cables. Basic idea is to deploy a constructed instance image to calculating servers (RaspberryPi) and send messages to the instance. [OOP on the Mathematica is already developed and shown][1] in this community, and further detail is shown on [slidesshare][2] titled of "OOP for Mathematica." ![enter image description here][3] ---------- Preparing for RaspberryPi Zero is as follows using SSH connection from a Mac, - naming each Zero as raspberypi,raspberrypi1,raspberrypi2,... - set the server program "init" to each RaspberryPi, init is, $ cat init While[True, Run[“nc -l 8000>input”]; temp=ReleaseHold[<<input]; temp >>output; Run[“nc your-mac-hostname.local 8002<output”] ] where, socket numbers must be identical. - Run Mathematica manually, and wait the booting Mathematica up. $ wolfram <init& Checking each RaspberryPi is useful as, $ nc -l 8002 >output|nc raspberrypi.local 8000 <<EOF > 10! > EOF $ cat output 3628800 ---------- Cluster controller program on a Mac is, - set directory SetDirectory[NotebookDirectory[]]; - setup socket communication process com1="nc -l 8002 >output1 |nc raspberrypi.local 8000 <input1"; com2="nc -l 9002 >output2 |nc raspberrypi1.local 9000 <input2"; com3="nc -l 9502 >output3 |nc raspberrypi2.local 9500 <input3"; - set object property obj={ <|"name"->node1,"comm"->com1,"in"->"input1","out"->"output1","p"->{2000,3500}|>, <|"name"->node2,"comm"->com2,"in"->"input2","out"->"output2","p"->{3501,4000}|>, <|"name"->node3,"comm"->com3,"in"->"input3","out"->"output3","p"->{4000,4500}|>}; - define calculation server class, where is a sample Mersenne prime number calculation new[nam_]:=Module[{ps,pe}, mersenneQ[n_]:=PrimeQ[2^n-1]; setv[nam[{s_,e_}]]^:={ps,pe}={s,e}; calc[nam]^:=Select[Range[ps,pe],mersenneQ] ]; - construct instances Map[new[#name]&,obj]; - deploy instances to calculation servers Map[Save[#in,#name]&,obj]; Map[Run[#comm]&,obj]; - send message to each instance Map[Put[Hold@setv[#name[#p]],#in]&,obj]; Map[Run[#comm]&,obj]; - start calculation Map[Put[Hold@calc[#name],#in]&,obj]; proc=Map[StartProcess[{$SystemShell,"-c",#comm}]&,obj] - wait for the process termination (mannualy in this sample code) Map[ProcessStatus[#]&,proc] {Finished,Finished,Finished} - gather the results Map[FilePrint[#out]&,obj]; {2203, 2281, 3217} {} {4253, 4423} [1]: http://community.wolfram.com/groups/-/m/t/897081?p_p_auth=o5qxZhNR [2]: https://www.slideshare.net/kobayashikorio/oop-for-mathematica [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2017-04-10.jpg&userId=897049 Hirokazu Kobayashi 2017-04-10T01:15:22Z https://community.wolfram.com/groups/-/m/t/196759 These sensors are pretty cool--they are [url=http://www.adafruit.com/products/374]cheap to buy[/url] and surprisingly sensitive to small changes in temperature. Here's a first attempt I made to interact with the sensors in the Wolfram Language. For this setup I used DS18B20 temperature sensors and hooked them up to the Raspberry Pi breadboard according to Adafruit's [url=http://learn.adafruit.com/adafruits-raspberry-pi-lesson-11-ds18b20-temperature-sensing/overview]setup guide[/url]. The board should look like the following diagram (make sure the sensor is hooked up to a 3.3V pin--not a 5V pin or you could fry the sensor): [center][img=width: 300px; height: 481px;]https://learn.adafruit.com/system/assets/assets/000/003/775/medium800/learn_raspberry_pi_summary.jpg[/img][/center] Once hooked up and connected to your Pi, run the following commands in the terminal: [code]sudo modprobe w1-gpio sudo modprobe w1-therm[/code] The temperatures are read from the sensor by "reading" the file that's created in the devices directory. You can locate the file with the following commands: [code]cd /sys/bus/w1/devices ls[/code] This will show you the contents of your devices folder, where there should be a file titled 28-xxxx, where the xxxx is the serial number unique to your sensor. Once you've got that number, enter: [code]cd 28-xxxx (the xxxx should be replaced with the serial number unique to your sensor) cat w1_slave[/code] Two lines of data should return back to you--if the first line ends with "YES" then the 5-digit number at the end of the second line is the temperature, to be read as xx.xxx degrees Celsius. And now that we know that the temperature sensor is working, and we know how to find it, we can copy the file path and import it using the Wolfram Language. [mcode]Import["/sys/bus/w1/devices/28-000004fe0343/w1_slave"][/mcode] Since this still returns a really long string of data that we don't need, we can single out the temperature and then convert the string into a computable expression. [mcode]temp:=N[ToExpression[StringTake[Import["/sys/bus/w1/devices/28-000004fe0343/w1_slave"],-5]]/1000][/mcode] So now when we read the file, we just get the temperature back! [mcode]temp (*22.312*) [/mcode] For kicks, I set up a scheduled task to plot the ambient temperature of my office every 60 seconds for 6 hours. Unsurprisingly, the temperature only fluctuated a few tenths of a degree...! [mcode]t={} RunScheduledTask[(deg=temp;AppendTo[t,deg]),{60,360}]; Dynamic[ListLinePlot[t,Joined->True,PlotRange->Automatic]] [/mcode] And here's what the graph looked like after a little bit of time--it truly is a sensitive device (the "large" dip down to 22.1 was me touching the sensor with my cold hands!): [center][img=width: 360px; height: 228px;]/c/portal/getImageAttachment?filename=temperaturereading3.jpg&userId=108162[/img][/center]Any suggestions for what to do next? Allison Taylor 2014-02-06T21:04:23Z https://community.wolfram.com/groups/-/m/t/344241 Together with [Björn Schelter][1] I have tried to read in data from the personal weather station [Netatmo][2] ![enter image description here][3] which, as it turns out, is a very good companion for Mathematica; it also features in the [connected devices list of Wolfram][4].This device measures temperature, humidity, pressure, noise level and potentially the precipitation indoors and outdoors. Users are encouraged to share the outdoors data; as the weather station is rather popular there are lots of measurements. On their website [https://www.netatmo.com/][5] the company makes these measurements available. You can represent worldwide data ![enter image description here][6] (I know that that figure does not show the entire world!) or zoom in to street level data: ![enter image description here][7] On the website [https://dev.netatmo.com][8] you can sign up for a developer account which gives you access to the API of netatmo. In this post I am going to show how to access the data with Mathematica. When you sign up for a netatmo developer account you will be issued a client id and a client secret. These are rather long strings. You will also get a username and a password for your account. Next you need to request an access token, which you can do via the following command: > curl -X POST -d > "grant_type=password&client_id=AAAAAAAAAAAAAAAAAAAA&client_secret=BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB > &username=XXXXXXXXXXXXXXXX&password=YYYYYYYYYYYYYYY&scope=read_station" > http://api.netatmo.net/oauth2/token> ~/Desktop/request-token.txt On a Mac I generate a file called netatmo.sh containing that string on the desktop; I obviously substitute AAAAAAAAAAAA by the client id, BBBBBBBBBBBBBBBB by the client secret, XXXXXXXXXXXX and YYYYYYYYYY by the user name and the password. Then I use the terminal command > chmod a+x netatmo.sh The rest is child's play. We need to execute the command Run["~/Desktop/netatmo.sh"]; data = Import["https://api.netatmo.net/api/getpublicdata?access_token="<>Last[StringSplit[Import["~/Desktop/request-token.txt", "CSV"][[1, 1]], "\""]] <> "&lat_ne=59.91&lon_ne=13.75&lat_sw=40.42&lon_sw=-20.0&filter=True", "Text"]; Note that the numbers following lat_ne, lon_ne, lat_sw, lon_sw are the north east and south west latitudes and longitudes. If we want to request data for other regions we can do so by changing these entries. Next we clean the data a little bit: tab = Quiet[ Select[Select[Table[ToExpression /@ Flatten[StringSplit[#, "]"] & /@ StringSplit[#, "["] & /@ If[Length[StringSplit[StringSplit[data, "place"][[k]], ","]] > 12, Drop[StringSplit[StringSplit[data, "place"][[k]],","], {5}], StringSplit[StringSplit[data, "place"][[k]], ","]]][[{2, 3, 7, 8, 15}]], {k, 2, Length[StringSplit[data, "place"]]}], Length[Cases[Flatten[#], $Failed]] == 0 & ], Length[#] == 5 &]]; That does look a bit cryptic but gives us what we want. tab[[1]] gives {10.5673, 59.8929, 13, 80, 1032.9}, wich are the gps coordinates, the temperature in Celsius, the humidity in % and the pressure in mbar. I will now propose three different representations of the data. scaled = Rescale[tab[[All, 3]]]; GeoGraphics[Table[{GeoStyling[Opacity[0.99], RGBColor[scaled[[k]], 1 - scaled[[k]], 0]], GeoDisk[{tab[[k, 2]], tab[[k, 1]]}, Quantity[20, "Kilometers"] ]}, {k,1, Length[tab]}]] which gives: ![enter image description here][9] The second representation is calculated using GeoRegionValuePlot[GeoPosition[{#[[2]], #[[1]]}] -> #[[3]] & /@ tab, PlotRange -> {0, 30}, ColorFunction -> "TemperatureMap", ImageSize -> Full] which looks like this ![enter image description here][10] Finally, the lengthy sequence of commands surface = Interpolation[{{#[[1]], #[[2]]}, #[[3]]} & /@ tab, InterpolationOrder -> 1]; cPlot = Quiet[ContourPlot[surface[x, y], {x, Min[tab[[All, 1]]], Max[tab[[All, 1]]]}, {y, Min[tab[[All, 2]]], Max[tab[[All, 2]]]}, ImagePadding -> None, ClippingStyle -> None, Frame -> None, Contours -> 60, ContourLines -> False, PlotRange -> {0, 30}, ColorFunction -> "TemperatureMap"]]; multipoly = Polygon[GeoPosition[Join @@ (EntityValue[EntityClass["Country", "Europe"], "Polygon"] /. Polygon[GeoPosition[x_]] :> x)]]; GeoGraphics[{GeoStyling[{"GeoImage", cPlot}], multipoly, Black, Opacity[1]}, ImageSize -> Full] gives this representation ![enter image description here][11] I am quite sure that with some modifications one can make a useful program out of this if one uses cloud deploy. Also, netatmo's data are updated every 30 minutes (every 5 minutes on the individual devices), so one can run a scheduled task and look at the development of the temperature. The large number of netatmo weather stations complements the data available from the Wolfram Data servers very nicely as they provide very up to date street level data. I would be glad to see a good idea of a cloud deployed service based on this or any other ideas that you might have. Cheers, Marco [1]: http://community.wolfram.com/web/bschelter [2]: https://www.netatmo.com/en-US/product/weather-station [3]: /c/portal/getImageAttachment?filename=ScreenShot2014-09-15at22.55.05.png&userId=48754 [4]: http://devices.wolfram.com/devices/netatmo-weather-station.html [5]: https://www.netatmo.com/weathermap [6]: /c/portal/getImageAttachment?filename=ScreenShot2014-09-15at22.59.02.png&userId=48754 [7]: /c/portal/getImageAttachment?filename=ScreenShot2014-09-15at22.59.37.png&userId=48754 [8]: https://dev.netatmo.com [9]: /c/portal/getImageAttachment?filename=netatmofig1.gif&userId=48754 [10]: /c/portal/getImageAttachment?filename=Netatmofig2.gif&userId=48754 [11]: /c/portal/getImageAttachment?filename=Netatmofig3.gif&userId=48754 Marco Thiel 2014-09-15T22:35:11Z https://community.wolfram.com/groups/-/m/t/456947 ![Wolfram Pi Flowers][9] ---------- I will explain how to make the time-lapse animation you can see above. **1)** Set-up your [camera module][1]. I sticked mine on a hard drive, see the first image on [my previous Data Drop post][2]. ![setup][3] **2)** Take a test shot to check that the exposure is acceptable. DeviceRead["RaspiCam",{320, 240}] **3)** Adjust the resulting image with [ImageAdjust][4]. ImageAdjust[DeviceRead["RaspiCam",{320, 240}]] ![Test shot][5] **4)** Create a new databin, and take note of its short ID: CloudConnect["email-wolframID","password" ]; bin=CreateDatabin[]; bin["ShortID"] "3GgU-jf4" **5)** Setup a [ScheduledTask][6] that adds a snapshot to your databin every 360 seconds (6minutes): intervalometer=RunScheduledTask[DatabinAdd[Databin["3GgU-jf4"], ImageAdjust[DeviceRead["RaspiCam",{320, 240}]]],360] **6)** Water your plant and wait. **7)** Check that your databin is being filled correctly [http://wolfr.am/3GgU-jf4][7] ![databin][8] **8)** Compile the animated gif: frames = Values[Databin["3GgU-jf4"]]; Export["resurrected_plant.gif", Join[frames, Reverse[frames]]] **9)** Enjoy! ![Wolfram Pi Flowers][9] **10)** To stop your scheduled task, use the function [StopScheduledTask][10]: StopScheduledTask[intervalometer] [1]: http://community.wolfram.com/groups/-/m/t/157704 [2]: http://community.wolfram.com/groups/-/m/t/453169 [3]: /c/portal/getImageAttachment?filename=setupPlant.png&userId=56204 [4]: http://reference.wolfram.com/language/ref/ImageAdjust.html [5]: /c/portal/getImageAttachment?filename=FlowerFrames.jpg&userId=56204 [6]: http://reference.wolfram.com/language/ref/RunScheduledTask.html [7]: http://wolfr.am/3GgU-jf4 [8]: /c/portal/getImageAttachment?filename=databin_filled.png&userId=56204 [9]: /c/portal/getImageAttachment?filename=Wplant.gif&userId=56204 [10]: http://reference.wolfram.com/language/ref/StopScheduledTask.html Bernat Espigulé 2015-03-11T11:50:05Z https://community.wolfram.com/groups/-/m/t/23261 I've recently started having fun with Arduino (see [b][url=http://www.arduino.cc/]www.arduino.com[/url][/b] for details).  The memory and processing speed is far below what is necessary to run the Mathematica kernel, but I wonder if an Arduino program might somehow make calls to a Mathematica kernel (running on a network-connected machine) and get results back.  Has anyone done this? David DeBrota 2012-10-19T12:17:10Z https://community.wolfram.com/groups/-/m/t/181641 Wanted to share with my kids the classical experiment on a rolling object down an incline plane using legos, arduino and Mathematica for the Raspberry Pi. Using a window valance and some lego technic pieces we proceeded to build the inclined plane platform. [img=width: 300px; height: 400px;]/c/portal/getImageAttachment?filename=inclinedplane1.JPG&userId=78214[/img] Using legos was great to allow to attach both leds and photorresistors to the inclined plane. It also allowed us to set up build a platform from where to attach a servo motor and a protractor to measure the angle of inclination. [img=width: 400px; height: 533px;]/c/portal/getImageAttachment?filename=inclinedplane2.JPG&userId=78214[/img] We'll detect when the ball reaches a certain point of the platform by the the disminution of the LED light received at the photoresistors. [img=width: 300px; height: 400px;]/c/portal/getImageAttachment?filename=8270photo(1).JPG&userId=78214[/img] The adafruit web site is a very good site to explain the details on how to connect the photoresistors and leds to the Arduino. [url=http://learn.adafruit.com/adafruit-arduino-lesson-2-leds/leds]http://learn.adafruit.com/adafruit-arduino-lesson-2-leds/leds[/url] [url=http://learn.adafruit.com/photocells/using-a-photocell]http://learn.adafruit.com/photocells/using-a-photocell[/url] As the readings of the photocells require of analog inputs, we decided to use a spare arduino we had at our disposal, and to have more fun, use XBEE modules to connect the arduino to the raspberry pi. [img=width: 300px; height: 225px;]/c/portal/getImageAttachment?filename=6471photo(2).JPG&userId=78214[/img] The following is the code at the Arduino.[code] #include <Servo.h> int servoPin = 9; int LightSensor[4]={A1,A2,A3,A4}; int current[4]={0,0,0,0}; double timers[4]={0,0,0,0}; int previous[4]={0,0,0,0}; Servo servo; int i=0; double factor=0.7; double timer = 0; int inByte =0; void setup() { Serial.begin(19200); servo.attach(servoPin); servo.write(0); delay(2000); for (i=0;i<4;i++){ previous[i]=analogRead(LightSensor[i]); } } void loop() { if(Serial.available()>0){ inByte=Serial.read(); if (inByte==65) { servo.write(90); timer=millis(); trackBall(); for (i=0;i<4;i++){ Serial.println(timers[i]); } servo.write(0); } } } void trackBall(){ int m =0; while (m<4){ current[m]=analogRead(LightSensor[m]); if (current[m]<factor*previous[m]){ timers[m]=millis()-timer; m++; } } }[/code] Mathematica code and results to follow [mcode]serial = DeviceOpen["Serial", {"/dev/ttyUSB0", "BaudRate" -> 19200}] lengths = {0., 0.175, 0.43, 0.69} ;(*Distance between light sensors in meters*) data = {};(*List to capture the time between sensors*) ping := Module[{}, DeviceWriteBuffer[serial, {"A"}]; Pause[3]; ToExpression[StringSplit[FromCharacterCode[DeviceReadBuffer[serial]]]]/1000] (*Function pings sends an "A" to the arduino to release the ball and \ collect timing*) Button["Collect Data", data = Append[data, ping]] Dynamic[tdata = Transpose@data; dataPoints = Flatten[Table[{tdata[[i, j]], lengths[[i]]}, {i, Length[lengths]}, {j, Length[data]}], 1]; lm = Fit[dataPoints, {1, x, x^2}, x]; Plot[lm, {x, -0.3, 1.2}, Epilog -> {Red, PointSize[Large], Point[dataPoints]}, AspectRatio -> 1, PlotLabel -> lm]][/mcode]Using a hollow ball, we can work out the gravity value [img=width: 440px; height: 500px;]/c/portal/getImageAttachment?filename=Untitled.png&userId=78214[/img] Using a golf ball [img=width: 500px; height: 482px;]/c/portal/getImageAttachment?filename=InclinedPlane.png&userId=78214[/img] A couple of videos of the experiment in action [url=https://www.youtube.com/watch?v=4eRZ48N3vM8]https://www.youtube.com/watch?v=4eRZ48N3vM8[/url] [url=https://www.youtube.com/watch?v=eLVPpEcyw_0]https://www.youtube.com/watch?v=eLVPpEcyw_0[/url] [url=https://www.youtube.com/watch?v=53WaEcRWY_0]https://www.youtube.com/watch?v=53WaEcRWY_0[/url] Diego Zviovich 2014-01-08T01:09:54Z https://community.wolfram.com/groups/-/m/t/90931 So the Leap Motion controller has just been released and I thought I might as well post some code that Todd Gayley and I wrote to connect the Leap Motion and all of its functionality to Mathematica! Here are the setup instructions: 1. (If you haven't already) download and install the leap motion software from [b][url=http://www.leapmotion.com/setup]leapmotion.com/setup[/url][/b] 2. Download the leap motion SDK off their developer page. 3. Connect the Leap Motion to your computer. 4. Find the file "LeapJava.jar" inside of the Leap SDK (It should be under lib.) 5. Open Mathematica and paste this in: [mcode]Needs["JLink`"]; ReinstallJava[CommandLine -> "java", JVMArguments -> "-Djava.library.path=[path to directory CONTAINING LeapJava.jar]"];[/mcode]Now put the path to "LeapJava.jar" in the indicated position, and remember this is the path to the directory containing LeapJava.jar, not the path to LeapJava.jar itself and run the code. 6. Now paste this in:[mcode]AddToClassPath["[path to LeapJava.jar]"];[/mcode]Replace the indicated area with the path to LeapJava.jar itself and run it. 7. To setup the controller, run this:[mcode]controller = JavaNew["com.leapmotion.leap.Controller"][/mcode] You should now be fully connected and ready to go!  To see if it is working you can run:[mcode]Methods[controller][/mcode]and it should return a list of all the methods under the controller. The main method you want to look at is frame[] which contains all of the information about what is going on. To see the methods under frame[] run this:[mcode]Methods[controller@frame[]] [/mcode] From here you should be able to figure things out like this: [mcode]controller@frame[]@fingers@count[][/mcode]which should count the visible fingers in the scene. Also in a final note I want mention that I was having problems accessing the fingers with this:[mcode]controller@frame[]@finger[finger number][/mcode]and so you may want to try:[mcode]controller@frame[]@fingers[]@get[finger number][/mcode]instead.  The same goes for palms. Well, if you write anything cool using this please post it back up here along with any questions you have. (I am going to try to post some of the code I have written with this soon :D ) Christopher Wolfram 2013-08-06T17:30:52Z https://community.wolfram.com/groups/-/m/t/1179035 ## Introduction ## A few weeks ago, I had the privilege of speaking with Michael Foale -- astronaut, astrophysicist, entrepreneur, and Mathematica fan -- about his recent work with the Wolfram Language on the Raspberry Pi. As an experienced pilot, Mike thought he could use the Wolfram Language's machine learning capabilities to alert pilots to abnormal or unsafe flying conditions. Using a collection of sensors attached to a Pi, the Wolfram Language's Classify function would constantly analyze things like altitude, velocity, roll, pitch, and yaw to determine whether the pilot might be about to lose control of the plane. You can read [Mike's User story here][1], his experience with [Mathematica on the Space Station Mir here][2]. and the full code for Mike's Imminent Loss Of Control Identification system, or ILOCI, [is here][3]. ## Getting the Initial Data ## Mike decided that the Raspberry Pi would be a good base for this project because of how easy it is to connect various sensors to the device. In his case, there were 3 sensors he wanted to read from: an accelerometer, an aero sensor attached to the tail, and a flex sensor attached to the rudder. All of these are attached via GPIO pins, which the Wolfram Language can communicate through. In Mike's case, he wrote a MathLink driver in C to do this, but since he began this project we have been pushing to make GPIO communication easier. Now, the Wolfram Language can read from sensors with [the DeviceOpen and DeviceRead functions][4]. If Mike were to re-do this project, that would have saved him quite a bit of time and debugging! ![Left: Prototype Pi and sensor setup. Right: ILOCI attached to a small plane for a test flight.][5] Before the Classify function can tell whether current flying conditions are normal or not, it must first learn what normal is. To do this, Mike took his Pi setup on a test-flight where he occasionally forced his plane to stall, or come close to stalling (please, do not try this for yourself!). After landing, he manually separated the sensor readings into "in family" and "out of family" moments -- that is, normal flying conditions and moments where loss of control is imminent. ## Importing the Data ## For Mike's flights, he had the Pi save data from an initial test flight to a CSV file and had Mathematica import that file to train his Classify function on. For example: datafile = FileNameJoin[{"","home","pi","Documents","training.dat"}]; data = Import[datafile]; For convenience's sake, I've embedded this same data in a notebook attached to this post, so that you can test and manipulate this data on your own as well. This data, saved under the variable "data", was divided up by Mike into the "in family" and "out of family" periods mentioned earlier: noloc1 = Take[data, {3500, 3800}]; (* Ground, engine off *) noloc2 = Take[data, {3900, 4200}]; (* Ground, engine on *) noloc3 = Take[data, {4500, 4600}]; (* Takeoff, climbing at 60 knots *) noloc4 = Take[data, {4800, 4900}]; (* Climbing, 70 knots *) noloc5 = Take[data, {5000, 5200}]; (* Climbing, 50 knots *) noloc6 = Take[data, {6200, 6300}]; (* Gliding, 42 knots *) noloc7 = Take[data, {6900, 7100}]; (* Climbing, 60 to 70 knots *) noloc8 = Take[data, {9200, 9400}]; (* Landing *) noloc9 = Take[data, {9300, 9400}]; (* Rolling out*) loc1 = Take[data, {6450, 6458}]; (* Straight stall *) loc2 = Take[data, {6480, 6484}]; (* Left stall *) loc3 = Take[data, {6528, 6534}]; (* Right stall *) loc4 = Take[data, {6693, 6700}]; (* Right Yaw *) loc5 = Take[data, {6720, 6727}]; (* Left Yaw *) You might notice that the list above doesn't cover the entire dataset. That's because some of the data is kept aside for verification, to ensure the Classify function is recognizing "in family" and "out of family" moments correctly. This is a very important part of training any artificially intelligent program! Below are some plots of the above datasets, just to get a visual feel for what the Pi is "seeing" during a flight. ListLinePlot[Transpose[noloc4], PlotLegends -> {"AccelerationZ", "AccelerationY", "AccelerationX", "RudderDeflection", "ElevatorDeflection", "TailYawRelative", "TailAngleAttackRelative", "TailAirspeedRelative"}, Frame -> True] ![Sensor readings while climbing at 70 knots][6] ListLinePlot[Transpose[loc1], PlotLegends -> {"AccelerationZ", "AccelerationY", "AccelerationX", "RudderDeflection", "ElevatorDeflection", "TailYawRelative", "TailAngleAttackRelative", "TailAirspeedRelative"}, Frame -> True] ![Sensor readings while stalled][7] These plots give us a good idea of what happens at some specific instances, but what does the flight as a whole look like? Recall from above that takeoff begins around datapoint 4500, the first stall around 6450, landing around 9200, and the rollout ends around 9400. According to Mike, the rudder movement around 11000 is simply moving the rudder to steer the aircraft back into the hangar. ListLinePlot[Transpose[data], PlotLegends -> {"AccelerationZ", "AccelerationY", "AccelerationX", "RudderDeflection", "ElevatorDeflection", "TailYawRelative", "TailAngleAttackRelative", "TailAirspeedRelative"}, Frame -> True, ImageSize -> Large] ![Sensor readings from whole flight][8] ## Training the Classifier Data ## After separating the data, Mike created Rules to label these moments as "Normal", "Stall Response", "Yaw Response Left", and "Yaw Response Right"; respectively "N", "D", "L", and "R". These Rules teach Classify which patterns belong to which label, so that later on Classify can tell what the appropriate label is for incoming, unlabeled data. Note that the ConstantArray functions simply repeat the data 10 times so the "out of family" moments are not overshadowed by the "in family" ones. normal = Join[noloc1, noloc2, noloc3, noloc4, noloc5, noloc6, noloc7, noloc8]; normalpairs = Rule[#1, "N"] & /@ normal; down = Flatten[ConstantArray[Join[loc1, loc2, loc3], 10], 1]; downpairs = Rule[#1, "D"] & /@ down; left = Flatten[ConstantArray[loc4, 10], 1]; leftpairs = Rule[#1, "L"] & /@ left; right = Flatten[ConstantArray[loc5, 10], 1]; rightpairs = Rule[#1, "R"] & /@ right; Finally, with the data segmented and labeled, Mike created a ClassifierFunction able to take live data from the sensors, then quickly tell the pilot when something is wrong and how to correct it. classify = Classify[Join[normalpairs, downpairs, leftpairs, rightpairs], Method -> {"NeuralNetwork", PerformanceGoal -> "Quality"}] ClassifierInformation[classify] ![Output of the ClassifierInformation function][9] Let's use this ClassifierFunction on a couple of the data points that we set aside earlier, to be sure the ClassifierFunction is correct, and to show how a ClassifierFunction is used. nolocVerify = Take[data, {4600, 4700}]; locVerify = Take[data, {6587, 6595}]; classify[nolocVerify] classify[locVerify] ![Results of Mike's classifier function on untrained data][10] Recall that the ClassifierFunction returns one of 4 labels for each data point: "N" for normal, "L" for left yaw response, "R" for right yaw response, and "D" for down response. Mike's ClassifierFunction perfectly recognizes the first verification set, and comes close to being perfect on the second set. Not bad, given how little data he had to train it with! This use-case gives a pretty good idea of how the ClassifierFunction works, but for a more in-depth example you can watch [this video from Wolfram Research][11]. ## Using the ClassifierFunction on Real Data ## At the moment I am neither a pilot nor the owner of an airplane, so performing a live test of Mike's ClassifierFunction would be a bit challenging. Fortunately, the Wolfram Language makes it easy to take Mike's recorded data and re-run it as though the ClassifierFunction were receiving this data in real time. First, we need to import the data that Mike recorded in his test flight. We actually did this already, when we called Import on the file containing the data. Next we'll import the timing data from the test flight. This is the absolute time in seconds and microseconds from the beginning and end of the flight, so subtracting the beginning time from the end time gives us the total time of the flight. With the times and the data known, we can determine how often the Pi read in measurements on the test flight. We will use that frame time to "replay" the test flight accurately. Mike's ILOCI system records timing information that we can Import from, but again I'll include it here for the sake of convenience: timing = {1466861802, 255724, 1466867826, 498879, 11660}; dataseconds = timing[[3]] - timing[[1]]; datausecs = timing[[4]] - timing[[2]]; frametime = (dataseconds + datausecs*1.0*^-6)/(Length[data] - 1) Now, let's use that frame length to create an animated output of the ClassifierFunction. This goes through the whole dataset and runs at the same rate as the Pi did. If we were actually flying an airplane, this would show us what the Pi thinks about our current environment, whether our motion is "in-family" or "out-of-family". Animate[ classify[ data[[frame]] ], {frame, 1, Length[data], 1}, AnimationRate -> (1/frametime), FrameLabel -> {{None, None}, {None, "Full Flight Playback"}} ] This would take a little over 90 minutes to run, and the non-normal readings go by fairly quickly, so let's focus in on some of the more interesting sections. First, let's see the straight stall that was reserved for verification. Again, the ClassifierFunction was not trained using this set -- it is brand new as far as the Classifier is concerned. Animate[ classify[ data[[frame]] ], {frame, 6580, 6595, 1}, AnimationRate -> (1/frametime), FrameLabel -> {{None, None}, {None, "Stall Playback"}} ] ![Animate of the stall playback][12] Notice that the Classifier constantly reads the situation and updates it's classification accordingly. Next let's look at one of the verification sets where everything was normal. It should read as "N" for the entire set: Animate[ classify[ data[[frame]] ], {frame, 6300, 6400, 1}, AnimationRate -> (1/frametime), FrameLabel -> {{None, None}, {None, "Normal Playback"}} ] ![Animate of the normal playback][13] ## Conclusion ## If we go back and count, there is about 60 lines of code. That's all that was needed to create plots, animations, and a neural net-based Classifier that might one day save lives. This is what makes the Wolfram Language such a powerful choice for projects like this -- quick prototyping and a plethora of built-in functions allows users to create some truly unique projects, regardless of experience or expertise. We hope that this will inspire you to start experimenting with your own ideas with the Wolfram Language! [1]: http://www.wolfram.com/mathematica/customer-stories/training-a-neural-network-to-think.html [2]: http://www.wolfram.com/mathematica/customer-stories/astronaut-places-a-customer-service-call-to-wolfram-research-from-space-station-mir.html [3]: https://github.com/cfoale/ILOCI [4]: http://reference.wolfram.com/language/guide/UsingConnectedDevices.html [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=PiAndPlaneSetup.png&userId=313765 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=LinePlot1.png&userId=313765 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=LinePlot2.png&userId=313765 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=LinePlot3.png&userId=313765 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ClassifierInfo.png&userId=313765 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ClassifierResults.png&userId=313765 [11]: https://youtu.be/ce6UptPYKxI?t=20m40s [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=StallPlayback.gif&userId=313765 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=NormalPlayback.gif&userId=313765 Brett Haines 2017-09-07T18:16:06Z https://community.wolfram.com/groups/-/m/t/992466 This project was part of a Wolfram Mentorship Program. The classification of human motions based on patterns and physical data is of great importance in developing areas such as robotics. Also, a function that recognizes a specific human motion can be an important addition to artificial intelligence and physiological monitoring systems. This project is about acquiring, curating and analyzing experimental data from certain actions such as walking, running and climbing stairs. The data taken with the help of an accelerometer needs to be turned into an acceptable input for the Classify function. Finally, the function can be updated with more data and classes to make it more efficient and whole. **Algorithms and procedures** The data for this project was acquired by programming an Arduino UNO microprocessor with a Raspberry Pi computer, using Wolfram Language. An accelerometer connected to the Arduino sent measurements each time it was called upon, and Mathematica in the Raspberry Pi collected and uploaded the data. The raw data had to be processed for it to be a good input for the classify function. First, it was transformed into an spectrogram (to analyze the frequency domain of the data). Then, the spectrogram's image was put through the IFData function which filters out some of the noise, and finally the images were converted into numerical data with the UpToMeasurements function (main function: ComponentMeasurements). This collection numerical data was put in a classify function under six different classes (standing, walking, running, jumping and waving). *The IFData function and the UpToMeasurements functions were sent to me by Todd Rowland during the Mentorship. Both functions will be shown at the end of this post. **Example visualization** The following ListLinePlot is an extract from the jumping data ![Example data][1] Next, the data from the plot above is turned into a spectrogram by the function Spectrogram, i.e.: spectrogramImage = Spectrogram[jumpingData, SampleRate -> 10, FrameTicks -> None, Frame -> False, Ticks -> None, FrameLabel -> None] ![Example jumping data spectrogram][2] Finally, all the spectrogram images are used as input for the UpToMeasurements function, along with some properties for the ComponentMeasurements function: i.e: numericalData = N@Flatten[ UpToMeasurements[ spectrogramImage, {"EnclosingComponentCount", "Max", "MaxIntensity", "TotalIntensity", "StandardDeviationIntensity", "ConvexCoverage", "Total", "Skew", "FilledCircularity", "MaxCentroidDistance", "ExteriorNeighborCount", "Area", "MinCentroidDistance", "FilledCount", "MeanIntensity", "StandardDeviation", "Energy", "Count", "MeanCentroidDistance"}, 1]] Which outputs a list of real numbers, one for each of the properties: {0., 1., 1., 1., 1., 19294.9, 0.222164, 0.985741, 31011.8, 15212.5, \ 9624.42, -0.0596506, 0.724527, 190.534, 0., 42584.5, 0.364667, \ 42584., 0.453101, 0.315209, 0.232859, 0.169549, 0.00909654, 42584., \ 98.7136} These numbers are grouped in a nested list which contains data for all 5 human motions. All the data is lastly classified in a classifier using the Classify function. After several combinations of both properties and data sets, I was able to produce classifier functions with an accuracy of 91%, and a total size of 269kb. ------------------------------------------------------------ **Attempt on building a classify function using image processing** On the other hand, the image processing capabilities of Mathematica lets us extract data from images, hence it should be possible to create a classifier which recognizes the moving patterns in the frames of a video. First, I had to take the noise out of every image, this proved to be troublesome, since the background can vary greatly between video samples. Then, I binarized the image in order to isolate the moving particles in each frame, and extract their position with ImageData. Lastly, a data set can be formed from all the analyzed frames; this data can essentially be used in the same way as the accelerometer's, but the classifier was unsuccessful in separating the samples accurately. This was mainly because the accelerometer's data is taken at a constant rate and very precisely, whereas the images depend on the camera's frame rate, and many other external factors. This is what made the data different enough to fail being classified with accuracy. Furthermore, if a big dataset is made from videos of people performing certain actions, the data processing can follow similar steps as the ones explained in this report. Thus producing a similar classifier function. This can further increase the functions accuracy, but the process needs an algorithm that can effectively trace the path of "a particle" that moves through each of the frames of the video, and extract precise velocity data from said movement. ------------------------------------------------------------ Conclusively, the classify function is working very well with the data provided, its accuracy is about 91% for the SupportVectorMachine method. This is a very good result for the human motion classifier. The next step is to add more classes to the function, and test the classifier with data acquired from different sources, such as another accelerometer and various videos of human motion footage. ----------------------------------------- **Code:** - UpToMeasurements function UpToMeasurements[image_,property_,n_]:=MaximalBy[ComponentMeasurements[image,"Count"],Last,UpTo[n]][[All,1]]/.ComponentMeasurements[image,property] *Note: This function simplifies the exploration of properties to input in ComponentMeasurements, also, it outputs a usable list of numerical data retrieved from a given group of images. - IFData function: imagefunctions=<|1-> (EntropyFilter[#,3]&), 2-> (EdgeDetect[EntropyFilter[#,3]]&), 3->Identity, 4-> (ImageAlign[reference110,#]&), 5-> (ImageHistogram[#,FrameTicks->None,Frame->False,FrameLabel->None,Ticks->None]&), 6-> (ImageApply[#^.6&,#]&), 7-> (Colorize[MorphologicalComponents[#]]&), 8-> (HighlightImage[#,ImageCorners[#,1,.001,5]]&), 9-> (HighlightImage[#,Graphics[Disk[{200,200},200]]]&), 10-> ImageRotate, 11-> (ImageRotate[#,45Degree]&), 12->(ImageTransformation[#,Sqrt]&), 13->(ImageTransformation[#,Function[p,With[{C=150.,R=35.},{p[[1]]+(R*Cos[(p[[1]]-C)*360*2/R]/6),p[[2]]}]]]&), 14->( Dilation[#,DiskMatrix[4]]&), 15->( ImageSubtract[Dilation[#,1],#]&), 16-> (Erosion[#,DiskMatrix[4]]&), 17-> (Opening[#,DiskMatrix[4]]&), 18->(Closing[#,DiskMatrix[4]]&), 19->DistanceTransform, 20-> InverseDistanceTransform, 21-> (HitMissTransform[#,{{1,-1},{-1,-1}}]&), 22->(TopHatTransform[#,5]&), 23->(BottomHatTransform[#,5]&), 24-> (MorphologicalTransform[Binarize[#],Max]&), 25-> (MorphologicalTransform[Binarize[#],"EndPoints"]&), 26->MorphologicalGraph, 27->SkeletonTransform, 28->Thinning, 29->Pruning, 30-> MorphologicalBinarize, 31-> (ImageAdjust[DerivativeFilter[#,{1,1}]]&), 32-> (GradientFilter[#,1]&), 33-> MorphologicalPerimeter, 34-> Radon |>; reference110=BlockRandom[SeedRandom["110"];Image[CellularAutomaton[110,RandomInteger[1,400],400]]]; IFData[n_Integer]:=Lookup[imagefunctions,n,Identity] IFData["Count"]:=Length[imagefunctions] IFData[All]:=imagefunctions *Note: This function groups together several image filtering fuctions; it was used to simplify the exploration of functions to be used in the classifier. **This function was written by the the Wolfram team, but was slightly modified for this project. - propertyVector function (this function automatically evaluates all the prior necessary code needed to create the classify functions): propertyVector[property_]:={walkingvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@walk); jumpingvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@jump); standingvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@stand); runningvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@run); wavingvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@wave); stairsvector=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@stairs); walkingvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@testwalk); jumpingvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@testjump); standingvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@teststand); runningvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@testrun); wavingvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@testwave); stairsvectortest=N@Flatten[UpToMeasurements[#,property,1]]&/@IFData[6]/@(Spectrogram[#,SampleRate->10,FrameTicks->None,Frame->False,Ticks->None,FrameLabel->None]&/@teststairs);} Training:=trainingSet=<|"walking"->walkingvector,"running"->runningvector, "standing"-> standingvector, "jumping"-> jumpingvector, "waving"-> wavingvector, "stairs"-> stairsvector|>; Test:=testSet=<|"walking"->walkingvectortest,"running"->runningvectortest, "standing"-> standingvectortest, "jumping"-> jumpingvectortest, "waving"-> wavingvectortest, "stairs"-> stairsvectortest|>; - Example code for the acceleration data acquisition from image processing: images=Import["$path"] motionData= Count[#,1]&/@ (Flatten[ ImageData[Binarize[ImageSubtract[ImageSubtract[#[[1]],#[[2]]],ImageSubtract[#[[2]],#[[3]]]]]]&/@ Partition[images,3,1],1]) *Note: before this code can be used, the backgrounds of the frames of the video have to be removed, and the image has to be binarized as much as possible (some examples will be shown in the next section). - Example code for the retrieval of raw data from DataDrop: rawData=Values[Databin["Serial#", {#}]]; data=Flatten[rawData["(xacc/yacc/zacc)"]]; --------------------------------- **Please feel free to contact me or comment if you are interested in the rest of the code ( uploading the C code to the Arduino, the manufacturer's code for the accelerometer, C code switch that lets Mathematica communicate with the Arduino, and the Wolfram Language code used to start each loop in the switch that retrieves data ). Also, I could send the classify function, or any other information that I might have left out; all suggestions welcome. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=602285 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=602285 Pablo Ruales 2017-01-11T01:15:04Z https://community.wolfram.com/groups/-/m/t/825781 Just benchmarked my RPI3 vs RPI2 Model B V1.1 with the built in Mathematica Benchmark[]. I was quite surprised to see the benchmark significantly decline. RPI3 had benchmark of 0.03 and time of 465 while the RPI2 had benchmark of 0.045 and time of 305 sec. On the RPI3, two tests dominated the time, matrix multiply and solving linear systems which took only slightly less than the entire benchmark on RPI2. Both systems were fully updated. I wonder if Wolfram could comment on this : do they feel it is the hardware or this might be improved in a future release?. As it is it is difficult to use Mathematica on an RPI and I was looking to RPI3 to improve this. Thanks david p 2016-03-19T02:02:04Z https://community.wolfram.com/groups/-/m/t/1098055 Recently, I've been working on a project called Mandy, an interactive periodic table that displays different element trends depending on what the user says to her. The Raspberry Pi/Mathematica duo has played a very strong role in all aspects of the project design and implementation. I'm not allowed to provide too many details about the project (not because it's secret, but because I am moving in a month and my wife has ordered that all of my toys and hobbies get packed or I risk them being left behind). Therefore, I [created a teaser trailer][2] showcasing the design with a promise to provide more details when I get settled in my new location. [![enter image description here][3]][2] [![enter image description here][4]][2] That said, I wanted to highlight a couple of areas where Mathematica played a pivotal role in the the project. My goal was to create a periodic table display (approximately 24x18") that has a RGB LED for each element. The color of the element would then be based on a given periodic trend (atomic radius, weight, ionization energy, etc.). Controlling 118 3-color LEDs turns out to be very easy when the LEDs are Neopixels and the controller is an Arduino. Because I envisioned a wall display, I wanted the user to interact with the piece in some fashion other than a mouse or keyboard. I have started working on a voice recognition system based on pocketsphinx which I call [Simplified Command and Control - SCAC](https://bobthechemist.com/2015/12/prelude-to-simplified-command-and-control/) but since it is a C/Python project, I'll leave that component for another forum. In summary, the final project requires that SCAC (a python script) interact with Mathematica (data manipulation) that then speaks to an Arduino via a serial connection. But Mathematica played a big role prior to the implementation as well: ## Design - With access to `ElementData`, I was able to very quickly create an image that could be sent to a laser cutter for carving the birch-wood frame and the acrylic element pieces. o = Table[ Map[ElementData[i, #] &, {"AtomicNumber", "Symbol", "Period", "Group"}], {i, 118}]; (* Need to massage the f-block elements,giving them fake groups and \ periods.Making their periods 9 and 10 with their groups 3 through 16 \ works nicely *) o[[57 ;; 70]] = Module[{i = 1, rep = Range[3, 16], tmp}, tmp = Select[o, 57 <= #[[1]] <= 70 &] /. {6 -> 9}; tmp /. {Missing["NotApplicable"] :> rep[[i++]]}]; o[[89 ;; 102]] = Module[{i = 1, rep = Range[3, 16], tmp}, tmp = Select[o, 89 <= #[[1]] <= 102 &] /. {7 -> 10}; tmp /. {Missing["NotApplicable"] :> rep[[i++]]}]; o = o /. {"Uut" -> "Nh", "Uup" -> "Mc", "Uus" -> "Ts", "Uuo" -> "Og"}; piece = Polygon[{{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}]; Clear[box] box[array_] := Module[{x, y, m = 10}, {x, y} = array[[{4, 3}]]; {FaceForm[None], EdgeForm[Thin], Rectangle[{m x, m (10 - y)}, {m (x + 1), m (11 - y)}] (*Inset[Style[array[[2]],10,Bold],{m (x+0.5),m(10.7-y)}], Inset[Style[array[[1]],8],{m(x+0.5),m(10.2-y)}]*)} ] makePiece[pt_] := GeometricTransformation[ GeometricTransformation[piece, {pt[[1]], 10 - pt[[2]]}*{1.2, 1.2}], ScalingTransform[{10, 10}]]; ptpuzzle = Graphics[{EdgeForm[Thin], FaceForm[None], makePiece /@ o[[All, {4, 3}]]}]; Clear[letters2] letters2[array_] := Module[{x, y, m = 10}, {x, y} = array[[{4, 3}]]; {FaceForm[None], EdgeForm[Thin], (*Rectangle[{m x,m(10-y)},{m(x+1),m(11-y)}]*) Inset[Style[array[[2]], 8, Bold, FontFamily -> "Cambria Math"], {m (x + 0.45), m (10.55 - y)}*{1.2, 1.2}], Inset[Style[array[[1]], 6, FontFamily -> "Cambria Math"], {m (x + 0.45), m (10.2 - y)}*{1.2, 1.2}]} ] ptpuzzlelt = letters2 /@ o // Graphics; Show[ptpuzzlelt, ptpuzzle, ImageSize -> 600] ![enter image description here][5] There are easier ways to create a periodic table, but the above method allowed me to create SVG images suitable for tweaking in vector graphics software and cut with the laser cutter. ## Data Naturally, `ElementData` can provide the physical and chemical properties of the elements that I want to display on Mandy. There's nothing inspiring about this code (grabbing the data, rescaling it and converting values to a corresponding color scheme). Mathematica provided a useful platform for sandboxing what the trends would look like: ![enter image description here][6] ## Implementation Since speech recognition (SCAC) is written in Python, I needed to control a Mathematica Kernel from within Python. I've [played with this idea before](https://github.com/bobthechemist/python-mathlink) which results in a functioning platform that is error-intolerant (READ: not ready for prime time). Communication with the Arduino is done through a "Serial" device instead of the "Arduino" device because I started this project before the latter was working. That said, it was pretty straightforward to create a Mathematica Package that (a) opens serial communication with the Arduino, (b) Reads in the element-LED data (c) sends a command to the Arduino to light the LEDs. I plan to post more details about the project, including code and design pictures, in due time. See [my website](https://bobthechemist.com/2017/05/mandy-the-periodic-table-teaser/) for updates. RIght now, it sounds like I've used up my daily allocation of blogging time and have to go pack some boxes. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=trends.gif&userId=61884 [2]: https://www.youtube.com/watch?v=eI-IgJ3n_RU [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-08-04at7.37.04AM.png&userId=11733 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-08-04at7.37.59AM.png&userId=11733 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture.JPG&userId=61884 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=trends.gif&userId=61884 BoB LeSuer 2017-05-18T15:11:29Z https://community.wolfram.com/groups/-/m/t/553861 Yesterday [IFTTT][1] (IF This Then That) released the [Wolfram Data Drop Channel][2]. This is a BIG step forward in making the data from the Internet of Things computable. Currently there are more than [150 trigger channels][3] that can be connected to [Data Drop][4]. Let's take a look at one of those channels: [Numerous][5]. In this post I'll show you how to get a Numerous recipe running in a few simple steps. - Sign in to [https://ifttt.com][6]. Go to My Recipes. Click "Create Recipe" ![Click Create Recipe][7] - Step 1: Select the Numerous Trigger Channel ![Choose Trigger][8] - Step 2: Select the trigger that fires every time a number changes by any amount ![chooseType][9] - Step 3: Select the number that you want to track, elevation in my case ![Select number][10] - Step 4: Select Wolfram Data Drop as Your Action Channel ![then action][11] ![data drop channel][12] - Step 5: Select "Add entry" Action ![add entry][13] - Step 6: Complete Action Fields ![action fields][14] Use the Wolfram Language function [CreateDatabin][15] to provide a name, and to specify that we want the values of the entries to be interpreted as a physical quantities (feet in this case). bin = CreateDatabin[<|"Name" -> "My Elevation"|>, "Interpretation" -> {"elevation" ->Restricted["StructuredQuantity","Feet"]}]; bin["ShortID"] **"6F9_LE8T"** - Copy-paste this ID - Write *elevation=* and select the ingredient **FormattedValue**. ![ingredient][17] elevation={{FormattedValue}} - Step 7: Create and Connect ![create][18] Voilà! ====== ![Numerous recipe][19] Now you can take an insight of the elevation measurements with [Wolfram|Alpha][20] by entering *Data drop* along with your databin's *ID*. **Data drop 6F9_LE8T** in my case. ![WA][21] Or you can access this data directly from the Wolfram Language: DateListPlot[Databin["6F9_LE8T"], Filling -> Bottom, FillingStyle -> LightBrown] ![WLelevation][22] Please, feel free to share your own recipes below. Enjoy! [1]: https://ifttt.com/wtf [2]: https://ifttt.com/wolfram_data_drop [3]: https://ifttt.com/channels [4]: https://datadrop.wolframcloud.com/ [5]: https://ifttt.com/numerous [6]: https://ifttt.com [7]: /c/portal/getImageAttachment?filename=createRecipe.png&userId=56204 [8]: /c/portal/getImageAttachment?filename=1.png&userId=56204 [9]: /c/portal/getImageAttachment?filename=2v.png&userId=56204 [10]: /c/portal/getImageAttachment?filename=2.png&userId=56204 [11]: /c/portal/getImageAttachment?filename=3.png&userId=56204 [12]: /c/portal/getImageAttachment?filename=3v.png&userId=56204 [13]: /c/portal/getImageAttachment?filename=4.png&userId=56204 [14]: /c/portal/getImageAttachment?filename=6v1.png&userId=56204 [15]: https://reference.wolfram.com/language/ref/CreateDatabin.html [16]: /c/portal/getImageAttachment?filename=6v4.png&userId=56204 [17]: /c/portal/getImageAttachment?filename=6v5.png&userId=56204 [18]: /c/portal/getImageAttachment?filename=7.png&userId=56204 [19]: /c/portal/getImageAttachment?filename=recipe.png&userId=56204 [20]: https://www.wolframalpha.com/input/?i=Data+drop+6F9_LE8T [21]: /c/portal/getImageAttachment?filename=WAelev.png&userId=56204 [22]: /c/portal/getImageAttachment?filename=WLelevation.png&userId=56204 Bernat Espigulé 2015-08-26T16:55:04Z https://community.wolfram.com/groups/-/m/t/408056 Learning to code and thinking computationally is becoming more and more popular. I’ve seen it filter down into the elementary schools. That’s why I didn’t hesitate when I had the opportunity to volunteer at [Kenwood Elementary school][1]. Kenwood is transitioning to becoming a computational lab school, where programming is as common as writing. I helped out at their afterschool program Tech Time, which is supported by the school and the University of Illinois and had a demo at their tech fair. We’ve all seen the wonders Mathematica and the Wolfram Language have at the industry, university and high school levels. But what about at the elementary level? The school had access to four Raspberry Pis and with the help of the University, was able to get all the necessary hardware accessories. For the after-school program, I created a series of lesson plans (lasting about 30 minutes each) to introduce the Wolfram Language and get them familiar with the Raspberry Pi. The overall goal of the lessons was to use the RPi with a button and LED light to blink Morse Code. Overview of the lessons - Lesson 1: Introducing the Raspberry Pi - Lesson 2: Powering up and Introducing Wolfram Language - Lesson 3: Working with Variables - Lesson 4: Connecting to hardware - Lesson 5: Morse Code with the Raspberry Pi Here is the setup that I used on the Raspberry Pi: ![morse code setup for raspberry pi and wolfram language][2] Since I was working with elementary school students (4th and 5th graders mostly), I felt the notebook interface was more forgiving than the command line. I had them start up Mathematica as root in order for Mathematica to be able to communicate with the hardware. In the command line, start Mathematica as root: sudo mathematica You can see in the attached notebooks what I used for the various lessons, but to blink the LED light on and off, I used the following: n= True; While[n, inv=DeviceRead[“GPIO”,4]; While[inv=={4->1},inv=DeviceRead[“GPIO”,4]]; DeviceWrite[“GPIO”,17->1]; While[inv=={4->0},inv=DeviceRead[“GPIO”,4]]; DeviceWrite[“GPIO”,17->0]; ]; Although there were some minor user errors that we needed to troubleshoot, the afterschool workshops went great. Students didn’t seem to have any problems with the language and wanted to know more. It was great to see them coming up with words to turn into Morse Code…words generally focused on the mildly crude :) For each lesson, I briefly went over what each function did in the notebook. My main focus was to get them playing around with the language. For example in lesson 2, I had the students practice evaluating code by taking their name and jumbling the letters. They loved doing this and kept putting in different words to see what the outcome would be…again words generally focused on the mildly crude. In addition to the weekly afterschool workshops, Kenwood held a Saturday Tech fair at the school and invited me to participate. The added challenge to this arrangement was that the students I was going to be working with had never used a text-based programming language or seen a Raspberry Pi before. For the event, I set up two demos: Talk in Morse Code and Create a Stop Motion Video. My strategy was to have the kids use printouts of the Fritzing diagrams to “put-together” the Raspberry Pi accessories and then have them evaluate Wolfram Language code snippets. Here was my setup: ![tech fair demo station for raspberry pi and wolfram language][3] I used the same setup for the Morse Code demo as I did in the workshop. Here is the setup for the stop motion demo: ![stop motion setup for raspberry pi and wolfram language][4] Not going to lie, I was a little nervous. But low and behold, I was completely busy for the full two hours showing students and parents how to setup the Raspberry Pi and to run the code. The parents were excited to see their children “getting their hands dirty” with the hardware and the software. They were especially impressed to see that only in a short amount of code you could generate a movie! I had a second graders setup the RPi, run the code I had for them, then start asking questions about changing the code! It was fantastic. Here are some students working on the Morse Code setup. A moment before, the one in the pink was giving me the “I got this…don’t need your help” look. :) ![kenwood students with the raspberry pi and wolfram language][5] Here is the code that I used for the Stop Motion demo. Again first running Mathematica as root in the command line: sudo mathematica To get the first image for the movie: listImages={DeviceRead["RaspiCam"]} Get the additional images for the movie: n=1; While[n<5, input=DeviceRead["GPIO",4]; While[input=={4->1},input=DeviceRead["GPIO",4]]; image=DeviceRead["RaspiCam"]; listImages=Append[listImages,image]; While[input=={4->0},input=DeviceRead["GPIO",4]]; n++; ] To see the list of images: listImages To turn the images into a movie, use the function ListAnimate: ListAnimate[listImages] [Here][6] is a link to download all my materials. The workshop materials (5 lessons worth) in addition to the materials I used for the 2 demos at the Tech fair. I’m a teacher first and a programmer second, so any comments that you have to improve or extend the activity would be fantastic! I had a great time at Kenwood and hope to have another opportunity like this in the future. Also wanted to give a special thanks to the folks at Kenwood Elementary school and the University of Illinois for all their help. [1]: http://www.champaignschools.org/schools/home/?id=15 [2]: /c/portal/getImageAttachment?filename=image1.png&userId=21124 [3]: /c/portal/getImageAttachment?filename=image2.png&userId=21124 [4]: /c/portal/getImageAttachment?filename=image3.png&userId=21124 [5]: /c/portal/getImageAttachment?filename=image4.png&userId=21124 [6]: http://wolfr.am/299nDmYx Adriana O'Brien 2014-12-15T17:38:03Z https://community.wolfram.com/groups/-/m/t/453169 Yesterday, [Stephen Wolfram announced][1] the release of this great solution for storing and sharing data coming from sensors, devices, programs, humans or anything else: the [Wolfram Data Drop][2]. I think this is a turning point; it completely changes the game on how I've been interacting with streams of data. In this post I want to share with you three ideas that I've been exploring using the [Raspberry Pi 2][3], which, by the way, it runs Mathematica about 10x faster than its predecessors! ![Data Drop on the Raspberry Pi][4] ![enter image description here][5] ![enter image description here][6] The first idea that came to my mind was to revisit some of the experiments I had carried out in the past, like this [home alarm system][7]. In a matter of minutes, I was able to set up an activity tracker for my home's hall. Every time I pass by, the [PIR motion sensor][8] adds a 1 to the "mov" variable that is being dropped to [this databin][9] every 20 minutes. Check it out in [W|A][10], it's live and growing! [== Data drop 3v1UbpOM][11] ![My home hall's activity][12] ![Periodic entries][13] This is such a great thing, that dataset is just about me but it could be monitoring whatever you want, like your cat's crazy habits. For this example the data is being logged periodically but you could set it up in an event-based manner. Like here, whenever a movement is detected, it triggers the [RaspiCam][15] and it sends the snapshot to the following databin: ![RaspiCam Databin][16] ![Cumulative Activity Plot][17] What about making a several days long time-lapse of you? ![Daily work at home][18] Or what about using other sensors? The possibilities are just endless! Finally, let me end up with the following collaborative activity for the classroom. Here is how you can carry it out. First, you create a public databin to add two different names of animals that the students will enter: CreateDatabin[ "Interpretation" -> {"animal1" -> "Animal", "animal2" -> "Animal"}, <|"Name" -> "Classroom Zoo"|>] Then, ask your students to submit their favorite animals' names, using the web-based platform http://wolfr.am/3zCzVgPJ ![Add new entry][19] Their individual entries will ended up generating things similar to this amazing [Graph][20]! data = Values[Databin["3zCzVgPJ"]]; pairs = Apply[Rule, Drop[Transpose[{data["animal1"], data["animal2"]}], 9], {1}] ![Name pairs][21] pics = Map[# -> #["Image"] &, Union[Flatten[Drop[Transpose[{data["animal1"], data["animal2"]}], 9]]]]; style ={ VertexSize->1.2,EdgeStyle->Directive[Arrowheads[{{.02,.6}}],Hue[.4,1,.3]],VertexShape->pics}; Graph[pairs, style, ImageSize -> 900] ![Animals Graph][22] Please, give [it a try][23]. Later, we will see what the giant graph ends up looking like. Or even more fun, share with us your ideas or databins that you want to be filled out collaboratively! [1]: http://blog.wolfram.com/2015/03/04/the-wolfram-data-drop-is-live/ [2]: https://datadrop.wolframcloud.com/ [3]: http://www.wolfram.com/raspberry-pi/ [4]: /c/portal/getImageAttachment?filename=RaspberryPi_Data_Drop.png&userId=56204 [5]: /c/portal/getImageAttachment?filename=raspberry-pi-01.png&userId=56204 [6]: /c/portal/getImageAttachment?filename=raspberry-pi-02.png&userId=56204 [7]: http://community.wolfram.com/groups/-/m/t/226163 [8]: http://www.adafruit.com/products/189 [9]: http://wolfr.am/3v1UbpOM [10]: https://www.wolframalpha.com/input/?i=Data%20drop%203v1UbpOM [11]: https://www.wolframalpha.com/input/?i=Data%20drop%203v1UbpOM [12]: /c/portal/getImageAttachment?filename=activity.png&userId=56204 [13]: /c/portal/getImageAttachment?filename=entries.png&userId=56204 [14]: /c/portal/getImageAttachment?filename=MyHomeHallActivity.png&userId=56204 [15]: http://community.wolfram.com/groups/-/m/t/157704 [16]: /c/portal/getImageAttachment?filename=HomeActivity.jpg&userId=56204 [17]: /c/portal/getImageAttachment?filename=cumulativePlot.png&userId=56204 [18]: /c/portal/getImageAttachment?filename=timelapse_Bernat.gif&userId=56204 [19]: /c/portal/getImageAttachment?filename=inputDD.png&userId=56204 [20]: http://reference.wolfram.com/language/ref/Graph.html [21]: /c/portal/getImageAttachment?filename=ClassZoo.jpg&userId=56204 [22]: /c/portal/getImageAttachment?filename=AnimalsGraph.jpg&userId=56204 [23]: http://wolfr.am/3zCzVgPJ Bernat Espigulé 2015-03-05T15:01:41Z