https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Raspberry Pi sorted by most viewed. https://community.wolfram.com/groups/-/m/t/157461 This post shows how to build a simple GPS tracker with the Wolfram Language on a Raspberry Pi. To recreate this experiment you will need the following hardware (in addition to the Raspberry Pi itself): [list] [*][url=http://www.adafruit.com/products/746]Ultimate GPS Breakout[/url] [*][url=http://www.adafruit.com/products/954]USB to TTL serial cable[/url] [*][url=http://www.adafruit.com/products/954][/url][url=http://www.adafruit.com/products/64]Half-size bread board[/url] [*][url=http://www.adafruit.com/products/758]Male/male jumper wires[/url] [/list]Plug the GPS module into the breadboard as shown and connect red to VIN, black to GND, green to RX and white to TX, using the jumper wires and the USB to TTL serial cable. Plug the USB end of the cable into the Raspberry Pi (powered down). Power up your Raspberry Pi. [img=width: 512px; height: 384px;]/c/portal/getImageAttachment?filename=1-out.jpg&userId=11733[/img] The GPS module starts to transmit data shortly after power up and will continue to do so until it is unplugged from a power source. In a terminal start the Wolfram Language using the following command: [code]> wolfram Wolfram Language (Raspberry Pi Pilot Release) Copyright 1988-2013 Wolfram Research Information & help: wolfram.com/raspi In[1]:= [/code] You can now open the serial port using the [url=reference.wolfram.com/language/ref/DeviceOpen.html]DeviceOpen [/url]by entering: [mcode]serial = DeviceOpen["Serial",{"/dev/ttyUSB0","BaudRate"->9600}] [/mcode] This returns a DeviceObject which can be used to read GPS data from. In this case we use [url=http://reference.wolfram.com/language/ref/DeviceReadBuffer.html]DeviceReadBuffer [/url]to read all available GPS data that has been generated up to this point: [mcode]data = DeviceReadBuffer[serial,"String"] [/mcode] The data returned is in a comma separated format, called [url=http://aprs.gids.nl/nmea/]GPS NMEA sentences[/url].[code] $GPRMC,154541.000,A,4005.8369,N,08814.7322,W,0.04,253.32,201113,,,A*79 $GPVTG,253.32,T,,M,0.04,N,0.07,K,A*3B $GPGGA,154542.000,4005.8369,N,08814.7322,W,1,8,1.07,228.0,M,-33.9,M,,*6B $GPGSA,A,3,04,12,10,17,23,24,25,02,,,,,1.31,1.07,0.76*04 $GPGSV,3,1,12,04,65,040,24,02,63,265,16,10,55,135,39,12,48,302,21*7D $GPGSV,3,2,12,17,35,096,33,05,19,190,17,25,13,321,33,24,12,247,16*71 $GPGSV,3,3,12,23,05,061,31,13,02,090,27,20,02,036,35,45,,,*45 $GPRMC,154542.000,A,4005.8369,N,08814.7322,W,0.06,253.32,201113,,,A*78[/code] We can import the data with the Wolfram Language using ImportString:[mcode]csv = ImportString[ data, "CSV" ][/mcode] The NMEA sentences which contain GPS coordinates start with $GPRMC so we filter for those using Cases and pattern matching:[mcode]gps = Cases[ csv, {"$GPRMC", ___} ][/mcode] The coordinates (latitude and longitude) are in the 4th and 6th position of each list, for example this is the GPS coordinate for the first data point:[mcode]Part[ gps, 1, {4,6} ] / 100[/mcode] which returns the GPS location for Champaign, Illinois, where Wolfram Research is located 40' North, 88' West):[mcode]{40.0583, 88.1474} [/mcode] Arnoud Buzing 2013-11-21T17:10:15Z https://community.wolfram.com/groups/-/m/t/457158 Dear Community, I am just new to Mathematica that came with my Raspberry Pi2. For a while now I have been looking for a program, which is able to minimize a discontinuous and nonlinear problem. Up to now I created the following formulas: f1[x_] := Piecewise[{{0.00000000000252413096488599 x^4 - 0.0000000295981935774312 x^3 + 0.0001268180409138660 x^2 - 0.239339875030011 x + 368.934089585833, x > 0}, {0, x <= 0}}] f2[x_] := Piecewise[{{0.00000000000327848026710691 x^4 - 0.0000000379764365996404 x^3 + 0.0001584280843487410 x^2 - 0.284905693712486 x + 386.639837124850, x > 0}, {0, x <= 0}}] f3[x_] := Piecewise[{{0.00000000000273770414832564 x^4 - 0.0000000245466477791088 x^3 + 0.0000876247218487314 x^2 - 0.151272246878742 x + 298.178569447775, x > 0}, {0, x <= 0}}] f4[x_] := Piecewise[{{0.00000000000151824463118546 x^4 - 0.0000000164748347339070 x^3 + 0.0000716029554621768 x^2 - 0.140270401260495 x + 293.998348739492, x > 0}, {0, x <= 0}}] NMinimize[{f1[w] + f2[x] + f3[y] + f4[z], Plus[w, x, y, z] == 7000}, {w \[Element] Interval[{0, 4000}], x \[Element] Interval[{0, 4000}], y \[Element] Interval[{0, 3000}], z \[Element] Interval[{0, 3000}]}] Unfortunately now I get the following error messages three times before the calculation is aborted: During evaluation of In[8]:= NMinimize::nnum: The function value {812.066} is not a number at {Subscript[w, 1],Subscript[x, 1],Subscript[y, 1],Subscript[z, 1]} = {1052.02,1848.71,2479.67,1619.59}. Is there any quick way of resolving this issue? Did I enter something in a wrong way? At least the sum of the resulting values for w,x,y, and z being 7000 is correct, maybe 812,066 is a local minimum already. But why is there an error message? I also tried to use Minimize and different Methods, but the outcome is the same in all cases. And it is just a LOCAL minimum: As one might be able to see from the equation, fx[0]=0. A minimum value, f.e. for the entered w+x+y+z==7000, should incorporate that some of the functions are set to zero! Is there any way to include this possibility in a fast way? Or do I have to write a minimization for all 16 possibilities and minimize these again? Best regards, Peter Peter Bergmann 2015-03-11T16:05:57Z https://community.wolfram.com/groups/-/m/t/157473 This post shows how to use the GPIO with the Wolfram Language on a Raspberry Pi. To recreate this experiment you will need the following hardware (in addition to the Raspberry Pi itself): [list] [*][url=http://www.adafruit.com/products/301]Super Bright Blue 5mm LED[/url] [*][url=http://www.adafruit.com/products/1105]Pi T-Cobbler Breakout Kit[/url] [*][url=http://www.adafruit.com/products/239]Full sized breadboard[/url] [*][url=http://www.adafruit.com/products/758]Male/male jumper wires[/url] [*]A 400 ohm resistor (to prevent the LEDs from burning out). [/list] Set up the breadboard as shown: Plug the T-Cobbler into the breadboard with 13 pins in the E column and 13 pin in the G column. Use the jumper wires to connect pins 4, 17, 27, 22, 18, 23, 24 and 25 to evenly spaced free rows lower on the breadboard. Connect 8 blue LEDs from each jumper wire row to the blue - column, with the flattened cathode side on the blue - column. Complete the circuit by connecting the resistor from the blue - column to the GND pin. Connect the ribbon cable to the T-Cobbler and the Raspberry Pi correctly, and turn on your Raspberry Pi. [img=width: 512px; height: 683px;]/c/portal/getImageAttachment?filename=2-5344gpio_community.jpg&userId=11733[/img] The GPIO interface requires root privilege for access so the Wolfram Language or Mathematica needs to be started as root for this experiment. In a terminal start the Wolfram Language using the following command (as root): [code]> sudo wolfram Wolfram Language (Raspberry Pi Pilot Release) Copyright 1988-2013 Wolfram Research Information & help: wolfram.com/raspi In[1]:= [/code] First we define the pins that correspond to connected LEDs: [mcode]pins = {4,17,27,22,18,23,24,25} [/mcode] Next we can turn on individual LEDs by writing the value '1' to it: [mcode]DeviceWrite[ "GPIO", First[pins] -> 1 ] [/mcode] And of course turn it back off, by writing the value '0': [mcode]DeviceWrite[ "GPIO", First[pins] -> 0 ] [/mcode] Or turn the LEDs on and off one at a time: [mcode]Do[ DeviceWrite[ "GPIO", pins[[i]]->1 ]; Pause[.2]; DeviceWrite[ "GPIO", pins[[i]]->0 ]; ,{i,8}] [/mcode] Arnoud Buzing 2013-11-21T17:13:19Z https://community.wolfram.com/groups/-/m/t/157704 This post shows how to use the standard Raspberry Pi camera with the Wolfram Language on a Raspberry Pi. To recreate this experiment you will need the following hardware (in addition to the Raspberry Pi itself): [list] [*][url=http://www.adafruit.com/products/1367l]Raspberry Pi Camera Board[/url] [/list] First configure your Raspberry Pi Camera Board following the instructions from the [url=http://www.raspberrypi.org/camera]Raspberry Pi Camera web page[/url]. From the desktop double click the 'Mathematica' icon or type 'mathematica' in a terminal to launch the notebook interface. To take pictures, simply run the DeviceRead command: [mcode]DeviceRead["RaspiCam"] [/mcode] [img=width: 800px; height: 500px;]/c/portal/getImageAttachment?filename=4-camdesk_community.jpg&userId=11733[/img] Arnoud Buzing 2013-11-21T17:19:08Z https://community.wolfram.com/groups/-/m/t/157340 [i]Mathematica [/i]and The Wolfram Language are now available from ours and the Raspberry Pi foundation's software repositories for the default Raspbian Linux distribution for the Pi. If you're running a Raspbian image provided by the Raspberry Pi foundation, you can now install the software with the following steps: [list=1] [*]Ensure that you have at least [b]600[/b] megabytes of free storage on your Raspberry Pi's SD card. The package itself will take up 429 megabytes of disk space when installed. [*][code]$ sudo apt-get update && sudo apt-get install wolfram-engine[/code] [*]Agree to the licensing terms displayed (Use tab to move between fields in the license window. You will only need to do this once). [*]Wait for the installation to complete.  [/list]You should now find Mathematica and the Wolfram Language installed on the LXDE desktop under the [b]Education[/b] menu and the Wolfram Language under the [b]Programming [/b] menu. In order to start the application from the Linux command line, type:[code]$ wolfram[/code]To start Mathematica, type:[code]$ mathematica[/code] If you have any questions about installing the application on your Raspberry Pi, feel free to ask!  Alex Newman 2013-11-21T17:12:50Z 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/163395 I am trying to connect to a remote Pi using the RDK. I guess there has to be a way to get the Mathematica kernel running on the Pi - without invoking the GUI frontend (i am running headless over SSH). But I am unable to figure out how to do that - has anybody already got that going? Any help is appreciated. Arvind Arvind Govindaraj 2013-12-02T10:57:26Z 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/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/157486 This post shows how to use a weather station module with the Wolfram Language on a Raspberry Pi. To recreate this experiment you will need the following hardware (in addition to the Raspberry Pi itself): [list] [*][url=http://www.web4robot.com/PiWeather.html]Raspberry Pi Weather Station Board[/url] [/list] [img=width: 512px; height: 384px;]/c/portal/getImageAttachment?filename=3-weather_community.jpg&userId=11733[/img] First configure your Raspberry Pi for I2C interface support as described in the [url=http://www.web4robot.com/files/PiWeatherCodeExamples.zip]ReadMe.pdf[/url] from the manufacturer. Next turn off your Raspberry Pi and connect the Weather Station board to the 26 pin interface. Turn your Pi back on and check that the device is detected: [code] > sudo i2cdetect -y 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- 4e -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- -- [/code] The Weather Station requires root privilege for access so the Wolfram Language or Mathematica needs to be started as root for this experiment. In a terminal start the Wolfram Language using the following command (as root): [code]> sudo wolfram Wolfram Language (Raspberry Pi Pilot Release) Copyright 1988-2013 Wolfram Research Information & help: wolfram.com/raspi In[1]:= [/code] First we open the device: [mcode]In[1]:= obj = DeviceOpen["RaspberryPiWeatherStation"] Out[1]= DeviceObject[{RaspberryPiWeatherStation, 1}] [/mcode] Next we can read the current temperature as measured by the board: [mcode]In[2]:= DeviceRead[obj, "Temperature"] Out[2]= 25 degrees Celsius [/mcode] Or the relative humidity: [mcode]In[3]:= DeviceRead[obj, "Humidity"] Out[3]= 30 percent [/mcode] And also the barometric pressure: [mcode]In[4]:= DeviceRead[obj, "Pressure"] Out[4]= 993 hectopascals [/mcode] Arnoud Buzing 2013-11-21T17:15:55Z 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/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/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/416746 Hello dear Mathematica community, <BR> I installed Mathematica 10 on my Mac a few days ago and wanted to connect it to my Raspberry Pi, but it failed. I also have the same problem as described in some other posts here. From my Mac I can ssh to my RasPi and launch there Wolfram, and make it add 1+1. But I can't figure out how to get a connection to the RasPi from Mathematica on my Mac using the RDK. In the setup mask of the RDK (Configure Pi Connection) I entered Network machine of Pi: IP address of the WLAN connection of my RasPi (as said, this one works for connecting via ssh) Login of Pi: pi (Every time I will retry this first setup step, a new kernel appears in the Evaluation->Kernel Configuration Options menu, even if the IP is the same. Is this just a bug and has never been tested by Wolfram??) In my point of view there is not much that the user can do there wrong, it should work out of the box. When I try to connect to my RasP and evaluate the Pi Test & Example notebook I am asked to enter my password for my pi login, I have to wait then quite a while, then I get the following two errors: The child process 594 reports: sh: Private: command not found The kernel Raspberry Pi failed to connect to the front end. (Error = MLECONNECT). You should try running the kernel connection outside the front end. When I enter Options[FrontEnd,EvaluatorNames] on my local desktop I get In[2]:=Options[FrontEnd, EvaluatorNames] Out[2]= {EvaluatorNames -> {"Local" -> {"AutoStartOnLaunch" -> True}, "Raspberry Pi" -> {"RemoteMachine" -> True, "TranslateReturns" -> True, "AutoStartOnLaunch" -> False, "Executable" -> "/usr/bin/wolfram", "HostName" -> "192.168.178.22", "RemoteLogin" -> "pi"}}} I googled, and found out that others seem to have the problem too, but couldn't find anything that would solve my connection problem. I would be very happy if someone could help me with this issue. Kind Regards Björn Björn Forster 2015-01-05T16:54:34Z https://community.wolfram.com/groups/-/m/t/157817 I saw the annoucement of [url=http://www.wolfram.com/raspberry-pi/]Mathematica for Raspberry Pi[/url] today. I was wondering if this version of Mathematica has all the functionality that is available in the commercial version of Mathematica.  Or is it just a subset?  (Mathematica 9 is much bigger than just [url=http://community.wolfram.com/groups/-/m/t/157340?p_p_auth=lZD0ficP]429 MB[/url].)  I'm interested in kernel functionality mostly.  I understand the the Predictive Interface is disabled to improve performance. I would try it out, but I do not have a Raspberry Pi at this moment... Szabolcs Horvát 2013-11-21T19:44:46Z 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/433430 Will the free version of Mathematica work on the newly announced Raspberry Pi 2? Daniel Jensen 2015-02-02T15:45:46Z