https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Connected Devices sorted by new. https://community.wolfram.com/groups/-/m/t/3563034 Has anyone been able to install and run Mathematica on NVIDIA's new DGX Spark computer? If yes, does CUDA work? Does, NetTrain work? Are you able to train models? David Laxer 2025-10-21T17:21:12Z https://community.wolfram.com/groups/-/m/t/3474215 Hi, I'm on Wolfram Home Edition 14.2.1 on macOS and I try to get OpenAIGym working as per the help page. The gym python package has been installed, but when I try to execute env = DeviceOpen["OpenAIGym", "Atlantis-v0"] an error message in the Messages window appears saying that Python package cv2 is not installed. I have installed it as well using ResourceFunction["PythonPackageInstall"]["opencv-python"] Has anyone else gotten this device running on macOS. It seems also like the gym package is deprecated and further development happens in the package gymnasium. Thomas Gustafsson 2025-06-04T13:38:17Z https://community.wolfram.com/groups/-/m/t/3460710 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/65e4af27-f068-4a98-bee5-c75d8ccdbce7 Dimitar Krastev 2025-05-14T13:35:17Z https://community.wolfram.com/groups/-/m/t/3454636 Is it possible to make multichannel audio recordings (beyond stereo L/R) in Mathematica? I have a 4-channel audio interface ("Listen AudioConnect 4x4") attached but am only getting single channel results. Context: As a retirement project I am making a test system for loudspeakers in which I make simultaneous measurements of response at different sensors (sound pressure, voltage, current, displacement) to a stimulus generated in Mathematica and synchronously played back on the same audio interface. I have done this in the past prior to the introduction of Audio, but it required using a Matlab toolbox (and MatLink, no longer supported) for the data acquisition. In the new system I would like to do this entirely within Mathematica, but I can't seem to get enough input data channels to record. Daniel Warren 2025-05-03T19:31:15Z https://community.wolfram.com/groups/-/m/t/3445017 ![enter image description here][2] **April 23rd, 2025**: Wolfram U is hosting a webinar on Wolfram System Modeler's OPC UA Library! Discover how you can connect your digital models with industrial devices such as PLCs, sensors, actuators and more. In this webinar, we will present the latest release of the OPC UA library, a System Modeler Library designed for real-time communication with OPC UA–enabled devices and systems. This library facilitates workflows such as testing control code through hardware-in-the-loop simulations, collecting and analyzing live data, deploying high-level control algorithms and creating custom control panels. By connecting models with physical systems in real time, it unlocks exciting possibilities in industrial automation, control development and data analysis. >[**REGISTER HERE**][3] ![enter image description here][4] [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=OPC-Event-WU.png&userId=1522613 [3]: https://www.bigmarker.com/wolfram-u/opc-ua-library?utm_bmcr_source=wsm-events-page [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=WolframU.png&userId=1522613 Ankit Naik 2025-04-16T14:24:24Z https://community.wolfram.com/groups/-/m/t/3365621 To run the Mathematica runtime directly on the PYNQ board, you’ll have to cross-compile Wolfram libraries for ARM. Wolfram Mathematica does not natively provide ARM-compatible libraries (libWolframRTL.so) for ARM platforms such as the PYNQ board. The libraries provided by Wolfram are typically built for x86-64 Linux systems, which causes the architecture mismatch when you try to use the ARM cross-compiler (arm-linux-gnueabihf-gcc). In this, ARM-compatible libraries from Wolfram are required. Or please provide a custom solution or suggest alternatives. Vijaya Babu Panthagani 2025-01-28T13:59:01Z https://community.wolfram.com/groups/-/m/t/3314481 ![Interactive NAO V5 robot programming: movement, problem solving & AI][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Main05112024.png&userId=20103 [2]: https://www.wolframcloud.com/obj/243dab72-d8b6-4da4-9813-1b4b384e6599 Terence Smith 2024-11-04T21:02:22Z https://community.wolfram.com/groups/-/m/t/3311950 Hello, I successfully use streaming from $DefaultAudioInputDevice. audio0 = AudioStream[$DefaultAudioInputDevice, SampleRate -> 7119, SoundVolume -> 1]; AudioRecord[audio0]; Pause[180] AudioStop[audio0]; In future I want to stream audio from Google Chrome Tab. Please, what device do I need to use? Regards - Leo Leo Baumann 2024-10-30T18:03:29Z https://community.wolfram.com/groups/-/m/t/3294878 Hello, I am playing with Micro:bit and Mathematica. I wanted to simply visualize current temperature (measuring constantly) in Mathematica with temperature sensor on Micro:bit. I have programmed Micro:bit and wrote a code in Mathematica using Dynamic and ThermometherGauge function to do the visualization. It works, but I noticed that data showing in MakeCode is different (and more accurate) than the data showing in Mathematica. And I can be sure that the temperature showing in Mathematica is wrong because 32ºC is not possible currently and it never changes. And the gauge is constantly showing 10 then 50 and then 32ºC. I do not know why is that. Code for Micro:bit in JavaScript: let temp = 0 basic.forever(function () { }) basic.forever(function () { // Get the temperature in Celsius temp = input.temperature() // Write temperature to serial as a number serial.writeNumber(temp) // Write a newline to ensure proper reading serial.writeLine("") // Wait for 2 seconds before sending next value basic.pause(2000) }) Mathematica: Dynamic[temp = DeviceRead[microbit] ] Dynamic[ThermometerGauge[temp, {0, 50}, ScaleOrigin -> 0, GaugeLabels -> "Temperature (°C)"]] Thanks in advance! Ivo P. 2024-10-09T15:00:48Z https://community.wolfram.com/groups/-/m/t/3161083 My friend and I are both having the same problem. My microphone works fine in all other apps, except Mathematica can't detect any input devices. Has anyone found a solution to this? Windows 11 Pro. Permissions for the microphone are set correctly. I tried various devices. Yes, the drivers are up to date. Again, but me and my friend are having the same issue on separate computers. I have v14 he has v13.3 Sam B 2024-04-19T20:31:05Z https://community.wolfram.com/groups/-/m/t/3119087 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=3539hero.png&userId=20103 [2]: https://www.wolframcloud.com/obj/f9223055-9ef0-4858-bd08-f2284fe5b1fd Marcel Pelletier 2024-02-09T01:19:05Z https://community.wolfram.com/groups/-/m/t/3105676 My USB microphone shows up in the PulseAudio volume control and also works well with Audacity, arecord etc. However, Mathematica can't see the mic -- $AudioInputDevices gives me a null list. How can I set up the mic to work as an audio input device in Mathematica? (Raspberry Pi OS Bookworm ) Thanks, Praveen Praveen Bharadhwaj 2024-01-19T04:18:27Z https://community.wolfram.com/groups/-/m/t/3025705 Using the following code to connect to the Arduino board, the following window will be shown, which requires the installation of the Arduino software. arduino = DeviceOpen["Arduino", "COM3"]; ![enter image description here][1] But because I have already installed the Arduino IDE software, I want to define its installation Path with the Device property "ArduinoInstallLocation" so I use the following code: arduino = DeviceOpen["Arduino", {"COM3","ArduinoInstallLocation" -> "C:\\Program Files\\Arduino IDE"}]; But it doesn't work for me. ![enter image description here][2] Please Help! I need to specify the installation path of Arduino Software. [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=3025416 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=3025416 Harry Hunt 2023-10-02T16:41:50Z https://community.wolfram.com/groups/-/m/t/3024384 I am very frustrated with the slow transfer of data from the Arduino serial COM port to the PlotLine[] in dynamic function. In the Arduino Plot Serial, data is drawn instantly. But when connected to WM with USB able, the plots are very very slow. About 10 and 20 to 1 speed. The Arduino code is sending a 6 pair of integers in ASCI format. Any suggestions as to how speed up. He Arduino sketch is this #include <Wire.h> #include "Adafruit_AS726x.h" //create the object Adafruit_AS726x ams; uint16_t sensorValues[AS726x_NUM_CHANNELS]; void setup() { Serial.begin(115200); while (!Serial) pinMode(LED_BUILTIN, OUTPUT); //inicia y permite la comunicacion con el sensor if (!ams.begin()) { Serial.println("could not connect to sensor! Please check your wiring."); while (1) ; } } void loop() { //temperature sensor //uint8_t temp = ams.readTemperature(); //ams.drvOn(); // descomentar esto si quieres usar el led del sensor para hacer medidas ams.startMeasurement(); //begin a measurement //permite que el sensor lea la data cuando este disponible bool rdy = false; while (!rdy) { delay(5); rdy = ams.dataReady(); } //ams.drvOff(); //descomentar esto si quieres usar el led del sensor para hacer medidas //lee los valores! ams.readRawValues(sensorValues); //ams.readCalibratedValues(calibratedValues); //Serial.print("{"); //Serial.print("Temp: "); //Serial.print(temp); //Serial.print(","); //Serial.print(" Violet: "); Serial.print(sensorValues[AS726x_VIOLET]); Serial.print(","); //Serial.print(" Blue: "); Serial.print(sensorValues[AS726x_BLUE]); Serial.print(","); //Serial.print(" Green: "); Serial.print(sensorValues[AS726x_GREEN]); Serial.print(","); //Serial.print(" Yellow: "); Serial.print(sensorValues[AS726x_YELLOW]); Serial.print(","); //Serial.print(" Orange: "); Serial.print(sensorValues[AS726x_ORANGE]); Serial.print(","); //Serial.print(" Red: "); Serial.print(sensorValues[AS726x_RED]); //Serial.print("}"); Serial.println(); ; } I have set up Baud speed to very high, but this makes no difference. Here is the Mathematica Notebook dev = DeviceOpen["Serial", {"COM3", "BaudRate" -> 115200}] parseData[{val1__, 44, val2__, 44, val3__, 44, val4__, 44, val5__, 44, val6__}] := ToExpression@ FromCharacterCode@# & /@ {{val1}, {val2}, {val3}, {val4}, {val5}, \ {val6}} parseData[___] := Sequence[] rawReadings = {} Dynamic[ListLinePlot[Transpose[parseData /@ rawReadings], PlotLegends -> Automatic]] DeviceClose[dev] Jose Calderon 2023-09-30T21:42:31Z https://community.wolfram.com/groups/-/m/t/3016653 I have set up the following sketch to capture a serial feed from an arduino. But the Dynamic command only pick up 4 feeds and dies. . he Arduino sketch is //*************************** // Credit original code to // Aleksandr Berezutskii //*************************** int raw1 = 0, raw2 = 0, raw3 = 0; int x = 0, y1 = 0, y2 = 0, y3 = 0; #define APin1 A11 #define APin2 A12 #define APin3 A13 void setup() { Serial.begin(9600); pinMode( APin1, INPUT ); pinMode( APin2, INPUT ); pinMode( APin3, INPUT ); analogReference(DEFAULT); } void loop() { while (x<=6000) { raw1 = analogRead( APin1 ); y1=raw1; raw2 = analogRead( APin2 ); y2=raw2; raw3 = analogRead( APin3 ); y3=raw3; x++; Serial.print( y1 ); Serial.print("\t"); Serial.print( y2 ); Serial.print("\t"); Serial.print( y3 ); Serial.println(); delay(400); } } The notepad is included here. &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/138756c1-8684-4ff5-841c-24dd2348e551 Jose Calderon 2023-09-20T00:59:13Z https://community.wolfram.com/groups/-/m/t/2714674 ![enter image description here][1] > Gizmodo: [This Question-Answering Typewriter Is Like if We Had Siri in the ’70s][2] > Original articles: [Termi2 - a Typewriter That Answers Your Questions][3] > [Siri like it's 1976 with a TI silent 700 terminal][4] What if a typewriter could respond to questions you enter? I answered that question [several years ago with a project I called Termi][5]. I salvaged a vintage TI Silent 700 electric typewriter/terminal (Model 745) and connected it to a Raspberry Pi Zero W that ran a script to query Wolfram Alpha. When the user typed a question into the typewriter, it would type out the answer ...like a 1976 version of Siri. For example, a simple exchange might look like: > Question: who is the president of the United States? > Answer: the current president of the United States is Joe Biden Termi2 is a reimagined version of that project, but better. I'm both reusing vintage hardware (the TI Silent 700) and the original idea in order to improve upon one of my favorite projects. **What's changed?** The basic concept is still the same: the user types a question, then Wolfram Alpha answers that question and the response automatically types out. But all of the hardware, aside from the TI Silent 700 itself, is different. I realized that an SBC (Single-Board Computer) was overkill for this project and introduced unnecessary complications. For example, it required that the user log into the Linux terminal at startup, took a while to boot, and necessitated a specific question command structure and some strange formatting. Termi2 now uses an ESP32 to handle the same functionality in a much more streamlined way. When powered on, it takes just a few seconds to connect to WiFi and prompt the user for a question. The user can type that question any way they like—no special commands or formatting necessary. Within a few seconds, a short answer from Wolfram Alpha (which can process a wide range of queries) will print out. The new hardware also eliminates the need for the Arduino adapter I created for the original and runs on a lithium battery, so no additional power adapter is needed. &[Wolfram Notebook][6] ##Supplies **Components:** - TI Silent 700 Terminal (Model 745) - ESP32 Development Board - SN74LVC245A level shifter IC - Battery charging/distribution module - Lithium-ion battery (between 250-1000mAh should work) - Power switch - Female DA-15 connector - Perfboard **Supplies:** - Soldering iron - 3D printer - Computer (for programming ESP32) - Hot glue gun - Wire ##Step 1: The TI Silent 700 Explained ![enter image description here][7] The TI Silent 700 is a strange device by modern standards. It looks like an electric typewriter and operates as such. TI even advertised it that way. But it isn't *just* a typewriter; it is also a computer terminal. It isn't a standalone computer and can't process anything on its own, but rather acts as an interface for a computer. In the 1970s, computers were big, expensive, and often shared among multiple users. In many ways, the kinds of high-end computers that businesses and universities used were more like what we think of as servers today. Like most modern servers, those vintage computers were often headless (meaning they didn't have their own monitor and keyboard). To work with them, could connect a terminal to input data into a computer and receive the output. That was especially useful when working with remote computers. In this case, when the TI Silent 700 is in online mode it will send anything typed on its keyboard to a connected computer. Optionally, it will also print the typed characters directly onto the paper like a normal electric typewriter. Anything the connected computer returns will print out on the paper via the same typewriter mechanism (a thermal printhead). This specific model, the 745, could connect to connects through a serial port or an acoustic coupler. The latter works with primitive modems and accepts a telephone handset. The TI Silent 700's speaker would beep and chirp into the handset to send data, and its microphone would listen for beeps and chirps to receive data. The serial port enables more conventional local communication and is what I used for this project. Data transfer is very slow and there are no advanced handshake features, but the serial communication is straightforward. Of note, this model can only output uppercase letters. That made it difficult to use with Linux, which meant that I had to utilize some creative workarounds for the original Termi project. ##Step 2: TI Silent 700 Serial Communication ![enter image description here][8] The most important thing to know when trying to setup serial communication with a TI Silent 700 is that the logic is inverted—voltage between -15V and -3V is a 1 (one, TRUE), and voltage between +3V and +15V is a 0 (zero, FALSE). This is the opposite logic of most modern serial communication. This means that, unless you correct for it, when the TI Silent 700 sends what it thinks is a 1, the receiving computer will likely receive a 0 (and vice-versa). The data will still send, but it will appear to be random characters. There are a few ways to correct for this. If the device supports it (as the ESP32 does), you can simply setup the serial connection with inverted logic on both RX and TX. You can also use a hex inverter IC chip, which has multiple input/output pairs that invert logic. The other serial data settings are straightforward. The TI Silent 700 requires: - 7 data bits - 1 stop bit - Odd parity bit (apparently even also works) - No flow control The Model 745 can print at either 30 characters a second or 10 characters a second. The former requires 300 baud and the latter requires 100 baud. There is also a switch for duplex mode. I use half duplex, which means it can only receive or send data at any given time. But that will also print everything the user types (something I wanted). In full duplex, the TI Silent 700 will only print data it receives over serial (not what the user types, unless the receiver echoes that). **The Serial Port** I'm calling it a serial port, but that isn't actually what it is. It is actually a proprietary port that has pins for two separate serial connections (one for the acoustic coupler, one for normal serial communication). That port accepts a female DA-15 connector with 15 pins arranged in two rows. Looking at the TI Silent 700's port, the top left pin is Pin 1 and the bottom right pin is Pin 15. The pictured page from the manual shows the pin functions (with their proprietary cable adapter). We won't need the adapter, because we're going to connect to the pins ourselves. Here are the connections I used: - Pin 1 > Ground - Pin 11 > 5V - Pin 12 > RX - Pin 13 > TX Pin 11 needs to receive steady voltage for the TI Silent 700 to register that it is connected to something. If it doesn't, it will refuse to send or receive data. **Level Shifting** The TI Silent 700 considers anything between -3V and 3V to be null—it isn't a 1 or a 0. And it outputs at somewhere between 5V and 8V. But the ESP32's pins cannot handle anything over 3.3V. It also outputs at 3.3V, which is enough for the TI Silent 700 to detect. To avoid damaging the ESP32, the output from the TI Silent 700 needs to come down to acceptable voltage. This is the job of the SN74LVC245A level shifter IC. It brings inputs down to whatever voltage it is supplied with and outputs them at that voltage. So if we supply it with 3.3V, it will take the high-voltage output from the TI Silent 700 and bring it down to 3.3V that is acceptable for the ESP32. ##Step 3: ESP32 Wiring ![enter image description here][9] ESP32 modules are available on different development boards without different pinouts. I used this ESP-WROOM-32 development board, which seems to have the most common pinout. You can see in the Fritzing schematic how everything is connected, but I'll cover it all here in detail. Connections to the ESP32's pins: - GND > ground for everything - VIN > 5V from battery, 5V to Pin 11 on the TI Silent 700 - 3V3 > to level shifter - RX2 > to level shifter output from TI Silent 700's Pin 13 TX output - TX2 > to Pin 12 on TI Silent 700 Connections to the SN74LVC245A's pins: - Pin 1 (DIR) > 3.3V from ESP32 - Pin 20 (Vcc) > 3.3V from ESP32 - Pin 2 (A1) > TX from Silent 700 - Pin 10 (GND) > Ground - Pin 19 (OE) > Ground - Pin 18 (B1) > TX output to ESP32 Connections to the DA-15 connector: - Pin 1 > Ground - Pin 11 > 5V - Pin 12 > RX - Pin 13 > TX The battery charging/power distribution module will depend on your particular model, but it should be pretty simple. Connect the battery's + and - leads to the module's + and - pads. Then the output + pad goes to the ESP32's VIN pin (through a power switch) and the - pad goes to the ESP32's GND pin. ##Step 4: ESP32 Code The code for the ESP32 (which I wrote in MicroPython) needs to do a few things: 1. Connect to WiFi 2. Listen for incoming data 3. Understand when the user finishes their query 4. Format the query 5. Send the query to the Wolfram Alpha API 6. Receive answer from Wolfram Alpha 7. Send the answer data to the TI Silent 700 for printing 8. Wait for a new query I'll explain how I went about accomplishing each step below. I've also fully commented the code, which is attached here. **Connect to WiFi** Connecting to WiFi is easy—that's the whole purpose of the ESP32 and MicroPython makes it simple. The easiest way is to hardcode your WiFi credentials, but I didn't go that route. Initially, I wanted the user to be able to type in their WiFi credentials using the TI Silent 700 and have the ESP32 store them. That would make it easy to connect to new networks. For that reason, I set it up so that the WiFi credentials are stored in a simple text file in flash memory. No, that isn't at all secure. If you're concerned about WiFi security (which you probably should be), you'll want to go a more secure route. But hardcoding the WiFi credentials in MicroPython isn't secure, either. In fact, there aren't many ways to secure the credentials on an ESP32. Unfortunately, the TI Silent 700 can only output uppercase and that made it very difficult to allow users to type in their credentials. How do you let them type an SSID or password that contains lowercase letters (or other characters not on the TI Silent 700's keyboard)? There are workarounds, such as letting the user also input a sort of map of cases, but I decided to just nix that feature. So to change network credentials, one has to plug the ESP32 into a computer and alter the text file. The code simply grabs those credentials and attempts to connect to WiFi for a while. If it isn't able to (or if the file isn't present), then it will print an error message on the TI Silent 700. **Listen for incoming data** The code simply runs a loop where it checks for incoming bytes. Once it receives a byte, it decodes it (as UTF-8) and then saves it as a string (which should only contain one character). It then adds that string to the query string that contains all of the received characters. **Understand when the user finishes the query** When the user presses the "RETURN" key on the TI Silent 700, it sends a byte for a carriage return. This is what we want to detect to determine when the user has entered their query and wants an answer. But their is problem: when decoded and converted to a string, the carriage return byte doesn't look like anything. It isn't a character we can scan for. The solution was to look at every byte that comes in and check to see if it matches a carriage return byte. It does that before converting the new byte to a character and adding it to the query string. If the incoming byte is a carriage return, it breaks the loop and passes the query string on. If it isn't a carriage return, it simply adds the new character to the query string as normal. **Format the query** The Wolfram Alpha Short Answers API (which returns simple answers perfect for this project) requires a URL request formatted like this: http://api.wolframalpha.com/v1/result?appid=DEMO&i=How+far+is+Los+Angeles+from+New+York%3f But the query as input by the user might look something like: > What is today's date? The spaces, apostrophe, and question mark won't work in this format. So the code processes the query string to remove all the spaces and special characters, then adds it to the URL for the request. **Send the query to Wolfram Alpha** MicroPython makes this easy. All we have to do is send a GET Request to the URL. **Receive answer from Wolfram Alpha** This is also easy. When we send the GET Request, the return will be the short answer. **Send the answer data to the TI Silent 700 for printing** All we have to do to print something on the TI Silent 700 is send it some data. But we want to do that one character at a time. So we cycle through a loop for each character in the answer string, writing that character to the UART (serial) port. But there is one complication: the TI Silent 700 is bad at understanding when it can't print any additional characters on a line. So the loop also checks if it has printed more than 75 characters (index 74). If it has, then it will send both an two newlines ("\n" to advance to the next line) and a carriage return ("\r" to move back to the beginning of the line). The reason it sends two newlines instead of just one is practical. My particular machine doesn't seem to feed paper quite as well as it should, so this compensates for that. It may not be necessary for other machines. **Wait for a new query** After printing the answer, the code just moves back to the loop where it waits for incoming bytes. This lets users continue to ask questions without ever having to reset anything. As long as there is still paper on the roll, it will continue answering questions as long as it as power and WiFi is working. **Step 5: Using Wolfram Alpha's API** Wolfram Alpha is really cool—I'm a huge fan. If you aren't familiar, Wolfram Alpha is a bit like a search engine mixed with a math processor, with a dash of virtual assistant (like Siri or Alexa) thrown in. It can handle things like mathematical formulas, but it also does natural language processing (NLP) and can answer a huge range of questions. If Siri or Alexa can answer it, there is a good chance that Wolfram Alpha can, too. The best part is that Wolfram Alpha has an API (Application Programming Interface) that is easy to use and free for things like hobby projects. There are different API calls one can make, but we're interested in the "Short Answers API" that returns just a sentence or two in plain text. That is exactly what we want for this project. Instructions on using it are here: https://products.wolframalpha.com/short-answers-api/documentation **Basically you just need to sign up for a free account, create an API application, and then plug your APP ID into the MicroPython code I provided.** ##Step 6: Setup WiFi All you need to do to get the ESP32 connected to WiFi using my MicroPython code is create a text file in its flash memory called "creds.txt" and then enter your SSID and password as a single line with a comma between, like this: Your_Network_SSID,Your_Password Nothing else should be in the file and it shouldn't have any spaces. If you don't know what I mean by putting the file in flash memory or haven't yet installed MicroPython on your ESP32, this site has some good instructions: https://randomnerdtutorials.com/getting-started-micropython-esp32-esp8266/ ##Step 7: Assembly ![enter image description here][10] I've designed Termi as a self-contained module that plugs into the TI Silent 700's serial port. I will probably redesign this in the near future to utilize a custom PCB and a nicer enclosure, which will make it look much nicer and far more compact. But for now it's all on a stripboard. The stripboard I used is 70x50mm, which is important for making it fit in the 3D-printed case. For the wiring, you'll want to reference the schematic and connections back in Step 3. I got a little sloppy with the CAD work, since I'm planning on redoing it after designing a real PCB. So hot glue is holding all of the components in place inside the case. The lid fastens to the main case using M3 screws in heat-set inserts. ##Step 8: Using Termi2 To use it, you just plug it in, turn on the TI Silent 700, and then turn on the module. Make sure the TI Silent 700 is set to online, half-duplex, and not low-speed. After a few seconds for the WiFi to connected, the TI Silent 700 should print out: ASK TERMI2: You can then type in whatever question you want, with or without a question mark, and then press the return key. After a few seconds for Wolfram Alpha to process the request and send the answer back, the TI Silent 700 will print the results and then prompt you to ask another question. That's it! Siri like it's 1976 ..again. This is a project I'm very proud of. It's awesome to make an old, obsolete piece of technology that would normally end up as e-waste into something useful and fun. Everyone who sees it loves it, because there is something fun about vintage hardware printing internet knowledge onto paper. [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=termi2_2.gif&userId=20103 [2]: https://www.gizmodo.com.au/2022/11/this-question-answering-typewriter-is-like-if-we-had-siri-in-the-70s/ [3]: https://www.instructables.com/Termi2-a-Typewriter-That-Answers-Your-Questions/ [4]: https://medium.com/cameron-coward/siri-like-its-1976-with-a-ti-silent-700-terminal-79da04ab6651 [5]: https://medium.com/cameron-coward/siri-like-its-1976-with-a-ti-silent-700-terminal-79da04ab6651 [6]: https://www.wolframcloud.com/obj/9a13ba06-381d-463f-9558-6088d4fb41df [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=collage1_1.png&userId=20103 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=FSP1XTNLAPDDN8M.png&userId=20103 [9]: https://community.wolfram.com//c/portal/getImageAttachment?filename=collage1_2.png&userId=20103 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=collage1.3_small.png&userId=20103 Cameron Coward 2022-12-02T18:24:35Z https://community.wolfram.com/groups/-/m/t/2680377 This should not be that difficult, but I'm not seeing the solution. I have a game controller, and in a notebook on my desktop some WL code. The controller sends a "button push" signal to the code just fine, captured by the code in the notebook with a line like this: Dynamic[ControllerState[2, "B4"]] However, I would like this to dynamically trigger a function in the code, similar to the way an event handler would work. To simplify things, let's just have it trigger `Beep[]` when the button is pushed. I could set a timer to repeatedly check the value of the ControllerState, but that can't be the best way to do it. The code is not part of a Manipulate or 3Dgraphics, but rather part of a custom interface. Can anyone please point me in the right direction? Thanks in advance. Mark Greenberg 2022-11-01T18:19:24Z https://community.wolfram.com/groups/-/m/t/2623336 Is there any possibility of using the ADALM-PLUTO with Mathematica? Analog Devices provides support for Matlab, but I wonder if it can be used in Mathematica as well. To complicate things more on macOS arm64. Codrut Popescu 2022-09-25T21:18:51Z https://community.wolfram.com/groups/-/m/t/2602822 Hi, a error message appears when opening a serial connection with an arduino uno. arduinoCCD = DeviceOpen["Arduino", "COM9"] The error message is then : ArduinoUpload`arduinoIndividualUpload::sizeFail: Checking the size of the sketch with avr-size failed with code 1 and output C:\Users\Eble\AppData\Roaming\Mathematica\ApplicationData\Arduino\arduino\hardware\tools\avr\bin\avr-size.exe: '"C:\Users\Eble\AppData\Local\Temp\arduinocompiled9ec104f74a246938788595e6ec6ae01\SketchTemplate.cpp.hex"': No such file and DeviceConfigure::uploadfail: Uploading of the sketch failed. Halting DeviceExecute[] and DeviceConfigure[] can not be used. Does anyone have an idea? Thank you. Benoit Eble 2022-08-22T13:31:16Z https://community.wolfram.com/groups/-/m/t/2565873 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/d190246a-cbf2-4c37-8437-a9d5f7a60adc Tom Sherlock 2022-07-07T15:40:30Z