Podcasts about uart

This week's EYE ON NPI is a powerful pocket-sized 'puter - it's the new PocketBeagle 2 from beagleboard.org! (https://www.digikey.com/en/product-highlight/b/beagleboard/pocketbeagle-2) This is a nice update from the beagleboard team to replace the deprecated PocketBeagle (https://www.digikey.com/short/bcmnqt01) - this new version gives you a lot more processor power at a much lower price. It's perfect when you want a full-featured single-board computer with a ton of GPIO and analog inputs, in a very smol package for easy integration. The PocketBeagle 2 is built around a TI Sitara AM6232 (https://www.digikey.com/short/83md98qd) dual-core Cortex-A53 plus dual Cortex-M4 subprocessor, with 512MB of external DDR4 SRAM. There's 4 MB of onboard eMMC flash, plus a socket for external microSD cards. There's also essentials like USB C for the native device, and a picoprobe-compatible (https://www.digikey.com/short/fq4wmp2b) UART port. What's great about the PocketBeagle 2 (https://www.digikey.com/short/17jh4q7b) is that compared to many single-board computers, the design is fully open source (https://github.com/beagleboard/pocketbeagle-2) verified-and-tested, so if you want to design your own board to add or remove peripherals/components, you can just pick up an AM6232 (https://www.digikey.com/short/83md98qd) from DigiKey and route your own design. Of course, with the high density BGA chip design, it's for experts: many makers and small-scale designers will be better off just adding the 2x18 Cape Headers (https://docs.beagle.cc/boards/pocketbeagle-2/04-expansion.html) which give you a ton of power and GPIO. For example, if you want to connect an external USB device to the host peripheral, those pins plus power and ground are on P1. If you want to connect a TTL graphical display (https://www.digikey.com/short/z9mfvzr8), the HSYNC/VSYNC/DE/Data pins are all on the P1/P2 - they're called VOUT. There's also multiple I2C and SPI ports and analog inputs. The PocketBeagle 2 (https://www.digikey.com/short/17jh4q7b) is back compatible with older peripherals you can pick up to get started designing 'Capes' (the name used for plug-in peripherals). Since the boards use 0.1" socket headers, its easy to prototype with jumper wires or DIY a design with simple CAD software and hand soldering. You can check out the GamePup (https://www.digikey.com/short/n2pp834m)which shows how to connect USB host, external battery, TFT display and lots of buttons. Or the TechLab (https://www.digikey.com/short/852dqn2c) which has 7-segment display, buzzer, USB serial and host, PWM'able RGB LED and I2C accelerometer. (https://www.beagleboard.org/boards/techlab) There's open source design files that you can use to kickstart your own Pocket Cape design (https://github.com/beagleboard/capes/tree/master/pocketbeagle/TechLab) Best of all, the PocketBeagle 2 (https://www.digikey.com/short/17jh4q7b) from beagleboard.org is almost half the price of the original PocketBeagle...and DigiKey has them in stock right now for instant shipment! Book today and you'll have a tiny and powerful single board Linux computer in your pocket by tomorrow afternoon. And don't forget... next week, June 19 2025, there's a webinar you can join to learn more (https://event.on24.com/wcc/r/4906084/A19039CF9E3C1ED0F430C14932B23630?partnerref=nph) about how to use the PocketBeagle 2 - it's free and run by the folks who designed the board, so register to get a reminder and watch!

This week's EYE ON NPI is a super connector - it's the Texas Instruments SimpleLink Wi-Fi CC33xx Family (https://www.digikey.com/en/product-highlight/t/texas-instruments/simplelink-wi-fi-cc33xx-family) with 2.4GHz and 5GHz WiFi 6 support, plus optional Bluetooth LE, in a low cost co-processor you can add to any microcontroller project you have to instantly IoT-ify it. This family of chips is a big upgrade in the CC3 family, and looks like a very competitive solution to existing market chips - we're excited to see how TI has adapted to the existing market to bring this compelling offering. Oh the TI CC3x series, how you've grown! We first met you back when it was the CC3000, a radical WiFi co-processor with the (at-the-time) astonishing price of ~$10 per module. At the time, we crafted an Arduino-compatible shield and a breakout board (https://learn.adafruit.com/adafruit-cc3000-wifi/overview) as well as an Arduino port of the TCP/IP mini-stack so that folks could do amazing things like get the time (https://learn.adafruit.com/adafruit-cc3000-wifi/internettime), read a web page (https://learn.adafruit.com/adafruit-cc3000-wifi/webclient) or even send a Tweet (https://learn.adafruit.com/adafruit-cc3000-wifi/sendtweet). The big thing was making it so you weren't spending the $50 it cost up-till-then to add a full-linux-system-as-peripheral (https://www.adafruit.com/product/1498). Since then, TI has released some updated versions, such as the CC3100 (https://www.digikey.com/short/9cp431pr), which added 802.11n and lower power draw - we saw it featured in a few micropython projects (https://blog.adafruit.com/2016/08/24/micropython-name-badge-from-emf-2016/) thanks to the core driver support (https://github.com/micropython/micropython/tree/master/drivers/cc3100). And after that, the CC3200 series (https://www.digikey.com/short/9289jcq3), which added TLS/SSL support and had an internal ARM Cortex-M4 that could run code on its own, like MicroPython! (https://github.com/micropython/micropython/blob/master/ports/cc3200/README.md) So it's no surprise that TI is continuing to press their WiFi family forward, to now the CC33xx! The new Texas Instruments SimpleLink Wi-Fi CC33xx Family (https://www.digikey.com/en/product-highlight/t/texas-instruments/simplelink-wi-fi-cc33xx-family) comes with 4 variants: the CC330x have 2.4GHz WiFi only, where-as the CC335x add 5GHz for an additional cost. Likewise, the CC33x0 have only WiFi, and the CC33x1 have WiFi+BLE. Since all the chips / modules are pin-compatible, you can develop with one and then change in production to whatever final setup suits your product. Like the earlier chips, these chips are expected to be connected to a main processor: either a microcontroller or microcomputer, over SPI or SDIO. SPI will work great for your smaller micros, SDIO is great when you have the speed and bandwidth to shift a lot more data around. When connecting over BLE, use the UART-with-flow control - that's the standard for a "BTLE Host Controller Interface" communications (https://www.bluetooth.com/wp-content/uploads/Files/Specification/HTML/Core-60/out/en/host-controller-interface/uart-transport-layer.html). Of course, there's no way you'll want to write a driver for this kind of complex chip - so visit the CC33xx software download page (https://www.ti.com/tool/CC33XX-SOFTWARE) which has software in the form of Linux kernel patch/drivers for beefy chips, or an microcontroller with an RTOS - follow their porting guide to get it running on a non-TI chipset (https://dev.ti.com/tirex/explore/node?node=A__AEIJm0rwIeU.2P1OBWwlaA__CC33XX-RTOS-MCU__dzPVh4K__LATEST) Now you're probably saying "OK cool but I don't want to do a bunch of RF layout, I want a nice tinned module i can slap down and connect my RP-SMA or chip antenna" - and not surprisingly, it looks like there's a CC3301 module (https://www.ti.com/product/CC3301MOD) in pre-production with an optimistic budgetary price of $2.88 - that's for 2.4GHz + BLE. For the 5GHz CC3351MOD (https://www.ti.com/product/CC3351MOD) the price is $3.50. Sans BLE the CC3350MOD (https://www.ti.com/product/CC3350MOD) is $3.13. If you want a peek at what the CC3301 module might look like, the BoosterPack product page has a tantalizing glimpse (https://www.ti.com/tool/BP-CC3301MOD). You can sign up at TI's site for updates on the release schedule, or chat with your DigiKey sales rep and they'll let you know when the part makes it into general distribution. Until then, you can get plenty of TI CC3350 (https://www.digikey.com/short/3z7tqtrp) and CC3351 (https://www.digikey.com/short/hmqzwv5j) bare chips: they're both in stock at DigiKey for immediate shipment! Order today and you'll quickly add low-cost WiFi 6 + BLE support to your next design, with 2.4/5 GHz support so you're ready for any customer or configuration. With ready-to-go software, and great low prices, you can get your design set up with cutting-edge networking without breaking the BOM bank.

Connor Rigby joins the Elixir Wizards to talk about Blue Heron BLE (Bluetooth Low Energy) support for Elixir apps. Blue Heron implements the BLE specs in pure Elixir, leveraging binary pattern matching and concurrent message processing to handle Bluetooth protocols. Unlike most solutions that require C ports or NIFs, Blue Heron runs entirely in user space, so it works seamlessly in both Nerves-based embedded projects and (eventually) desktop Elixir applications. We discuss how Nerves development differs from building Phoenix apps. Connor shares challenges he's experienced with hardware compatibility, where some chips only partially implement the spec, and he discusses the surprisingly deep (but sometimes incomplete) world of BLE device profiles. His tip for anyone entering the BLE space: read the official spec instead of trusting secondhand blog posts. Tools like Nerves LiveBook give you hands-on examples, so you can get a BLE prototype running on a Raspberry Pi and your phone in no time. Key topics discussed in this episode: Blue Heron origins and “bird” naming convention BLE vs. Bluetooth Classic: core differences Pure Elixir implementation—no C dependencies Binary pattern matching for packet parsing Hardware transport options: UART, SPI, USB, SDIO GenServer patterns in Nerves vs. Phoenix Linux requirement and power-consumption trade-offs GATT (Generic Attribute Table) implementation patterns SQLite integration for Nerves apps Hardware chip quirks and spec compliance Manufacturer-specific commands and workarounds BLE device profiles and spec gaps Security Management Profile (SMP) for encryption Device connection and pairing workflows Web vs. embedded development differences Where to get started: hardware recommendations and docs Links mentioned: https://github.com/ConnorRigby/ https://github.com/blue-heron/ https://nerves-project.org/ BLE (Bluetooth Low Energy) https://en.wikipedia.org/wiki/BluetoothLowEnergy https://developer.apple.com/ibeacon/ https://learnyousomeerlang.com/building-otp-applications Linux https://www.linux.org/ HCI (Host Controller Interface) https://en.wikipedia.org/wiki/Hostcontrollerinterface Circuits UART Library https://hexdocs.pm/circuitsuart/readme.html SPI (Serial Peripheral Interface) https://github.com/elixir-circuits/circuitsspi SDIO (Secure Digital Input Output https://en.wikipedia.org/wiki/SDIO Raspberry Pi https://www.raspberrypi.com/ Coral SoM Dev Board https://coral.ai/products/dev-board/ BeagleBone Single-Board Linux Computer https://www.beagleboard.org/boards/beaglebone-black https://www.bluetooth.com/bluetooth-resources/intro-to-bluetooth-gap-gatt/ Genservers https://hexdocs.pm/elixir/1.12/GenServer.html https://hexdocs.pm/ecto/Ecto.html https://github.com/elixir-sqlite/ectosqlite3 https://github.com/nerves-livebook/nerveslivebook Special Guest: Connor Rigby.

Arduino. Founded in Italy twenty years ago by a group of visionary educators and engineers, Arduino was born out of a desire to democratize electronics and make it accessible to everyone. Named after a bar in Ivrea, the platform started with hand-assembled circuit boards for students at the Interaction Design Institute Ivrea (IDII). The founders—Massimo Banzi, David Cuartielles, David Mellis, Tom Igoe, and Gianluca Martino—made key decisions to keep the hardware and software open-source, ensuring that anyone could learn, create, and innovate.   The result is… a world where anyone, regardless of their technical background, can create electronic projects that once seemed out of reach. This is the world that Arduino has made possible.   The significance of Arduino extends far beyond its technical specifications. It has lowered barriers of entry, making electronics affordable and accessible. Its massive open-source community fosters sharing and innovation, sparking the Maker movement and encouraging creation over consumption. Arduino has become a platform, bridging disciplines like art, design, engineering, and computer science, and enabling rapid prototyping. Its impact is felt in education, product development, and the philosophy of technology accessibility.   Arduino has inspired a global movement, empowering hobbyists, students, artists, and professionals to bring their ideas to life. It has influenced modern IoT and smart devices, proving that with the right tools, anyone can be an innovator. Arduino's choice of the AVR ATmega168 and later the ATmega328P microcontrollers was pivotal. These microcontrollers offered a balance of performance, cost, and ease of use, featuring 8-bit architecture, flash memory, SRAM, EEPROM, and built-in peripherals like timers, ADC, PWM, UART, SPI, and I2C. This made them ideal for a wide range of applications, from simple projects to complex prototypes.   What happens next is anybody's guess, but the frontiers spawned by the Shockley's and Moore's of the world, with their advanced educations and access to vast amounts of capital, are giving way to the kid in their bedroom, tinkering with a board and a laptop, intent on building a thing – turning their imagination into reality through simple advancements in integrated circuits, sensors, and open-source software.   How can Microchip Technology fuel the ethos of the Do-It-Yourself Maker movement?

Arduino. Founded in Italy twenty years ago by a group of visionary educators and engineers, Arduino was born out of a desire to democratize electronics and make it accessible to everyone. Named after a bar in Ivrea, the platform started with hand-assembled circuit boards for students at the Interaction Design Institute Ivrea (IDII). The founders—Massimo Banzi, David Cuartielles, David Mellis, Tom Igoe, and Gianluca Martino—made key decisions to keep the hardware and software open-source, ensuring that anyone could learn, create, and innovate.   The result is… a world where anyone, regardless of their technical background, can create electronic projects that once seemed out of reach. This is the world that Arduino has made possible.   The significance of Arduino extends far beyond its technical specifications. It has lowered barriers of entry, making electronics affordable and accessible. Its massive open-source community fosters sharing and innovation, sparking the Maker movement and encouraging creation over consumption. Arduino has become a platform, bridging disciplines like art, design, engineering, and computer science, and enabling rapid prototyping. Its impact is felt in education, product development, and the philosophy of technology accessibility.   Arduino has inspired a global movement, empowering hobbyists, students, artists, and professionals to bring their ideas to life. It has influenced modern IoT and smart devices, proving that with the right tools, anyone can be an innovator. Arduino's choice of the AVR ATmega168 and later the ATmega328P microcontrollers was pivotal. These microcontrollers offered a balance of performance, cost, and ease of use, featuring 8-bit architecture, flash memory, SRAM, EEPROM, and built-in peripherals like timers, ADC, PWM, UART, SPI, and I2C. This made them ideal for a wide range of applications, from simple projects to complex prototypes.   What happens next is anybody's guess, but the frontiers spawned by the Shockley's and Moore's of the world, with their advanced educations and access to vast amounts of capital, are giving way to the kid in their bedroom, tinkering with a board and a laptop, intent on building a thing – turning their imagination into reality through simple advancements in integrated circuits, sensors, and open-source software.   How can Microchip Technology fuel the ethos of the Do-It-Yourself Maker movement?

This week's EYE ON NPI features a new 'everything' sensor, the Sensirion SEN66 Environmental Sensor Node (https://www.digikey.com/en/product-highlight/s/sensirion/environmental-sensor-node-sen6x) . This is a highly-anticipated update to the SEN5x (https://www.digikey.com/en/videos/s/sensirion/eye-on-npi-sen54-environmental-sensor-node) goes hard on gas sensing, with VOC, NOx and CO2 sensors built in. You can even update to the SEN68 and get formaldehyde HCHO sensing! What we like about this series is the complete solution for all kinds of environmental sensing with a single cable. Sensirion is one of our fav sensor companies: from classics like the SHT45 (https://www.adafruit.com/product/5665) to the popular SGP30 (https://www.adafruit.com/product/3709) and the high quality SCD30 (https://www.adafruit.com/product/4867) we have made breakouts for many-a-sensor from this company. Lately they've started to do fully integrated products - like the SEN5x series (https://www.digikey.com/en/videos/s/sensirion/eye-on-npi-sen54-environmental-sensor-node) that we covered earlier on EYE ON NPI. The SEN54 series has particulate matter (PM1, PM2.5, PM4, PM10) dust sensing, plus temperature, humidity, volatile organic compounds (VOCs), with the SEN55 adding NOx. We saw this sensor often paired with an SCD30 (https://www.digikey.com/short/d1h3t1n4) or SCD4x (https://www.digikey.com/short/zmh2zjz3) to add CO2 sensing. Those folks will like the look of the SEN6x series as now we get CO2 sensing in all but the lowest-cost SEN60. One thing to note with CO2 sensing is that once a week it needs to 'self-calibrated' by letting it sense fresh outdoor air which will be ~400ppm. This isn't a bad idea for your health either. Another new sensor added in the upcoming SEN68 is formaldehyde, which integrates the SFA30 (https://www.digikey.com/short/2d5fb8rt). If you've used the SEN5x series, (https://www.digikey.com/en/videos/s/sensirion/eye-on-npi-sen54-environmental-sensor-node) you're probably familiar with their connection interface: a JST GH 6-pin cable is used to connect and provide power and I2C data connection. However, one thing to note is that the cable is the same but the pinout has changed. Power is now 3.3V instead of 5.0 and there's no UART interface, so the SEL pin is not available. For that reason, if you'd like to use the same cable, go for it - but the circuitry will need to change...for example we're revising our SEN5x breakout (https://www.digikey.com/short/h0jffnm2)! We like that, just as with the SEN5x series, the SEN6x (https://www.digikey.com/en/product-highlight/s/sensirion/environmental-sensor-node-sen6x) uses plain I2C to communicate. This makes it easy to integrate with any microcontroller or microcomputer, and the added CRC helps avoid accidental data corruption from EMI or loose cables. The interface is not just to each individual sensor - there's only one I2C address and command structure and once you initialize the sensor you can read all values at once for 'timestamped' consistency. The commands are easy to implement, but if you want a head-start, check out the Sensirion GitHub account (https://github.com/Sensirion?q=sen6&type=all&language=&sort=), they have code in C and Python for a 5-minute quick start. Excited to check this fancy new combo-sensor out? You're in luck because DigiKey has the Sensirion SEN66 Environmental Sensor Node (https://www.digikey.com/short/0d4jt424) in stock right now for immediate shipment! Order today and DigiKey will ship it you in an instant - you will be sensing up a storm by tomorrow afternoon! See at DigiKey https://www.digikey.com/short/0d4jt424 See Sensiron's video https://www.digikey.com/api/videos/videoplayer/smallplayer/6371044300112 Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI is Pretty Sweet Of Course! It's the Infineon Technologies PSOC Control C3 Microcontroller Line (https://www.digikey.com/short/8cw3wpp8) a souped-up microcontroller that is a perfect choice for engineers who need to do some motor control while also managing buttons, LEDs, displays, and other product requirements all on one chip. With a the high-speed ADCs on board, you can manage your BLDC motors and handle the feedback loop in firmware for dynamic tuning without the expense of a specialized co-processor. The PSOC Control C3 series comes in two flavors, the Entry and Main line chips (https://www.infineon.com/cms/en/product/microcontroller/32-bit-psoc-arm-cortex-microcontroller/32-bit-psoc-control-arm-cortex-m33-mcu/psoc-control-c3m/). Both are based on the Arm Cortex M33 which means you know that your CMSIS-based code will be an easy compile and you can use existing pre-compiled libraries. The M33 line is an upgrade to the M3 and M4, giving you the same or better clock speeds and FPU/DSP commands you get with the M4 plus TrustZone and better power efficiency. The Entry line runs at 100MHz, with max 256k Flash 64K SRAM, 10-bit DAC, a 6 MSPS 12-bit ADC, 16 x 16-bit + 4 x 32-bit TCPWMs and a "CORDIC math coprocessor". The Main line can run at 180MHz, same Flash/SRAM and TCPWMs, and has a 12 MSPS ADC plus 4-channel HRPWM with less than 100ps resolution. Both come in 48 and 64 pin TQFP/QFN varieties, the Main line also has an 80-pin version. (There will also apparently be a Performance line, so far un-announced, which may offer more memory / higher frequency). Both have FPU/DSP support, so you'll be able to process the 6 or 12-MSPS ADC data quickly. And the CORDIC processor (https://en.wikipedia.org/wiki/CORDIC) optimizes trig functions like sin/cos/tan/ln so you don't need lookup tables for performing these floating point calculations. These are particularly useful when handling motor motion calculations since they are often sinusoidal and we need to convert to-and-from the ADC measurements to the precision PWM timers. There's a huge selection of Arm processors out there, but the PSOC Control C3 has the best peripherals for motor control: it's rare to see 12MSPS 12-Bit ADC plus so many 16-bit and 32-bit timers with high-speed PWM. The CORDIC co-processor especially will make managing BLDC or Stepper motors a breeze. Plus you still get all the peripherals you would expect of a microcontroller: I2C, UART, SPI, CAN bus, DAC, IRQs, and lots of GPIO. That means you can handle all the other stuff your product has to do while also managing the motor in the background, saving you lots of space and money in BOM costs and fewer integration woes when trying to communicate between a main processor and a motor-control co-processor. The KITPSC3M5EVK eval board (https://www.digikey.com/en/products/detail/infineon-technologies/KITPSC3M5EVK/25880112) is in stock right now if you want a ready-to-go kit at a good price. It comes with 'Arduino shield compatible" pinouts plus a USB / debug interface, and MikroBus connector for expansion. You can also pick up just the bare chip - for example the PSC3M5FDS2ACQ1AQSA1 (https://www.digikey.com/short/8cw3wpp8) is a fancy version with 256K of flash, the 12 Msps ADC, and hall encoder in a TQFP-64 package. It's in stock now at DigiKey for immediate shipment! Order today and you can have a powerful microcontroller with excellent motor feedback control in your hands by tomorrow morning.

This week, we were all over the place with a bunch of different designs and experiments. After last week's analysis of the TLV320DAC3100, we made some updates to the design and re-booked prototype PCBs. We also designed a triple-matrix bonnet: with our latest work on getting HUB75 RGB matrices working on the Raspberry Pi 5, we can now do matrix control on the latest Pi 5 chip. But we're limited by the RP1 chip, so to get big displays going, we'll need multiple strands—these don't use significantly more bandwidth because half of the pins are shared. Finally, we ended the week by getting another older prototype working: the SAM-M8Q is an entry-level all-in-one GPS from u-blox. It comes with both UART and I2C interfaces, plus a built-in antenna, so it's ready to go out of the box. The NMEA interface is trivial, but we also wanted to try out the UBX interface, and thankfully, Claude 3.7 was able to vibe-code it for us in a jiffy.

Heeeey, we're just having a super chill vibe here at the desk of Ladyada—writing a driver for the uBlox M8Q https://blog.adafruit.com/2024/09/10/a-mini-gps-from-ublox-with-i2c-and-uart/ which has both I2C and UART interfaces. As expected, it can do everyday NMEA output, but it can also do UBX, a "compressed" protocol for advanced data reads and writes over I2C/UART—or even SPI on some other chips. However, the UBX protocol is a hugely complex driver to implement, with dozens of commands and hundreds of flags. But why stress when you can viiiibe? We're using this beast of a spec as an excuse to try out the new Claude 3.7, which is doing great at chomping through the UBX documentation roughage and giving us some nice code on the other side. Within an hour, we're able to connect and switch to UBX mode by sending a well-formed message and receiving an ACK. What we like about coding with a good LLM is that it does the work we sometimes get lazy over, like handling various error conditions, timeouts, and verbose error messages. Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ ----------------------------------------- #ai #gps #coding

This week's EYE ON NPI is a Texas-two-steppin' motion controller that takes your 2-axis motion control to the next level: it's ADI/Maxim/Trinamic's TMC5272 Dual-Axis Stepper Motor Controller and Driver IC. We've been checking out many of Trinamic's great stepper motor driver chips lately and this one is the latest generation, with 2 drivers, plus motion control, for advanced usage even on boards that don't need real-time GPIO toggling for steps. Trinamic is definitely not a group that 'rests on their laurels': every year they are coming out with even more improvements to their awesome stepper motor drivers. This chip has 250 pages of datasheet and each page details yet another improvement or setting that will make your mechatronics fast, silent, and efficient. What sets the TMC5272 (https://www.digikey.com/short/0mq250r7) apart? Well, the first big thing is you get double the fun with two full stepper drivers for X and Y axis support. The voltage range is 2-20V, so good for low to medium voltage motors. The tradeoff is you can only get 1.5A max peak current, 1.1A sine wave, but for most users that don't have massive steppers that is perfectly fine. There's also a lot more 'smarts' in this stepper than the ones even from a couple years ago: 8-point motion control, no-loss/no-sense-resistor current management, 2D trajectory management over two axes, encoder or reference switch inputs, sensorless standstill motion detection. Of course all the fixin's you expect from the previous generations are there: silent stepping, UART and SPI and step/dir interface, stallguard, 1 to 256 microstepping, and diagnostic output But, it's in a 3x3mm WLCSP package: this means you'll need at least a 4 layer board and plugged vias. It also means heat dissipation might be more challenging than the drivers with the big ground pads. However, a nice tradeoff is that there is internal 'lossless' current sensing, so no chunky resistors are required. The upside of a WLCSP is that we have lots more pins for tons of interfaces. Each driver can run one bipolar stepper motor, and has multiple interfaces for control. As usual there's the STEP/DIR interface. This is great for usage with older designs that expect to toggle GPIO on each step. However, the S/D pins are shared with some of the cool sensors/encoders/switches. Plus all the really cool things the chip can do are too complex to adjust with just a few GPIO, so to really get the most use you'll need to use one of the packetized interfaces: UART or SPI. UART is great if you happen to only have USB for your computer: you can always just use a USB-serial converter, and the controller can be daisy-chained for multiple drivers per UART. If you have extra GPIO and/or a dedicated SPI port, we would recommend that since it's much faster and you can easily add more chips with one chip-select per. Some of the cool things you can do via the interface include a 8-point ramp controller: instead of stepping each motor and dynamically adjusting the micro-steps for speed/precision, the TMC5272 can do it all on its own. It can also handle knowing 'where' it is on an axis bar, by using the built in homing support. Homing can be done either by using the sensorless 'StallGuard' (https://www.analog.com/en/lp/001/building-better-stepper-motor-system.html) or with reference switches. You can wire the switches directly to the TMC5272 - good if you want to have slow motion homing since you don't have to whack into the end of the axis - and then let the chip manage where it is. Then you can tell it you want to move and when you want to get there, and the TMC will take care of the rest. For ultra-accurate motion control, you can connect an external optical or magnetic encoder to the motor shaft that will tell you exactly when a step has occurred. There's also a neat back-EMF sensor that can tell when the motor has moved while 'disabled' - good to know when you will need to do another homing step after re-enabling the motor. There's also an TMC5272-EVAL-KIT eval board that you can plug-n-play for instant stepper motor usage (https://www.digikey.com/en/products/detail/analog-devices-inc-maxim-integrated/TMC5272-EVAL-KIT/22107596), it works instantly with the TMCL IDE for trying out the various programmable settings (https://www.analog.com/en/resources/evaluation-hardware-and-software/motor-motion-control-software/tmcl-ide.html) and turn the motor via the TMCL IDE which sends UART/SPI commands over their USB driver board, so it's perfect for verifying the performance with your desired motors. If you want double the pleasure, double the fun of double-motor driving, you can pick up the ADI/Maxim/Trinamic's TMC5272 Dual-Axis Stepper Motor Controller and Driver IC (https://www.digikey.com/short/0mq250r7) from DigiKey today - it's in stock & ready to ship immediately! Place your order now & by tomorrow morning you can be step-step-stepping to the most advanced 2-axis motor controller design you've ever seen.

Join Scott as he continues polishing CircuitPython on Zephyr and answers questions folks ask. Visit the Adafruit shop online - http://www.adafruit.com Thanks to dcd for timecodes: 0:00 Getting started 1:40 Welcome - and grabs the macropad with rp2040 microprocessor 4:00 discuss debug connections 6:00 finding the schematic 8:08 progress redirected towards building zephyr in CI 9:43 CI and scheduler 12:00 tricks for building on windows 13:50 circuitpython/ports/zephyr ( fetching blobs for CI builds ) 15:08 UART and USB I/O with ports/zephyr-cp 19:53 using sublime merge to review recent changes 24:05 on big flaw in ninja - concurency management 25:00 back to zephyr2cp.py 26:00 split out USB vs storage 28:40 adafruit usb_vid_pid.csv tracking 30:35 commit recent changes 32:30 pre-commits are failing - why? 34:00 scheduler failed? 37:25 trying out the new sublime outline extension 38:00 shared_bindings_matrix.py 42:26 changing autogenede file generation 43:03 git mv ST autogen files 46:00 boldly git rm */*..... and regenerate them 47:48 TOML Kit (tomlkit ) allows comments! 50:12 more cptools work 51:00 stm32 discovery kit 51:44 RA8 may be in the future :-) 57:00 review stm32h7b3i_dk.dts 1:07:00 continue work on renesas_ek_ra8d1 port 1:24:00 what goes onto the second core of disimilar dual core systems like Portenta 1:31:48 hello from ra8 zephyr! 1:35:16 ra6 building too! 1:35:50 see if "make html" works 1:38:20 need to exclude the zephyr docs 1:42:00 peek at MCUmgr - Zephyr project docs 1:43:20 add zephyr-cp docs to supported_ports.rst 1:44:00 update README.md in zephyr-config 1:46:00 pushed to github tannewt/circuitpython.git 1:50:57 look at things that broke the build 1:55:07 commit a few changes - to be squashed later :-) 1:59:30 next steps in the zephyr thread 2:01:42 protothreads discussion 2:02:48 tasks for next week - (nordic) 2:05:17 wrap up - but first - investigate build failures :-) 2:10:00 re-wrap up :-) ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Mara Bettiol, Presidente de la Unión de Aseguradoras de Riesgo de Trabajo, UART @Delarcopolitico 16-1-2025

We've been testing the Trinamic/Maxim/Analog/WeylandYutani TMC2209 (https://www.digikey.com/short/8r5m38h8) breakout we designed, and it's working great - the step/dir interface plus the micro-step select allows a microcontroller to control a stepper with just GPIO and true-to-its-name it is a very silent stepper driver, much quieter than the A4988 (https://www.digikey.com/short/tfjt88dd)! There are a few different I/O pins on the TMC: Index tells you when a full step is completed, which is handy to know when you want to change stepper modes on the fly. Diag lets you know when a power or motor failure has occurred. It can also tell when the motor has stalled if it's configured to. Finally, and most interestingly, is the UART interface: this unidirectional pin lets you read and write configuration registers, set 1-128 microsteps, change current limiting, and detect stalls for 'auto homing'. So far, everything works; we're just going to swap the direction of the potentiometer so it twists clockwise to increase the current limit and book PCBs! Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ ----------------------------------------- #tmc2209 #steppermotordriver #silentdriver

Mara Bettiol, presidente de la Unión Argentina de Riesgos del Trabajo, dialogó con Pablo Wende sobre el aumento de los juicios laborales.

We covered a DMX transceiver on EYE ON NPI (https://www.youtube.com/watch?app=desktop&v=X12v_qLC4-M) a few weeks ago, and after learning about how DMX works, we decided to make a DMX FeatherWing much like the MIDI 'Wing (https://www.adafruit.comproduct/4740). We'll need a chip, a hardware UART, and a couple of GPIOs. We'll also need two DIN connectors, one for the input and one for the output. We're sure that we can get some simple through-hole components through DigiKey; let's look for both the "input" and "output" directions for the DMX connectors. See the chosen part on DigiKey https://www.digikey.com/short/d4mnrr59 ----------------------------------------- Visit the Adafruit shop online - http://www.adafruit.com LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/

Today on Elixir Wizards, Bryan Green shares how he transformed a vintage 1930s rotary phone into a fully functional cell phone using Elixir, Nerves, and a mix of hardware components. Bryan shares the highs and lows of his project, from decoding rotary dial clicks to troubleshooting hardware issues with LED outputs. He explains why Nerves was the perfect fit for this project, offering SSH access, over-the-air updates, and remote debugging. You'll also hear how Elixir's concurrency model helped him manage hardware inputs and outputs efficiently using GenStateMachine and Genservers. Elixir and Nerves really shine when modeling real-world systems. Bryan dives into how he used a finite state machine to track the phone's states and handled inputs from the rotary dial and hook switch via GPIO. For hardware enthusiasts, Bryan's advice is to embrace this “golden age” of DIY electronics. Whether you're experienced with embedded systems or just curious on where to start, Bryan's VintageCell can inspire you to tinker with a hardware engineering project. Key topics discussed in this episode: Advantages of functional programming and immutability in Elixir Building hardware projects using Adafruit components Why Nerves was the best choice for the VintageCell project Interpreting rotary dial clicks using GPIO and circuits.gpio Troubleshooting hardware issues with LED diagnostics Challenges in optimizing wiring and PCB design Benefits of Nerves: SSH access, OTA updates, and remote debugging Modeling real-world systems with Elixir and Nerves Implementing a finite state machine with GenStateMachine Managing input with Genservers for rotary dial and hook switch Leveraging community resources like Discord, Elixir Slack, and forums Practical advice for keeping hardware projects on track Potential applications from SMS servers to home automation Links mentioned: Vintage Cellphone: Bridging the Past and Future with Elixir (https://www.youtube.com/watch?v=U4hetzVpjmo) Seven Languages in Seven Weeks https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/ Seven More Languages https://pragprog.com/titles/7lang/seven-more-languages-in-seven-weeks/ Node.js https://github.com/nodejs https://nerves-project.org/ https://www.arduino.cc/ Adafruit Circuit Playground https://www.adafruit.com/category/965 Adafruit 3D Printed Star Trek Communicator https://learn.adafruit.com/3d-printed-star-trek-communicator Adafruit FONA 3G Cellular + GPS Breakout https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview https://github.com/elixir-circuits/circuitsgpio Nerves SSH https://hex.pm/packages/nervesssh OTA (over-the-air) Updates with NervesHub https://www.nerves-hub.org/ https://github.com/kicad Waveshare 4G Hat for Raspberry Pi https://www.waveshare.com/sim7600e-h-4g-hat.htm https://hexdocs.pm/genstatemachine/GenStateMachine.html https://hexdocs.pm/elixir/GenServer.html https://www.sparkfun.com/ https://www.digikey.com/ USB-C Gadget Mode with Nerves https://github.com/nerves-project/nervessystemrpi4/issues/18 https://livebook.dev/ https://codestorm.me/ https://github.com/codestorm1/vintage_cell/ Special Guest: Bryan Green.

This week's EYE ON NPI is Gon' Give It To Ya (https://www.youtube.com/watch?v=fGx6K90TmCI), it's the MaxLinear half duplex RS-485 transceivers (https://www.digikey.com/en/product-highlight/m/maxlinear/rs485-422-serial-transceiver) an easy way to convert your every day UART serial connection to a RS-485 or RS-422 data link layer (https://en.wikipedia.org/wiki/Data_link_layer). We've seen RS-485 most often in DMX512 lighting networks (https://en.wikipedia.org/wiki/DMX512), where there are up to 512 lights/devices connected up to a control board 'universe'. Each one is individually settable. While these could have used CAN bus, or Ethernet, DMX ended up using RS-485 for simplicity and low cost. It's super easy and inexpensive to convert between UART and RS-485 using a MaxLinear chip because the encoded data is the same as 8N1 serial. Each line of RS-485 consists of a differential signal pair, A + B, where A is inverted from B and B's logic level is the bit being sent. This means it can go farther and more reliably than RS-232 (https://en.wikipedia.org/wiki/RS-232) which is single-ended and just has wide voltage swings. However, instead of having ground, RX and TX for connection between two data ports - DCE and DTE - RS-485 cables as used in a DMX setup have the A and B wires plus ground. This means RS-485 going to survive signal degradation better than RS-232 but the downside is its uni-directional. That's fine for lighting rigs because you just want to tell the light "turn blue" or fog machine "on". RS-485 is also driven quite fast, the DMX standardizes on 250kbps comfortably, whereas RS-232 does best at 115.2kbps or less. If you really want, it is possible to convert the line into a bi-directional setup as long as the transmitter knows when to expect signal from a remote device. Simply sent the Driver Output Enable pin of the MxL8321x (https://www.digikey.com/short/dm7zp1hf) low to tri-state the output driver buffer, then set Receiver Output Enable line low, this will swap the device from being a transmitter to a receiver. The light on the other side will do the opposite, setting both pins high to turn into a transmitter. It can then send signal back down the line. Technically this is the difference between RS-485 and RS-422 (https://en.wikipedia.org/wiki/RS-422), which is really just the differential-ized RS-232 part without output/input enable and thus does not have the ability to change 'direction'. For RS-422 you'll probably want two MxL8321x's (https://www.digikey.com/short/dm7zp1hf), one for each direction. While used often for DMX512, you don't have to use the DMX protocol with your MxL8321x RS-485 converters: after all it's just a new physical layer for UART serial, so if you have any design that already uses serial: GPS, MIDI, microcontroller communication, radio modules, you can pop these in between for no-fuss extension from a few inches to many meters, up to 500kbps. The MxL8321x uses 3.3v or 5V power/logic so its easy to integrate into any existing design. The family also comes in a few package sizes and speed variants, from the MxL83211's (https://www.digikey.com/short/55bp41c9) 250kbps to the MxL83214's 50Mbps (https://www.digikey.com/short/zrb42hdh). Pick the slowest one you can use to get the best line drive strength to reduce EMI and reflections. You'll also need to set up a terminator (https://www.ti.com/lit/an/snla044b/snla044b.pdf) on the end of the transmission line. If you're looking to add RS-485 or RS-422 support to your next design, MaxLinear is here to Give You What You Really Want (https://www.youtube.com/watch?v=0MdAbsd0HmI) with their wide range of half duplex RS-485 transceivers. And best of all, DigiKey has them all in stock for instant shipment to your door. Order today and you'll have your MxL8321x in hand by tomorrow morning for instant integration.

Entrevista de Pablo Wende a Mara Bettiol, presidente de la Unión de Aseguradoras de Riesgos del Trabajo, a propósito del aumento de los juicios vinculados a los accidentes laborales.

JP's Product Pick of the Week 6/25/24 CH9328 UART to HID Keyboard Breakout RECAP https://www.adafruit.com/product/5973 Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week we had the idea of making a breakout for IrDA data transfer: this is an older infrared bi-directional protocol that can mimics UART-like behavior with RX and TX running at 115.2Kbps. It could be useful for projects where you want to make a link between two boards but don't want the expect, complexity or overhead over RF. Simply transmit and receive whenever the two are within about a meter of distance. This used to be used for simple data transfer between computers, handhelds, or watches. They've phased out of popularity in the last couple decades... can we still get IrDA transceivers at DigiKey? Let's find out! See the chosen part on DigiKey https://www.digikey.com/short/jrn4wzqb Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Seeed Studio Round Touchscreen Display for Xiao / QT Py (0:08) https://www.adafruit.com/product/5771?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts Adafruit Switchable USB Type A to C Breakout Board (2:10) https://www.adafruit.com/product/5972?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts Adafruit CH9328 UART to HID Keyboard Breakout (5:12) https://www.adafruit.com/product/5973?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts ----------------------------------------- New nEw NEWs New Products, News, and more: https://www.adafruit.com/newsletter #newnewnew Shop for all of the newest Adafruit products: http://adafru.it/new Visit the Adafruit shop online - http://www.adafruit.com Adafruit on Instagram: https://www.instagram.com/adafruit LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Seeed Studio Round Touchscreen Display for Xiao / QT Py (0:08) https://www.adafruit.com/product/5771?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts Adafruit Switchable USB Type A to C Breakout Board (2:10) https://www.adafruit.com/product/5972?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts Adafruit CH9328 UART to HID Keyboard Breakout (5:12) https://www.adafruit.com/product/5973?utm_source=youtube&utm_medium=videodescrip&utm_campaign=newproducts ----------------------------------------- New nEw NEWs New Products, News, and more: https://www.adafruit.com/newsletter #newnewnew Shop for all of the newest Adafruit products: http://adafru.it/new Visit the Adafruit shop online - http://www.adafruit.com Adafruit on Instagram: https://www.instagram.com/adafruit LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI is more like an "EYE ON Ladyada's Desk" because while the ESP32-C6 has not yet been featured by DigiKey on their New Products Page (https://digikey.com/new) we're starting to spend a little time checking out this new Espressif chip - the ESP32-C6 series - and the ready-to-use modules available from DigiKey, such as the ESP32-C6 WROOM (https://www.digikey.com/short/8vj302rf). We use the Espressif family of chips (https://www.digikey.com/en/supplier-centers/espressif-systems) in tons of our designs: they're inexpensive, powerful, have excellent low-power sleep modes, and all come with fast and secure WiFi functionality, so they make for excellent IoT devices. Starting with the ESP32 in 2016, a follow-up to their 'accidental microcontroller' the ESP8266, Espressif has focused on Tensilica-based microcontrollers with built in WiFi and/or Bluetooth radio. By combining the silicon for radio and processor, they've been able to come in at disruptively-low pricing (https://en.wikipedia.org/wiki/Disruptive_innovation) - with chips ranging from $1-$3 and modules from $2-$6. Over the years they've branched out to include improved BLE, native USB, and many other peripherals like CAN and TFTs. They've also dabbled in RISC-V, adding a co-processor to the ESP-Sx series and finally going 'full RISC-V' in the ESP-Cx series. Now, with the C6, they're adding a new protocol to the mix: in addition to updating to WiFi 6 and BLE 5, the C6 also can talk 2.4GHz 802.15.4 which means it can communicate with Zigbee devices (https://en.wikipedia.org/wiki/Zigbee) including Thread and... Matter (https://en.wikipedia.org/wiki/Matter_(standard)) an open-source connectivity standard for smart home and Internet of Things devices from the Connectivity Standards Alliance (https://csa-iot.org/) formally the ZigBee Alliance. Matter is, hopefully, not just the latest, but the last attempt at creating a unified standard for home/business/industrial IoT and automation. It is a higher level protocol that runs on top of WiFi, BLE, or Thread - Thread being a replacement for Zigbee that also runs on 802.15.4 radios. That means that if you want to create a Matter device, you can use any of the three transports (https://learn.adafruit.com/alltheiot-transports) supported by the ESP32-C6: WiFi is medium range, medium cost, high power, medium complexity and high data rate: once you set up the access point, and as long as it's plugged into the wall, it tends to work very well. BLE is lower range, low cost, low power and medium complexity since you still need to pair to another device. Thread/ZigBee is medium range, low power, low cost, and high complexity since you need a gateway to use. As of this post/video, the Matter API for Espressif chips is only available through the ESP IDF SDK (https://github.com/espressif/esp-matter), and not in Arduino yet, although there is an open issue being worked on (https://github.com/espressif/arduino-esp32/issues/7432). However, if you aren't up for using the ESP-IDF for programming, you can check out ZeroCode (https://zerocode.espressif.com/) Espressif in-browser code generation, compilation and uploading system. At this time only '2-chip' setups are available for code generation, the 'bare' ESP32-C6 support is coming soon, but we tried out the IoT ExpressLink configs (https://www.espressif.com/en/solutions/device-connectivity/esp-aws-iot-expresslink) which have UART commands for setting up and tearing down the Matter device. After filtering for ExpressLink, we selected the C6 Mini module we have on our Feather prototype. A schematic is generated to show how the module will need to be wired for the UART access. Then you can program it directly in the browser. The unique Matter identifier is turned into a QR code: you can scan this with your mobile phone to add the device to your home's Matter-hub. Finally - check out the AT command reference (https://docs.aws.amazon.com/pdfs/iot-expresslink/latest/gettingstartedguide/expresslink-gsg.pdf) for how to start the Matter subsystem and send/receive data. As Thread/Matter gets adopted as the next-gen IoT transport protocol, the Espressif ESP32-C6 (https://www.digikey.com/short/8vj302rf) is positioned to be the perfect module for fast integration and low cost. With pre-certified and encased modules, plus a ready-to-go SDK, you can spin up a prototype product in just a couple days. We recommend starting with the ESP32-C6-WROOM-1-N8 module to start, with tons of flash memory, you can always downgrade if you end up only needing 4MB of Flash. There's also an affordable ESP32-C6-DevKitC (https://www.digikey.com/en/products/detail/espressif-systems/ESP32-C6-DEVKITC-1-N8/17728861) that has all the basics on already for instant bring-up. Order from DigiKey today to get your ESP32-C6's by tomorrow afternoon so you can be ready for the future of IoT with WiFi, BLE 5 and Thread/Matter support baked in.

this prototype board allows folks to use many Grove devices with Feather boards! it fits nicely on top and has 3 Analog/Digital connectors, 1 UART connector and 2 I2C connectors. Not a ton, but enough to get many small projects going. we even managed to fit a vertical Stemma QT port on the end for another I2C connection. we think this board will be handy for bridging two great standards! Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI has us pitter-pattering on our tippy-toes, it's the newest and bestest stepper motor driver we've seen, the Analog Devices' TMC5240 Stepper Motor Controller and Driver IC (https://www.digikey.com/short/rt0zpt4v) from the Trinamic division at ADI! Trinamic is famous for their stepper motor driver chips, which we see often in 3D printers (https://www.analog.com/en/design-center/evaluation-hardware-and-software/evaluation-boards-kits/trams.html), XY gantries and other robots that need fast motion control. Stepper motors are commonly used when we need continuous rotation for linear movement through a rack and pinion. We've got huge steppers in our pick and place machine, and most makers are going to be familiar with them in CNC devices like laser cutters, 3D printers or milling machines (https://www.digikey.com/en/product-highlight/b/bantam-tools/desktop-pcb-milling-machine) - servos will be controlling the X, Y and Z axes as well as any extruder. And if you have one of these devices you know they can be loud and slow: in order to get good precision from a stepper we need to micro-step, so that instead of a standard 200 steps per rotation, we get 16*200 or 256*200 (https://www.analog.com/en/products/landing-pages/001/optimizing-stepper-motors-microstepping.html). Microstepping gets us that beautiful precision, but adds a ton of noise because now there's a PWM signal that is vibrating the motor (https://www.analog.com/en/products/landing-pages/001/secret-silent-stepper-motor-control.html). That's where Trinamic's StealthChop2 secret sauce comes in: The StealthChop chopper modulates the current based on the PWM duty cycle, resulting in a perfect current sinewave with straight crossing of the zero-current level. The constant PWM frequency minimizes current ripple and, by extension, any Eddy current that may be found in the stator, reducing power loss, and increasing efficiency. The StealthChop chopper also removes variations of the chopper frequency, or frequency jitter, so that only the commanded variations remain. Thus, at a 50% PWM duty cycle, the current is actually zero. The result of all this is silent stepper motor operation at a standstill and at low to moderate speeds. We've covered Trinamic's TMC2226 stepper driver before on EYE ON NPI (https://blog.adafruit.com/2020/06/18/eye-on-npi-tmc2226-sa-ultra-silent-stepper-motor-driver-eyeonnpi-digikey-adafruit-digikey-adafruit-trinamic_mc/) and that chip mimic'd the common configuration for stepper motor drivers: set the microsteps with GPIO and then use a DIRection and STEP pin. That makes it easy for integration with any hardware, you just need some GPIO pins, but it means that you have to do the motion control yourself. And, once you have 2 or 3 motors, motion control code can get really complicated: you have to tune and configure ramp ups from idle to fast run, and back down so there isn't any jerky motion. What's really cool is that the TMC5240 has built-in motion-control! You set some configurations and then can tell it what position or velocity to achieve, and the microstepping is done for you. It even handles encoder reading, mechanical stall detection, and end-stop switch interrupts for you so you don't slam into the side of the machine by accident. To do this, the TMC5240 has a full register and command set, that can be controlled with SPI or UART - with UART there is node addressing required, but perhaps this is easier to integrate with low-pin microcomputers. For both, commands are sent for configuring everything from stall current, to motion control, to individual steps to temperature reads. Speaking of which: the TMC5240 come in two packages: QFN and TSSOP. TSSOP has a big thermal pad at the bottom for better dissipation, QFN is smaller. With either, use plenty of vias, a 4-layer design with dedicated 2 oz copper ground planes to keep the motor driver cool: these can handle 5-36V at up to 2A per leg, so they are throwing a lot of current around. You can pick up bare TMC5240 chips (https://www.digikey.com/short/vhvtnjbw), basic breakout boards (https://www.digikey.com/en/products/detail/analog-devices-inc-maxim-integrated/TMC5240-BOB/21292888) and eval boards (https://www.digikey.com/en/products/detail/analog-devices-inc-maxim-integrated/TMC5240-EVAL/17878664). Since you have to use the SPI/UART protocol to communicate, we recommend checkout out the pyTrinamic library (https://github.com/trinamic/PyTrinamic) which has added support to the TMC5240 (https://github.com/trinamic/PyTrinamic/blob/master/pytrinamic/ic/TMC5240.py) so you can hit the ground running / stepping. Order up some of these silent stepper drivers today and you'll get them in hand by tomorrow afternoon, you'll save tons of time on your next robotic or mechatronic project thanks to the tons of built-in capabilities on the TMC5240!

if you got a Pi 5 (https://www.adafruit.com/product/5812) and you want to log in or debug without ssh'ing or using a monitor and keyboard - there's now a super fast and easy way to get into the UART console - thanks to the new JST SH 3-pin 'UART' port nestled between the HDMI connectors. Use your Pico Probe (https://www.adafruit.com/product/5699) and connect the 3-pin cable to the 'U' port - the probe board will appear as a COM/serial port, and you can open it up with any terminal program. we love using it for kernel debugging because the connection stays open between reboots and you'll get all messages directly printed, plus the early boot messages...even ones before the firmware is loaded or the display comes up. Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

The new Raspberry 5 has a new UART port, which is great because the first 4 Pi's used the hardware serial as a UART - which made debugging hard when using something like a GPS. However, unlike the GPIO header UART, this connector is SMT, and much smaller than 0.1" pitch. While we can always contact the Pi folks for a part number, let's figure out what connector it is just using a pair of calipers - then find a cable that will plug in that we can use to get that tasty RX/TX data out! See the chosen part on DigiKey https://www.digikey.com/short/bf8r7j8j

This week's EYE ON NPI is Big In Japan, it's the Renesas RA Microcontroller Series (https://www.digikey.com/en/product-highlight/r/renesas/ra-mcus) available at DigiKey in a wide range of sizes and configurations. With the chip shortage easing up, it's a great time to look at what chips to use for your next design. And while we have covered a ton of Arm Cortex microcontrollers on EYE ON NPI (https://blog.adafruit.com/?s=eye+on+npi+cortex), we haven't yet taken a look at Renesas' RA offerings. Renesas is a company created by the merging of the silicon design groups from Hitachi, NEC and Mitsubishi Electric (https://www.youtube.com/@RenesasPresents), so not surprisingly it's very Japanese-focused and used a lot in Japanese electronics companies but not as often in the USA. However, it's always good to have more competition and with the Arm Cortex standard, it's easy to move from one chip vendor to another without having to do a lot of re-targeting. So let's take a look! We saw Renesas highlighted over on DigiKey (https://www.digikey.com/en/product-highlight/r/renesas/ra-mcus) and the same day also received our new Early Access Arduino UNO R4 Minima (https://store.arduino.cc/pages/unor4) for us to use in making sure all our libraries work. The UNO R4 is the long-awaited upgrade to the popular R3 (https://www.digikey.com/en/products/detail/arduino/A000073/3476357) which came with an 8-bit, 16 MHz, 16 KB Flash, 2KB SRAM chip. While Arduino has come out with many other dev boards since then, the UNO hadn't got an update to 32-bit in a while. The challenge? Finding an affordable 32-bit chip with native USB, Cortex M3 or M4, good software SDK and 5V compatibility. That last part is the hardest, for example there's no ATSAM chip that has both USB and 5V compliance. An acquaintance just came back from a holiday in Japan and she mentioned that "everything is just...a little better there than here in the US!" and that's how we felt when looking at the RA4M1 datasheet (https://www.renesas.com/us/en/document/dst/renesas-ra4m1-group-datasheet) The RA4M1 series is a great pick for an 8-bit upgrade. The core is a Cortex M4 which means you're going to get good speedy computation with built in floating point and DSP instructions. For flash memory, 256 KB stores your code and there's a separate 8KB "EEPROM" like section. For RAM, 32 KB is available. It's got all the peripherals you expect such as timers, DMA, ADCs, USB full-speed, I2C, SPI, and UART as well as some upgrades you can't get on 8-bit chips. For example, the ADC is 14 bits, and there's also a 12-bit DAC. There's 4 internal op-amps and 8 total timers! There's two I2Cs, SPIs and UARTs and also CAN bus. A built in RTC is a true real time clock, with battery backup. There's also capacitive touch sensing and a segment LCD controller - our friend Joey Castillo will love that! (https://www.joeycastillo.com/objects/lcdwing/). In addition - we also saw some really beautiful silkscreen board designs for the Renesas Gadget Series (https://www.renesas.com/us/en/products/gadget-renesas) as well as an online code editor for compiling for the chip series. (https://www.renesas.com/us/en/products/gadget-renesas/boards/gr-sakura/project-sketch-on-web-compiler) We're hoping some of that work gets revitalized with the many makers folks who will be hacking with the R4. If you can't wait to try the Renesas RA4M1 (https://www.digikey.com/short/wt4b872q) chip out, Digikey has an affordable RA4M1 dev board in stock (https://www.digikey.com/short/3qzr0bbw) which comes with a J-Link on-board debugger with separate USB port, a few onboard peripherals, current sensing jumpers, and tons of GPIO so you can prototype your design quickly. Once you've got your design sorted out, chips are available for immediate shipment in TQFP (https://www.digikey.com/short/f3m2pffz) and QFN (https://www.digikey.com/short/fn2m9bbm). Order these from DigiKey and you will say "Konnichi wa" (https://en.wikipedia.org/wiki/Konnichiwa) to a new family of microcontrollers by tomorrow morning.

Bryan and Adam are joined by Oxide colleagues Arjen, Matt, John, and Nathaneal to talk about the management network--the brainstem of the Oxide Rack. Just as it ties together so many components, this episode ties together many many (many!) topics we've discussed in other episodes.We've been hosting a live show weekly on Mondays at 5p for about an hour, and recording them all; here is the recording from May 8th 2023.In addition to Bryan Cantrill and Adam Leventhal, we were joined by Oxide colleagues Arjen Roodselaar, Matt Keeter, John Gallagher, and Nathanael Huffman.This built on work described in many previous episodes: Cabling the Backplane Prior to going all-in on a cabled backplane with blind-mated server sleds (i.e. no plugging, unplugging, mis-plugging network cables). We (Bryan) espoused an "NC-SI or bust" mantra... at least in part to avoid doubling the cable count. With the cabled backplane, the reasons for NC-SI disappeared (which let the many reasons against truly shine). The Pragmatism of Hubris in which we talk about our embedded operating system, Hubris (and it's companion debugger, Humility). Hubris runs on the service processors that are the main endpoints on the management network. Matt's work controlling the management network switch (the VSC7448) is in the context of Hubris, as is John's work communicating with the sleds over the management network. The Power of Proto Boards showed and told about the many small boards we've used in development. Several of those were purpose built for controlling and simulating parts of the management network. The Oxide Supply Chain Kate Hicks joined us to talk about the challenges of navigating the supply chain. Mentioned here in the context of "supply-chain-driven design": we designed around the parts we could procure! Tip: stay away from "automotive-quality" parts when the auto industry is soaking them all up. Holistic Boot in which we talked about how (uniquely!) Oxide boots from nothing to its operating system and services. Over the management network, we can drive server recovery by piping in a RAMdisk over the network and then (slowly) through the UART to the CPU. Get You a State Machine for Great Good Andrew joined us to talk about his work on a state-machine driven text-UI and its companion replay debugger. We mentioned this in the context of John replaying the long upload process in seconds rather than hours to fix a UI bug. Major components of the management networkMatt's VSC7448 dev kitMatt's remote tuning setup via webcamManagement network debuggingManagement network debugging

This week's EYE ON NPI comes to us from the brilliant wireless engineers at Nordic Semiconductor - it's the Nordic nRF9160 System-in-Package with Integrated Cellular and GNSS (https://www.digikey.com/en/product-highlight/n/nordic-semi/nrf9160-sip). You know them for their popular nRF52 series of microcontrollers that have integrated Bluetooth LE - they're the market leaders for BLE development and support, with excellent software and low-power capabilities. A few years ago they decided to start branching out from their hit products and into more wireless IoT transports, like cellular and, more recently, WiFi (which perhaps we'll cover in a future EYE ON NPI!). The nRF91 series (https://www.nordicsemi.com/Products/nRF9160) is the Nordic Semi flagship cellular line, but it's different than most cell modules we've used. Normally you get a modules say from Quectel, and interface to it via USB or UART - sending AT commands (https://en.wikipedia.org/wiki/Hayes_command_set) and parsing the responses. That's fine and good but means that there's often a secondary microcontroller that has to do the work, and there's always a lot of work to do that parsing and command handling. What we like about the nRF91 is that it comes as a cute SIP package, much smaller than most modules, and integrates an ARM Cortex M33 with 1MB of flash, 256KB of RAM that you can program directly. This is familiar to folks who use the nRF52 series, where the BLE stack is integrated in hardware/firmware through the 'SoftDevice' system. (https://infocenter.nordicsemi.com/topic/ug_gsg_ses/UG/gsg/softdevices.html) You get all the hardware-interfacing you need with 32 GPIO, 12-bit ADC, RTC, SPI, I2C, I2S, UART, PDM and PWM which means that ideally you can develop your entire product on a single chip without need for external peripherals or drivers. The nRF91 comes in three flavors: nRF9160-SIAA (https://www.digikey.com/en/products/detail/nordic-semiconductor-asa/NRF9160-SIAA-B1A-R7/13533593) which has only LTE-M cellular support, nRF9160-SIBA (https://www.digikey.com/en/products/detail/nordic-semiconductor-asa/NRF9160-SIBA-B1A-R7/13533587) which has only NB-IOT support, and the nRF9160-SICA (https://www.digikey.com/en/products/detail/nordic-semiconductor-asa/NRF9160-SICA-B1A-R7/13533588) which has LTE, NB-IOT and GNSS. Each one has is pin-compatible but has different price levels, so pick the one that fits your budget and wireless needs. Note there's full 700MHz - 2.2GHz band support on each version of the SIP, so you don't have to order different SIPs for North America, South America, Asia, Europe, Africa, etc. There are global certifications available that you can look up to make sure you are cleared to integrate in any country you may need (https://www.nordicsemi.com/Products/Low-power-cellular-IoT/nRF9160-Certifications) The Nordic nRF9160 modules have been out for a few years, so there's lots of development boards you can use. For example, Nordic's in-house made dev board is fully featured with every add-on needed, plus Arduino-compatible headers (https://www.digikey.com/en/products/detail/nordic-semiconductor-asa/NRF9160-DK/9740721). There's also the extremely well-named Nordic Thingy 91 (https://www.digikey.com/en/videos/n/nordic-semiconductor/introducing-the-nordic-thingy-91-cellular-iot-prototyping-platform) which is a great dev kit for designing compact, battery powered, sensor-filled prototypes. The prior is better when you want to have JTAG headers and connect lots of external hardware, the latter is good if you happen to have some overlap with the built in hardware and want to prototype user experiences. If you are a Feather Fancier, there's an nRF9160 Feather (https://www.digikey.com/short/94tc2w84) that you can use to make lightweight portable designs that plug into FeatherWings. Best of all, all three versions of the nRF91 (https://www.digikey.com/en/product-highlight/n/nordic-semi/nrf9160-sip) are in stock now for immediate shipment from Digi-Key! We recommend starting with the full-featured nRF9160-SICA (https://www.digikey.com/short/j97r25p7) as you can always place the final design with one of the pared down SIAA or SIBA when you go to production. Order today for instantaneous shipment, you'll have these in your hands by tomorrow afternoon.

HPR News. Threat Analysis; your attack surface. Wireless key fobs compromised in European nations (France, Spain, and Latvia). On October 10, 2022, European authorities arrested 31 suspects across three nations. The suspects are believed to be related to a cybercrime ring that allegedly advertised an “automotive diagnostic solution” online and sent out fraudulent packages to their victims. The fraudulent packages contained malware and once installed onto the victims vehicle, the attackers were able to unlock the vehicle, start the ignition, then steal the vehicle without the physical key fob. European authorities confiscated over €1 million in criminal assets (malicious software, tools, and an online domain). Microsoft Office 365 has a broken encryption algorithm. Microsoft Office 365 uses an encryption algorithm called “Office 365 Message Encryption” to send and receive encrypted email messages. The messages are encrypted in an Electronic Codebook (ECB). The U.S. National Institute of Standards and Technology (NIST) reported, "ECB mode encrypts plaintext blocks independently, without randomization; therefore, the inspection of any two ciphertext blocks reveals whether or not the corresponding plaintext blocks are equal". Emails can be harvested today then decrypted later for future attacks. User Space. Netflix crackdown on freeloaders. Netflix is testing in Argentina, the Dominican Republic, El Salvador, Guatemala, and Honduras Chile, Costa Rica and Peru different efforts to crackdown on freeloaders. The term “freeloaders” covers the multiple users sharing a single Netflix account from different locations. Netflix plans to charge an additional $3.00 - $4.00 per subaccount. Samsung implements private blockchain to link user devices. While claiming the private blockchain, “has nothing to do with cryptomining”, the Knox Matrix security system links all your devices together in a private blockchain instead using a server based group verification system. The system, Knox Matrix, is suppose to allow devices to “manage themselves” by auto updating, caching updates for other devices then distributing the updates to other devices on the private blockchain. Toys for Techs. Juno Tablet: whois lookup DNS Twister Report Juno Tablet is a Beta product; overall it works with a few bugs. This is a non-refundable product, you will only get store credit. Price: $429.00 USD. Screen Size: 10.1” Screen Type: Full HD IPS screen 1920×1200 Capacitive touch, Capacitive (10-Point) MIPI-DSI. Refresh Rate: 60 Hz. CPU: Intel Jasper Lake Intel Celeron N5100 (4 Cores / 4 Threads) – 1.10GHz (Turbo 2.80 GHz) Graphics: Intel UHD Graphics, Frequency: Base 350 MHz - Max 800 MHz. Ram (SOLDERED): 8GB 2133 MHz LPDDR4. Storage: 256GB, 512GB, 1TB SSD. Chassis: Plastic. Wireless Card: Intel Wireless AC 9460/9560 Jefferson Peak 2.4 and 5GHz + Bluetooth 4.2. Ports: 1x USB3.0 1x Type-C 3.1 (Supports charging + video out) 1x Mini HDMI 1x Micro SD 3.5MM Headphone Jack Built-in Microphone Linux Kernel 5.18+ OS: Manjaro Phosh Manjaro Plasma Mobile Mobian Phosh Windows 11 (Not included – can provide ISO) JingPad A1, It’s the World’s FIRST Consumer-level ARM-based Linux Tablet. JingPad A1 maybe discontinued: https://www.youtube.com/watch?v=cmBG1Sjgsgk Pine64’s Ox64. RISC-V SBC Info: Ram: Embedded 64MB PSRAM Network: 2.4GHz 1T1R WiFi 802.11 b/g/n Bluetooth 5.2 Zigbee 10/100Mbps Ethernet (optional, on expansion board) Storage: on-board 16Mb (2MB) or 128Mb (16MB) XSPI NOR flash memory. microSD - supports SDHC and SDXC Expansion Ports: USB 2.0 OTG port 26 GPIO Pins, including SPI, I2C and UART functionality. Possible I2S and GMII expansion. Dual lane MiPi CSI port, located at USB-C port, for camera module. Audio: mic (optional, on camera module) speaker (optional, on camera module)

This week's EYE ON NPI is a breath of fresh air - with the Amphenol Telaire T6793 CO2 Sensor Module (https://www.digikey.com/en/product-highlight/a/amphenol-advanced-sensors/t6793-co2-sensor-module), another great sensor we are happy to highlight from Amphenol Advanced Sensor group (https://blog.adafruit.com/2020/07/23/eye-on-npi-amphenol-ztp-148src1-thermal-sensor-eyeonnpi-digikey-adafruit-amphenolsensors/). This time it's a sensor to detect the concentration of CO2 in the air. Carbon dioxide, aka CO2, is a gas that is an essential part of the Earth's atmosphere and life in general. However, while essential, it can have negative effects when concentrations exceed certain level. It can impact the entire planet via global warming. But it can also have very local effects, for example on indoor air quality. Elevated levels of CO2 can lead to reduced cognitive ability and other health related concerns. Therefore, monitoring CO2 levels of inside air can be useful as a part of gauging general air quality. Folks have had CO2 air-quality sensors in buildings and homes for a long time but now they're extremely popular because CO2 levels are correlated with air freshness. Outdoor air is about 400 ppm CO2. Us humans love to breathe in air, extract the O2 and fill rooms with CO2. That means when there's poor ventilation to the outdoors, and lots of humans - the air is going to have higher and higher CO2 concentrations. (https://theconversation.com/how-to-use-ventilation-and-air-filtration-to-prevent-the-spread-of-coronavirus-indoors-143732) We consider under 1000 ppm to be 'good' but really we want to keep it under 600 ppm if we can since that has been shown to reduce transmission of airborne disease. (https://onlinelibrary.wiley.com/doi/full/10.1111/ina.12639) There are two categories of CO2 sensors we see. One is the 'effective CO2' measurement, which is really a VOC sensor using doped MOX variable resistance sensors, and the other are 'true CO2' sensors which use NDIR. For example, the ENS160 breakout (https://www.adafruit.com/product/5606) we recently started stocking is a MOX sensor that will provide measurements of overall air quality based on volatile gases. It can also use this to approximate the CO2 concentration. But note it isn't actually measuring CO2! While this is fine for low cost or basic AQI measurements, it isn't a calibrated or reliable way to measure CO2. Instead, the right thing to do is use an NDIR sensor (https://en.wikipedia.org/wiki/Nondispersive_infrared_sensor) like the T6793 CO2 Sensor Module (https://www.digikey.com/short/h4278vt7), which is a 'true' CO2 sensor that will tell you the CO2 PPM (parts-per-million) composition of ambient air. That means it's a lot bigger and more expensive than eCO2 sensors, but it is the real thing. Perfect for environmental sensing, scientific experiments, air quality and ventilation studies, and more. The Amphenol T6793 CO2 Sensor Module (https://www.digikey.com/short/h4278vt7) is a true NDIR CO2 sensor, with self-recalibration if used outside where it will be exposed to 400ppm CO2 signal at least once a week, and comes in two versions, one with 2Kppm and one with 5Kppm maximums. It's highly stable, and accurate with +-45ppm + 3% of reading accuracy and continuous 5 second readings. One thing we really liked about this sensor is that it has multiple output modes, no matter what your system integration requires. The T6793 comes with a wide selection: 100KHz I2C, UART, RS485 and even PWM output! The module comes with a 6-pin 0.1" / 2.54mm pitch header so it can be swapped out of a larger system after a few years or if the sensor gets contaminated. The PWM pulse rates and I2C registers are documented in the app note (https://www.amphenol-sensors.com/en/telaire/co2/525-co2-sensor-modules/3399-t6713) and there is some some Arduino code available on GitHub for reference. (https://github.com/AmphenolAdvancedSensors/Evaluation_Kits/tree/AAS_AQS_UNO_RH_CO2) If you want high-quality, reliable, and accurate CO2 sensing with a true NDIR sensor - you are in luck because the Amphenol T6793 CO2 Sensor Module (https://www.digikey.com/short/h4278vt7) is in stock right now at Digi-Key for immediate shipment! Order today and you can have this fancy golden sensor ready to use by tomorrow afternoon.

Here's the Supporter Q&A from October 13th, 2022. All comments and questions are fielded through the support service Q&A page. Please consider supporting this channel via monthly services, tips, or even just by using our affiliate links to purchase things you were already going to buy anyway, at no extra cost to you: https://www.retrorgb.com/support.html View this as a video: https://www.youtube.com/retrorgb Amazon Links to products I use: https://www.amazon.com/shop/retrorgb T-Shirts & Stuff: https://www.retrorgb.com/store.html TIMESTAMPS (please assume all links are affiliate links): 00:00 Welcome! 00:08 Koryuu Transcoder: https://www.retrorgb.com/koryuu-transcoder-firmware-v-1-1.html 01:10 Any way to prevent video dropouts during OSSC resolution changes? Sega CDX 3BP? 05:00 PS1 link cable uses UART protocol? Lag testing Retrofighters Controllers?: https://rpubs.com/misteraddons/inputlatency HDMI to Component in 1080p for Datapath 08:44 Following up on running fans at lower voltages. 12:46 Shielded S-Video to BNC cable? Maybe this one?: https://amzn.to/3CUkXpJ Anyone have a low profile bracket for a Datapath Vision E1s? 15:51 Fixing composite RCA cables? 4K Gamer Pro: https://www.retrorgb.com/4k-gamer-pro-now-on-amazon.html 19:35 HDMI switches with more than 2 outputs? 21:18 Best way to connect a Dreamcast to a D20 BVM?: https://retro-access.com/products/dreamcast-15khz-31khz-480i-480p-scart-cable?variant=17095604207667?aff=3 24:36 Safe MiSTer SCART cables (I/O or Direct Video): https://www.retrorgb.com/beware-of-mister-scart-cables.html 26:59 Convert an HDMI signal to DVI-D for compatibility??? 29:06 Can you kill a CRT by sending it the wrong resolution? MiSTerCade vs J-PAC? 37:09 RGBs over VGA? Other matrix switches? Gscartsw still king for SCART: https://bit.ly/gscartsw --- Support this podcast: https://anchor.fm/retrorgb/support

This week's EYE ON NPI has an EYE TO THE SKY, it's a new MAX-M10 series of ultra-low-power GPS modules from u-blox (https://www.digikey.com/en/product-highlight/u/u-blox/max-m10-series). u-blox is famous for their high quality GPS modules, they've been making them for about 20 years and they've never stopped iterating on their trusted designs. This new generation of modules, the MAX-M10 series, comes in two flavors for cost vs tracking-sensitivity optimization. The MAX-M10 modules are the same footprint, and both support the four active or soon-to-be-active GNSS constellations: GPS (USA-launched satellite system), GLONASS (Russia), Galileo (Europe) and BeiDou (China) The MAX-M10 is available in S series (https://www.digikey.com/short/r5j974z0) and M series varieties (https://www.digikey.com/short/zp5v73zm). The MAX-M10S-00B S series has a temperature compensated oscillator (https://en.wikipedia.org/wiki/Crystal_oscillator#Temperature) a.k.a TCXO for the frequency tuning, so you'll get better sensitivity and tracking: -167dBm sensitivity compared to the M series' -164dBm, but at higher current draw and pricing. The MAX-M10M-00B M series has a regular crystal a.k.a XTAL, for lower cost and power usage, but will take longer to get initial fix and won't have as good sensitivity. Also, the M series can run 1.8-5.5V, where as the S series is 1.8-3.3V max and has a SAW filter (https://en.wikipedia.org/wiki/Filter_(signal_processing)#SAW_filters) and LNA (https://en.wikipedia.org/wiki/Low-noise_amplifier). Both modules have UART and I2C support, which is great news because so many microcomputers and 'controllers do not have lots of spare UARTs. I2C has a built in buffer and you can query the current size and then read bytes out of it. Do note that I2C has clock stretching so you will need to either slow down the baud rate or verify your controller can handle the stretching. For UART mode, default baud rate is 9600 but can be configured higher. Unlike some basic all-in-one modules, the MAX M10s require an external antenna. You can use either passive (https://www.adafruit.com/product/2461) or active antennas (https://www.adafruit.com/product/960), active antenna only needs a few passive components. If you want to really have a fancy setup, you can enable an antenna supervisor circuit which can tell you if the antenna is connected, shorted, or even open. (https://www.u-blox.com/sites/default/files/MAX-M10S_IntegrationManual_UBX-20053088.pdf) The recent GPS modules from u-blox also support their native IoT cloud asset tracking system called CloudLocate (https://www.u-blox.com/en/product/cloudlocate) also known as ThingStream (https://www.u-blox.com/en/product/thingstream) which seems to do a very cool thing where you don't actually need to get a fix or download the ephermeris data, you can stream timing measurement deltas immediately and the calculation of GPS coordinates is done by a computer that has almanac data all loaded up. Of course this works only if you have a LoRa/Cell/WiFi connection already but for asset tracking it's a cute idea! Wanna upgrade your GNSS product to the very latest and greatest u-blox 10th generation series today? You can because the MAX-M10S-00B is in stock right now at Digi-Key for immediate shipment! (https://www.digikey.com/short/1rdqtp9j) And while you're waiting for your next-day shipment to burst out the warehouse doors and make its way into your arms, be sure to sign up for the free webinar on October 12th on Accelerating Your Wireless Solution Development ( https://dky.bz/3E0mPOI) which will use the u-blox XPLR-IOT-1 dev kit (https://www.digikey.com/short/051jv5r0) for quick LTE / NB-IOT / WiFi / GNSS development.

The RCWL sensor has a lil solder jumper on the back that lets you turn it into "IIC" mode - we tried it out and ... it kinda works! This sensor can be used on an I2C bus, but it doesn't seem to do well if sharing it with other devices. Still, if you have a microcontroller or microcomputer that doesn't have fast GPIO for toggle/pulse or a hardware UART, you definitely can use it for inexpensive sensing. Note that on this QT Py RP2040 we've got the OLED on a different I2C bus which is why it's happily running for hours now. In stock at the adafruit shop! https://www.adafruit.com/product/4742 #adafruit #ultrasonic #python Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI is going loooooooooooooong with a fully integrated Long Range radio module + microcontroller - it's the Murata's Type 1SJ Integrated LoRaWAN Module (https://www.digikey.com/en/product-highlight/m/murata-electronics-north-america/type-1sj-integrated-lorawan-module). This nifty wafer-thin chip is an all-in-one compact solution for adding far-reaching wireless without the cost and power requirements of cellular or WiFi. Particularly for compact products that need to stay small and thin, we've never seen a smaller integrated LoRaWAN solution! This product is a true triple collaboration, combining the second-generation Semtech SX1262 radio frequency IC (https://www.digikey.com/short/342nj2dp) that comes with the licensed LoRa encoding support and an ARM Cortex-M0 STM32L072 microcontroller (https://www.digikey.com/short/z27vc2rn) from STMicroelectronics with 192 kB of Flash memory, and 20 kB of RAM, along with a built-in RF switch. Having the STM32L0 chip means excellent deep sleep capabilities, so the module can run on a battery - even a coin cell - for a long time. The STM32 also has plenty of peripherals, so whatever data you need to send over LoRa, you'll be able to read and process the data: USB, ADC, I2C, SPI, UART etc. The RF side of the module is the Semtech SX1262 - they're the company that licenses the LoRa RF specification so basically you're guaranteed to get working LoRa/LoRaWAN support with working code examples. The radio can transmit at up +22dBm for many-mile range, similar to the SX breakouts and FeatherWings we manufacture (https://www.adafruit.com/?q=lora&sort=BestMatch) with official driver code available through mbed (https://os.mbed.com/teams/Semtech/) and GitHub (https://github.com/Lora-net/sx126x_driver). All together they make for a compact, inexpensive module which saves you money and space over combining the radio plus microcontroller. We like the epoxy-coated slab look and it seems like it would be easy to use in a pick & place + reflow manufacturing line. To get started quickly, you can pick up the Murata LBAA0QB1SJ-TEMP-EVK evaluation board (https://www.digikey.com/short/rz8pmb3j) or two, it comes with Arduino-like headers, antenna connection options and a built in SWD/JTAG programmer debugger for the STM32 microcontroller. Once you've got your code working, the individual Murata LBAA0QB1SJ-296 (https://www.digikey.com/short/cct0q8cd) modules are available on tape & reel - book an order with Digi-Key for shipment as soon as they come into stock!

You can build a laser harp using time of flight distance sensors. The CircuitPython code converts the distance data to MIDI messages that can be sent out over UART or USB. Check out the Learn Guide for all of the files and build instructions: https://learn.adafruit.com/midi-laser-harp-time-of-flight-sensors Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

We were looking at WCH @Patrick_RISCV for a USB to serial chip to replace the CP210x, when we remembered a lot of chatter a few years ago about the CH552 series of ultra-low-cost 8051 microcontrollers with native USB. you can kinda sorta code these with Arduino https://hackaday.io/project/172143-ch55xduino and we thought it could be an interesting QT Py since it has so few pins but does cover the basic use cases: 4 ADC, UART, SPI and maybe even I2C with a bitbang connection? Still, for very very basic USB projects maybe it would be useful, particularly since it has a ROM USB bootloader. Here's a simple design we whipped together. Since there isn't a lot of muxing or IO available, MISO and A2 share the same pin. Some interesting unusual things to watch for: reset is backwards from how we'd expect, and bootloader mode is entered by pulling D+ to 3V? Any CH55x experts out there who want to take a look and see if we got it all wired right? Anything we missed? #adafruit #arduino #qtpy Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI should be on *your* radar - it's InnoSenT's 24 GHz IMD-2000 Radar Sensor (https://www.digikey.com/en/product-highlight/i/innosent/imd-2000-radar-sensor) This all-in-one sensor is easy to integrate into your next product and brings high-tech radar sensing to an affordable range. Radar is literally "Radio Detecting And Ranging" - a way of bouncing 'high frequency' electromagnetic waves off of objects to detect the reflection. We're familiar with radar (https://en.wikipedia.org/wiki/Radar) in a few contexts: originally developed for military use, it worked great for detecting metal things in the sky (airplanes) as they would approach a city to possibly bomb it. We still use it a lot in military contexts: detecting planes, bombs, boats and submarines. It's also super handy in domestic contexts like air traffic control, if you can detect planes you can verify their positions and make sure each one comes in or out of the airport without collision. Radar is also useful for weather pattern detection (although this sensor isn't good for that purpose, just a fun fact for you to know) Another common purpose for radar you're probably familiar with is the dreaded speeding radar gun (https://en.wikipedia.org/wiki/Radar_speed_gun) a small-enough-to-be-handheld radar device that can be pointed at a car to determine its speed without requiring a difficult-to-calculate "time between two points" measurement. These reliable devices (which apparently now are replaced with LIDAR based ones!) Now, most folks who have used IR sensors, Time of Flight, or sonar sensors can understand how to detect an object by counting the delay between sending a signal vs when its received and dividing by the wavelength. How can you determine velocity - normally you'd need to detect location twice, then determine the time between the two locations whereas radar can do it one measurement. This is thanks to the 'Doppler effect' (https://en.wikipedia.org/wiki/Doppler_effect) the same scientific principle that causes ambulance sirens to be higher pitch as they approach and lower pitch as they drive away from you due to the 'bunching up' of the waves as the wave source moves. Likewise with Radar, the frequency will shift slightly depending on the speed of the object, which can be detected by calculating the minute variation in frequency. Radar sensors are often used in similar cases as IR, ToF, sonar or LIDAR sensors: for detecting objects or motion or distance. Compared to IR, Radar will give you a much longer range and will work with a wider range of objects without being affected by ambient light, object color or shininess. Compared to ToF you'll get velocity, long range. Sonar is longer range than IR or ToF but has a wide spread. LIDAR is very comparable but is new and more expensive - Radar is easy to implement and low cost by comparison. And this Radar module is particularly easy to use because unlike many cheap modules that only give you a pulse signal that has to be massaged and measured to determine object distance and/or speed, this one has an FTDI-cable (https://www.digikey.com/en/products/detail/adafruit-industries-llc/70/9092299) compatible UART signal out. Simply provide 5V power and you'll get 250 kbps TTL signal out with a listing of objects, distances and velocities. This makes it trivial to integrate with any computer or microcontroller. The InnoSenT's 24 GHz IMD-2000 Radar Sensor (https://www.digikey.com/short/40wz7zdd) is the easiest to use Radar sensor we've seen and it's in stock now, for immediate shipment from Digi-Key! Book it today and you can be radaring, object counting, distance measuring, velocity-finding and more by tomorrow afternoon.

This week's EYE ON NPI will woo you like a period romance show - no, we're not talking about Bridgerton, this is a different kind of Bridge! We're highlighting NXP's SC18IM704 UART to I²C-Bus Bridge (https://www.digikey.com/en/product-highlight/n/nxp-semi/sc18im704-uart-to-i2c-bus-bridge). This is a chip or module that will let you take an existing system with RS-232 or UART Serial and wedge in I2C support. Handy for desktop computer systems that just need to integrate a single sensor or control in userspace or embedded computers without extra GPIO: having user-space support for I2C, ADC, DAC or SPI is rare if you don't happen to have a BeBox (https://en.wikipedia.org/wiki/BeBox) but you can get almost any kind of device connected if you've got I2C! These sorts of bridge devices could also be super useful during the chip shortage (https://en.wikipedia.org/wiki/2020%E2%80%93present_global_chip_shortage) - which we think will continue through until 2024 - where you have a design that has the right matching peripheral set, and then at the last minute, a part can't be sourced and you end up needing to re-spin the design. You may be able to get a similar spec part but...it doesn't have UART, only I2C, or SPI, or any mix-and-match combination of the three! For that reason, there's actually a couple different bridge chips that NXP makes (https://www.nxp.com/products/peripherals-and-logic/signal-chain/bridges:MC_50962) The SC18IM704 (https://www.digikey.com/short/j242d1nm) has a single UART in and an I2C output, with 8 additional GPIO pins that can be handy for IRQ or busy pin reading, or for resetting pins or changing address selects. Commands are sent as bytes, and the user can initiate I2C start/stop, then read/write as well as setting GPIO direction, pull and value. Since NXP now owns Philips who wrote the I2C specification, (https://www.i2c-bus.org/specification/) you can be sure that this chip will work well with any I2C-standard sensor or expander you could find. If you aren't integrating the chip, like say you have a computer board or other industrial device and you just want to get started fast, you can pick up the NXP SC18IM704-EVB eval board (https://www.digikey.com/en/products/detail/nxp-usa-inc./SC18IM704-EVB/15777144) which provides an RS-232 port and plug and play headers with 3V logic and 5V compliance. Like many new product introductions lately, there were not many chips released in the initial stock and they're currently sold out! However, the NXP SC18IM704 UART to I²C-Bus Bridge (https://www.digikey.com/short/j242d1nm) is a stocking part on Digi-Key and a few thousand will be shipping in 2 months, so you can book an order today and have it send to you as soon as its available!

we spent today working on a ESP32-S3 feather. you may be thinking "hey wait didn't you already design one?" yep! but we had a hardware bug that increased deep-sleep power, and so we wanted to revise the ESP32-S2 feather first to fix it since the PCBs for the two designs are shared. now we have the new ESP32-S2 in the shop with the fix https://www.adafruit.com/product/5303 so we can respin the S3. even better, Espressif has started adding S3 support in a branch so we were able to test the GPIO, I2C, UART, NeoPixel, low power, and WiFi capabilities successfully. We've got a PR open to add this new board - it's very exciting! https://github.com/espressif/arduino-esp32/pull/6450 This board uses the only S3 mini module available right now, with 8 MB of Flash and no PSRAM. however, there's more SRAM on the S3 than S2 so its still very usable. when the PSRAM-containing mini module comes out we'll make a version with that too. Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week's EYE ON NPI is another banger from Sensirion - who has been really rockin' out with great sensors over the last few years - it's the SEN54 Environmental Sensor Node (https://www.digikey.com/en/product-highlight/s/sensirion/sek-sen5x-evaluation-kit), an all-in-one sensor node that combines all of the Sensirion top hits in one. This sensor looks like your everyday dust sensor - just like the SPS30 particulate sensor (https://www.digikey.com/en/products/detail/sensirion-ag/SPS30/9598990), but combines additional sensors inside! There's a few models planned for the SEN5X series - today we're highlighting the SEN54 which has * Particulate Matter - PM2.5 * Humidity and Temperature via SHT40 (https://www.digikey.com/en/products/detail/sensirion-ag/SHT40-AD1B-R3/14322709) * Volatile Organic Compound via SGP41 (https://www.digikey.com/en/products/detail/sensirion-ag/SGP41-D-R4/15652788) (There's also a SEN55 which will include an addition NOx sensor, but it has not been released yet) The sensor uses a sub-processor that will act as a single I2C peripheral to receive commands and send sensor data back. It's a great deal if you want a simple-to-install air quality sensor with all the goodies. There's a 3D model available for mechanical installation, and for connectivity you just need a single JST GHR 6 pin (https://www.digikey.com/en/products/detail/jst-sales-america-inc/GHR-06V-S/807818) cable which has power, and I2C or UART data. Note that the cable is not sold separately so you'll need to acquire the cable from a separate vendor or pick up the full evaluation kit that comes with a couple cables at additional cost. (https://www.digikey.com/en/products/detail/sensirion-ag/SEK-SEN5X/15903862) The real success story here is the libraries that are pre-written and supported by Sensirion that makes getting started very very fast. We were able to wire up the SEN54 to an ESP32 board and run the BLE demo (https://github.com/Sensirion/arduino-ble-gadget) within a few minutes! Using the Sensirion MyAmbience app, (https://apps.apple.com/us/app/sensirion-myambience/id1529131572) we could see instant data show up on our iOS or Android device. Over-all a slick and easy experience. We must say that we're really impressed with how maker-engineer friendly the sensors and firmware development is. This all-in-one sensor board is going to be a popular environmental sensor from folks who really know environmental sensing! Digi-Key has a whole bunch of the Sensirion SEN54 sensors in stock right now for immediate shipment (https://www.digikey.com/short/pn08ff2w) and with same-day shipping, you can order today and be sensing by tomorrow afternoon!

This week's EYE ON NPI is like a Vulcan: no, it doesn't have pointy ears, but it is totally logical! It's the Crouzet Millenium Slim Ultra-Small Logic Controller. (https://www.digikey.com/en/product-highlight/c/crouzet-usa/millenium-slim-ultra-small-logic-controller) It's the darn-cutest looking logic controller we've seen, with wireless BLE programming support for 4 inputs and 4 outputs. Each controller is very small compared to large PLCs, with 4 inputs and 4 outputs. There's a version with 500mA transistor sourcing outputs which can do PWM output, and two relay versions - one AC powered and one DC powered. Each input can also be PWM input and some can be tachometer or analog inputs. There's no LCD or TFT display - instead you can use a phone with iOS or Android to connect to the BLE interface to analyze/debug the output, and provide buttons for input if a UI is desired. (https://www.crouzet.com/products/automation-controllers/software/crouzet-virtual-display/) The nicest part of this product is the programming interface software. (https://www.crouzet.com/products/automation-controllers/software/) The software only runs on Windows that we could tell, but it's a simple drag-n-drop flow-based programming kit that lets the operator come up with simple logical operations that can be combined to create advanced control flows. This is a bit different than microcontroller programming: all the logic executes at the same time, so perhaps it's a little like a cross between block-based coding and FPGA/CPLD coding. There are some simple commands like Boolean logic, or simple counters - to more advanced ones like PID controllers, timers, or Schmidt triggers. Even though this is like a 'baby' PLC, it seems like the programs can be simulated/shared from smaller to larger controllers. The BLE connectivity is handled with a BlueGiga dongle (https://www.silabs.com/wireless/bluetooth/bluegiga-low-energy-legacy-modules/device.bled112)- this is a device that presents itself as a serial COM port and then takes commands over UART data to connect and transfer BLE data. This might seem a bit odd given that Win 10 has native wireless support - but probably a good idea since native BLE connectivity is really tough on desktop. There's also a better chance that the programmer could run in an emulator because the driver is generic. We think the Millenium Slim Ultra-Small Logic Controller could be an excellent first-time-PLC for someone starting out with PLC, or anyone with a small automation project where a big controller is overkill. Best of all, both the BLE dongle (https://www.digikey.com/short/ct5hqv07) and PLC (https://www.digikey.com/short/2jfv2p4d) are in stock right at Digi-Key for immediate purchase. So whether you are an expert automator, or a beginner mechatronist - purchase today and you can get it in your hands tomorrow morning! See on Digi-Key at https://www.digikey.com/short/2jfv2p4d

Join Scott as he works on bringing CircuitPython to the Raspberry Pi. Work on USB has stalled so he's taking a break by working on getting CircuitPython working over UART. Chat with Scott and lot of others on the Adafruit Discord at https://adafru.it/discord. Deep Dive happens every week. Normally Fridays at 2pm Pacific but occasionally shifted to Thursday at 2pm. Typically goes for two hours or more. Questions are welcome. Next week is on Friday. 0:00 Getting started 0:03:25 Hello everyone / Housekeeping 0:05:51 Today - working on Arm Cortex A as bare metal micro (raspberry pi 4) 0:06:37 last week: interrupts / tiny usb 0:07:29 Exception Levels. EL3, EL2 (hypervisor), EL1 (OS), EL0 (applications) 0:09:13 Last week - EL2 hypervisor bits needed to be set 0:10:47 Looked into ARM architecture reference manual HCR_EL2 (64 bit register) 0:12:39 TGE bit Trap General Exception 0:16:19 D1.13 asynchronous exception type, routing, masking and priorities 0:18:09 Non-secure mode, SCR, TDE “C - interrupt remains pending” TGE bit set to 1 0:19:44 the magic bit that needed to be set in broadcom peripherals repo 0:21:00 NVM3722 ARM and AUX_IRQhandler 0:23:25 Pointer boxing ( using ‘extra' bits in 64 bit pointer ) 0:24:10 Open OCD, Gdb, and uart screens 0:25:06 CP repl on Rasbperry Pi 0:25:33 print(“hello world”) hangs / next week HDMI output, but first fix this bug 0:28:21 ARM exception decoding using cortex-a.py arm8a-exception 0:29:40 pointer greater than 32 bits - probably a problem 0:30:30 Memory mapping ( only the first ‘gig' of memory mapped ) 0:37:19 question: can a zero 1.3 use with any lcd??? 0:40:55 aapcs arm call stack research / Procedure call standard for the Arm Architecture 0:43:51 decode failing - irq_entry and irq_exit call stack creation 0:45:20 Frame pointer 0:50:58 ARM ABI 0:53:40 Microsoft arm arch 64 ABI documentation - very similar 0:54:54 experiment with h=”hello world” 0:55:58 gdb) info frame 1:02:25 typical C function call 1:05:28 exceptions should save the ‘callers' state 1:06:13 ‘101' review of memory ( heap and stack ) 1:25:00 disassemble mp_obj_print_helper to look at use of frame pointer 1:28:00 back to github libunwind 1:34:35 Unwinding frames in python 1:35:10 CP uses PIO for neopixels on RP2040 1:37:52 aarch64-unwind.h 1:41:10 does it come down to the exception entry code needing to update frame pointer (x29) to be stored on the stack to a GDB "correct" value, rather than storing the previous frame pointer value when exception occurs? 1:51:20 Digikey has a small number of the LED glasses and nRF driver boards available 1:54:00 stack-unwind-samples 1:56:10 greyed out command completion from fish shell 1:59:08 code is compiled for 64 bit ARM 2:00:43 oh, my fish extension - otherwise it's pretty standard .fishrc (omf and bobthefish) 2:02:44 looking at github rsta2/circle for examples 2:03:51 exception stub 2:04:32 edc/bass to use bash utilities in fish shell 2:05:12 circle irq handler - might like what we want “exceptionstub64.S” 2:16:23 trying out the experiment - it's worse :-( 2:18:55 wrap up - shop at adafruit.com or digikey.com if not in stock 2:20:47 wake the cat - and catch the links at github tannewt rpi branch 2:21:55 bye spook Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Scott covers progress on the Cortex A work for Raspberry Pi. He's been working on expanding the system view description (SVD) files and learning all about the Generic Interrupt Controller (GIC400 / GICv2). He'll also answer any questions folks have. Visit the Adafruit shop online - http://www.adafruit.com Chat with me and lot of others on the Adafruit Discord at https://adafru.it/discord. Deep Dive happens every week. Normally Fridays at 2pm Pacific but occasionally shifted to Thursday at 2pm. Typically goes for two hours or more. Questions are welcome. 0:00 Getting started 0:02:00 Hello and Housekeeping 0:04:42 Unexpected Makers Feather S2 - https://unexpectedmaker.com/ 0:05:30 Today's topic deep dive Raspberry Pi 0:06:30 Educational/Work Background summary 0:10:20 Getting started in Board Design - KiCad, Oshpark - https://www.kicad.org/ 0:12:00 Working on google maps, reasons for leaving 0:13:35 What was the most important thing learned at Google? 0:14:45 Getting started with surface mount 0:16:15 Flux and soldering, Pin Headers - https://www.adafruit.com/product/2830 0:20:30 Adafruit Collin's Lab soldering videos - https://www.youtube.com/playlist?list=PLjF7R1fz_OOXyxiYQWEX4OZga9c7jrw5q 0:21:05 Hand soldering, vs. SMD for dotstars 0:22:17 Looking at the ‘new' Pi Development board 40-Pin / external JTAG / SWD adapter - https://oshpark.com/shared_projects/fBq76nP9 0:24:22 Raspberry Pi CM4 0:25:37 USB to UART external board 0:26:45 External connector and chickadee logo ( on oshpark ) 0:29:35 Oshpark, PCB shopper (dot com) 0:31:00 Chickadee.tech web page and After Dark theme 0:32:12 Two weeks of progress on RPi 0:32:32 Troubleshooting 4 layer boards 0:33:25 adafruit/samd-peripherals github page - SAMD21 / SAMD51 0:33:52 adafruit / Broadcom peripherals page - https://github.com/adafruit/broadcom-peripherals 0:35:55 Recap system on chips ( SAM D21 block diagram ) 0:38:00 .SVD ( arm ) vs flash.xml ? 0:38:46 Memory Mapped I/O and Product (memory) Mapping 0:40:40 SVD file used for debugging and generate C code 0:42:00 RPi Desktop/workspace setup explained 0:44:00 Debug output and open OCD 0:44:35 Gdbstub PyCortexMDebug - https://github.com/bnahill/PyCortexMDebug 0:46:30 “svd” commands 0:50:24 Using KDE console terminal for tiling “management” 0:51:00 IRQ's and interrupts 0:53:24 Need USB Interrupts to get TinyUSB to work 0:54:00 PPI vs SPI 0:57:28 Would interrupts drive support to multicore 0:58:55 Do we need delays to support interrupts? (no) 1:00:50 Can you have delays in an interrupt? ( don't want to ) 1:02:10 SVDcon (sp) converted table 1:02:39 Python generated jinja macros (svd tool) 1:07:50 GPIO alternate functions - moving to get interrupts working 1:08:40 USB initialization need to be powered on ( see vcmailbox ? ) 1:09:40 How does the interrupt handler work - assembly code 1:10:10 saving and restoring state in interrupts (macro) 1:11:30 handling invalid interrupt entries 1:12:25 CPU exception top level code 1:13:14 handle IRQ 1:14:15 svd USB_OTG_GLOBAL / examine the registers 1:17:02 next thing down the line, the interrupt controller 1:20:30 Lady Ada on the screen! 1:32:23 - after some good advice, goodbye 1:35:20 ARM provided svd conv (sp) 1:38:52 GIC 400 1:40:53 the GIC 400 overview diagram 1:43:20 Interrupt “1023” magic number - in a spurious interrupt 1:46:42 Interrupt handling state machine diagram Figure 3-1 1:47:55 Distributor register descriptions - GICD_ITARGETS 1:49:00 Old show notes - https://github.com/adafruit/deep-dive-notes/ 1:51:16 Reviewing interrupt priority fields 1:54:20 interrupts are all zero 1:55:00 Try setting priority to one, as an experiment 1:57:00 restart with new code - gdb says in fifo-read 1:58:34 Wrap-up 1:59:25 Next week next Friday 2:00:09 cat-cam ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

A die-hard interface chip that is the backbone of many-a-devboard is the USB-to-UART adapter chip. While many micros come with native USB, there is still a large number that have UART only - like the ESP32, or RISC-V cores. Since most computers don't have a UART/RS232 port anymore, we're often converting UART to USB. For many years, we really like the CP2104 for low-cost and consistent/reliable behavior. That's NRND now, so what shall we find to replace it? See on Digi-Key at https://www.digikey.com/short/tmqr7f2t Visit the Adafruit shop online - http://www.adafruit.com See more Desk of Ladyada on YouTube https://www.youtube.com/playlist?list=PLjF7R1fz_OOXUtaFu7-_D1UCugC8OecKv See other episodes of The Great Search https://www.youtube.com/playlist?list=PLjF7R1fz_OOVHqJN28IbXLBj1FKCxw-xD ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/

OK we finally spent a few hours and finished up our UPDI stand-alone programming code. That means we can start releasing some ATtiny8xx designs because we will be able to program/test them nice and fast. First up is a basic breakout with QT connectors. Let's maybe put together a tester? The Great Search - Alternative for CP2014 USB to UART https://www.digikey.com/short/tmqr7f2t A die-hard interface chip that is the backbone of many-a-devboard is the USB-to-UART adapter chip. While many micros come with native USB, there is still a large number that have UART only - like the ESP32, or RISC-V cores. Since most computers don't have a UART/RS232 port anymore, we're often converting UART to USB. For many years, we really like the CP2104 for low-cost and consistant/reliable behavior. That's NRND now, so what shall we find to replace it? #adafruit #deskofladyada #thegreatsearch Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Join Scott as he covers more fixes for CircuitPython 7.0.0 including an epic memory bug that he and Jeff debugged. Scott will answer questions as well. Visit the Adafruit shop online - http://www.adafruit.com Deep Dive happens every week. Normally Fridays at 2pm Pacific but occasionally shifted to Thursday at 2pm. Typically goes for two hours or more. Questions are welcome. Next week will be on Friday. Thanks to David (@dcd) for taking timecodes and notes. 0:00 Getting started 0:06:31 Hello/Welcome/Housekeeping 0:10:00 Hot Reload issue from UM 0:10:30 What's after CP 7.0 0:12:30 Espressif (feature on Ask and Engineer) - not supported yet 0:13:36 WipperSnapper 0:14:55 RealPython podcast plug - https://realpython.com/podcasts/rpp/75/ 0:18:24 Reviewing Closed issues - https://github.com/adafruit/circuitpython/issues 0:23:10 issue 5021 - Watch Dog Timer (WDT) 0:28:00 Magtag hacked to access debug UART - handy for debugging 0:31:50 trying controlling the neopix on my feather840 with the guide with no success. couldn't find adafruit_ble.services.nordic in docs to help troubleshoot bleuart 0:33:10 When you use this m_new_obj_with_finaliser does the class have to have a finaliser or does it handle it automatically? 0:34:00 https://github.com/2m/fish-history-merge mentioned in discord 0:35:00 more spoilers - don't look :-) 0:36:26 Can CP do quad and/or octo SPI ? 0:37:30 TG1WDT_SYS_RST ( watch dog timer reset ) 0:38:30 gc: collect() outputs (main.c) 0:40:46 mention of adding file name and line number to debug _FILE__, __LINE__ ( thanks Jeff ) 0:43:45 gc_collect_ptr() marking heap memory chunks that have pointers 0:45:10 the costs of using dynamic memory (16 byte blocs in ATB ) 0:40:00 __del and bitmaps for finalizers (FTB - finalizer table ) 0:49:00 gc_mark_subtree() 0:52:45 0x3ff80000 printed 0:53:16 esp32-s2 technical reference - Address Mapping in Table 20: 0:56:20 similar MP bug with Cortex M7 memory that shut the the memory bus 0:57:30 memory protection unit discussion 0:58:00 “it shouldn't do that” reading memory causes bus to hang 1:00:56 last time throught the loop - the block was “1”, now it's “2” 1:01:33 How did we come up with the block size of 2? 1:04:30 gc_alloc() FTB_SET and finalizer changing numbers.. 1:07:21 Micropython issue 7716 1:11:10 fix in pull #5245 1:12:20 turn off long living - and the bug went away 1:13:14 - youtube visualizations of left and right “heap before after” low addresses on the left, high on the right - https://www.youtube.com/watch?v=CD3lyGS_W9o 1:15:27 Short lived / Long Lived in CircuitPython 3.x ( no layers of indirection ) 1:16:40 Long Lived rules (import, Q-strings, etc.) placed on right side 1:20:45 search for long_lived, also allocators with _ll in their name 1:22:25 So it does compaction if needed? 1:23:00 Long Lived only impacts the allocation process 1:23:40 I2c bug also fixed this week - not long lived 1:24:40 earlier memory issue deep dive https://www.youtube.com/watch?v=baa5ILZTRkQ 1:26:08 my debug output is garbled although I have 115200 set. 1:28:00 build status for merge 1:28:50 - need to build CP ESP32 with debug flag to get debug strings 1:29:39 GDB learn guide 1:30:15 What did you use to make the heap graphic? / ( see tools analyze_heap_dump.py ) 1:32:25 let's talk nRF = issue #5240 ( see also #5241 for rp2040 ) 1:35:13 (the faked sleep modes) Explains why i see the same power usage regardless of sleep mode, even time.sleep 1:36:25 sublime merge review changes 1:37:47 issue #5211 1:42:06 RESETREAS ( why nRF52840 was reset ) 1:49:46 NRF / deep-sleep-with-circuitpython/power-on-other-boards learn guide ( oh - that is still a draft ) 1:50:12 So you said about time sleep -- does that need an RTC, or just based on internal clock? 1:52:11 Nordic nRF-PPk2 Power Profiler Kit II product 5048 1:54:05 “need to figure out exception class” to throw 1:56:55 having deep sleep in CP is a game changer - CP knows what you are using 2:13:20 wrapping up #5253 2:16:30 sign off ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

Join Scott as he answers audience questions and squashes bugs for CircuitPython 7.0.0. Scott is sponsored by Adafruit to work on CircuitPython. Support them, and by extension Scott, by purchasing hardware from https://adafruit.com Chat with Scott and lot of others on the Adafruit Discord at https://adafru.it/discord. Deep Dive happens every week. Normally Fridays at 2pm Pacific but occasionally shifted to Thursday at 2pm. Typically goes for two hours or more. Questions are welcome. Next week will be on Friday as well. 0:00 Getting started 0:05:00 - what made it into CP 7.0 0:07:52 housekeeping 0:11:02 2 x Arduino Nano RP2040 Connect, BLE device to device. As soon as the BLE obj on the Central is active it appears the RGB led cannot be controlled ( not CP ) 013:36 keyboardio 0:16:31 CP 7.0 - pull request review and issues 0:20:30 If Native CP on the Pi was a thing, would we get real multi-core support? And would that gain multi-core support on the Pico? 0:23:55 trying to do a pull from main, get the issue with ports/raspberrypi/sdk/lib/tinyusb has moved to some new point in time. what's the best way to get it all straight 0:24:50 “git status” always 0:25:22 RP2040 flash size fix 0:29:44 ScanEntry.matches fix 0:31:00 Don't blink blue…. 0:32:11 Fix crash when UART construct fails 0:34:00 only push main to S3 0:34:20 Remove OSError(0) and old network modules 0:35:18 nrf52840 build not booting 0:35:40 refactor pulseout to no take PWMOut 0:36:00 Ctrl-C is not interrupting deep sleep 0:37:36 start with pulseout_switch ( git commands ) 0:40:34 source code in sublime 0:45:17 in terms of microcontroller support, do you think we're coming to the point where the SAMD21 is just too small to be productive for future CircuitPython releases? 0:46:30 practical metrics on RAM usage in 6 versus 7 0:47:50 finding adafruit schematics - NEOSENSE_SWITCH 0:52:00 overhead camera) 0:54:00 oh look - it works :-) 0:54:25 Adafruit board) Circuit playground bluefruit revisions rev (G) 0:58:23 board.c - reset_board - turning off power switch 1:00:01 Is there a description of the different board revisions? I have a Circuit Playground Bluefruit Rev D and I'm not seeing anything here: https://github.com/adafruit/Adafruit-Circuit-Playground-Bluefruit-PCB 1:00:00 review the product page description 1:02:43 board init and board_deinit ( supervisor/port.c ) 1:08:30 back to the schematic - 1:11:59 make and test one more time - perfect! 1:13:27 not to Atmel SAMD 1:18:32 Serial/by-id in linux /dev/ as argument to tio 1:21:19 git commit support multiple status neopixels fix #5039 1:23:20 Should be Blue for Bluetototh? 1:24:35 Refactor pulseout 1:26:20 monitor CI ( continuous integration ) in the background 1:26:50 CP 6.3 readthedocs / pulseio.pulseout 1:28:00 pull/3279/files pull request 1:32:40 - not quite backwards compatible 1:33:50 need to test a bunch of ports 1:35:54 fetch the test program from other board 1:37:34 connect new board 1:38:30 there are other things in CP 7.0 that will be changes 1:39:20 would love people to make the CI faster 1:41:11 this test was even more accurate 1:42:40 STM32f405_express feather boot loader 1:43:40 that PR had a bug in it - need to fix that - add a default value for the count 1:47:15 pulseout_switch testing after git rebase 1:47:50 return to the learn guide for STM32F405 - Enabling DFU bootloader mode 1:48:40 dfu-util command ( in fish history! ) 1:49:15 dfu vs. uf2 for updates 1:50:07 is there support for stm32 in tinyuf2 1:50:58 now we are in safe mode - again tio /dev/serial/by-id provides value! 1:53:10 this is the problem with having the source code on the device :-) 1:55:40 - back to the Logic 2 - see that the deinit didn't work 1:57:05 plug for discotool 2:04:08 save code.py 2:08:18 wrapping up / rambling :-) 2:11:21 have a great one… ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ -----------------------------------------

This week on BSD Now, we clear up some ZFS FUD, show you how to write a NetBSD kernel module, and cover DragonflyBSD on the desktop. This episode was brought to you by Headlines ZFS is the best file system (for now) (http://blog.fosketts.net/2017/07/10/zfs-best-filesystem-now/) In my ongoing effort to fight misinformation and FUD about ZFS, I would like to go through this post in detail and share my thoughts on the current state and future of OpenZFS. The post starts with: ZFS should have been great, but I kind of hate it: ZFS seems to be trapped in the past, before it was sidelined it as the cool storage project of choice; it's inflexible; it lacks modern flash integration; and it's not directly supported by most operating systems. But I put all my valuable data on ZFS because it simply offers the best level of data protection in a small office/home office (SOHO) environment. Here's why. When ZFS first appeared in 2005, it was absolutely with the times, but it's remained stuck there ever since. The ZFS engineers did a lot right when they combined the best features of a volume manager with a “zettabyte-scale” filesystem in Solaris 10 The skies first darkened in 2007, as NetApp sued Sun, claiming that their WAFL patents were infringed by ZFS. Sun counter-sued later that year, and the legal issues dragged on. The lawsuit was resolved, and it didn't really impede ZFS. Some say it is the reason that Apple didn't go with ZFS, but there are other theories too. By then, Sun was hitting hard times and Oracle swooped in to purchase the company. This sowed further doubt about the future of ZFS, since Oracle did not enjoy wide support from open source advocates. Yes, Oracle taking over Sun and closing the source for ZFS definitely seemed like a setback at the time, but the OpenZFS project was started and active development has continued as an ever increasing pace. As of today, more than half of the code in OpenZFS has been written since the fork from the last open version of Oracle ZFS. the CDDL license Sun applied to the ZFS code was https://sfconservancy.org/blog/2016/feb/25/zfs-and-linux/ (judged incompatible) with the GPLv2 that covers Linux, making it a non-starter for inclusion in the world's server operating system. That hasn't stopped the ZFS-on-Linux project, or Ubuntu… Although OpenSolaris continued after the Oracle acquisition, and FreeBSD embraced ZFS, this was pretty much the extent of its impact outside the enterprise. Sure, NexentaStor and http://blog.fosketts.net/2008/09/15/greenbytes-embraces-extends-zfs/ (GreenBytes) helped push ZFS forward in the enterprise, but Oracle's lackluster commitment to Sun in the datacenter started having an impact. Lots of companies have adopted OpenZFS for their products. Before OpenZFS, there were very few non-Sun appliances that used ZFS, now there are plenty. OpenZFS Wiki: Companies with products based on OpenZFS (http://open-zfs.org/wiki/Companies) OpenZFS remains little-changed from what we had a decade ago. Other than the fact that half of the current code did not exist a decade ago… Many remain skeptical of deduplication, which hogs expensive RAM in the best-case scenario. This is one of the weaker points in ZFS. As it turns out, the demand for deduplication is actually not that strong. Most of the win can be had with transparent compression. However, there are a number of suggested designs to work around the dedup problems: Dedup Ceiling: Set a limit on the side of the DDT and just stop deduping new unique blocks when this limit is reached. Allocation Classes: A feature being developed by Intel for a supercomputer, will allow different types of data to be classified, and dedicated vdevs (or even metaslabs within a vdev), to be dedicated to that class of data. This could be extended to having the DDT live on a fast device like an PCIe NVMe, combined with the Dedup Ceiling when the device is full. DDT Pruning: Matt Ahrens described a design where items in the DDT with only a single reference, would be expired in an LRU type fashion, to allow newer blocks to live in the DDT in hopes that they would end up with more than a single reference. This doesn't cause bookkeeping problems since when a block is about to be freed, if it is NOT listed in the DDT, ZFS knows it was never deduplicated, so the current block must be the only reference, and it can safely be freed. This provides a best case scenario compared to Dedup Ceiling, since blocks that will deduplicate well, are likely to be written relatively close together, whereas the chance to a dedup match on a very old block is much lower. And I do mean expensive: Pretty much every ZFS FAQ flatly declares that ECC RAM is a must-have and 8 GB is the bare minimum. In my own experience with FreeNAS, 32 GB is a nice amount for an active small ZFS server, and this costs $200-$300 even at today's prices. As we talked about a few weeks ago, ECC is best, but it is not required. If you want your server to stay up for a long time, to be highly available, you'll put ECC in it. Don't let a lack of ECC stop you from using ZFS, you are just putting your data at more risk. The scrub of death is a myth. ZFS does not ‘require' lots of ram. Your NAS will work happily with 8 GB instead of 32 GB of RAM. Its cache hit ratio will be much lower, so performance will be worse. It won't be able to buffer as many writes, so performance will be worse. Copy-on-Write has some drawbacks, data tends to get scattered and fragmented across the drives when it is written gradually. The ARC (RAM Cache) lessens the pain of this, and allows ZFS to batch incoming writes up into nice contiguous writes. ZFS purposely alternates between reading and writing, since both are faster when the other is not happening. So writes are batched up until there is too much dirty data, or the timeout expires. Then reads are held off while the bulk linear write finishes as quickly as possible, and reads are resumed. Obviously all of this works better and more efficiently in larger batches, which you can do if you have more RAM. ZFS can be tuned to use less RAM, and if you do not have a lot of RAM, or you have a lot of other demand on your RAM, you should do that tuning. And ZFS never really adapted to today's world of widely-available flash storage: Although flash can be used to support the ZIL and L2ARC caches, these are of dubious value in a system with sufficient RAM, and ZFS has no true hybrid storage capability. It's laughable that the ZFS documentation obsesses over a few GB of SLC flash when multi-TB 3D NAND drives are on the market. And no one is talking about NVMe even though it's everywhere in performance PC's. Make up your mind, is 32GB of ram too expensive or not… the L2ARC exists specifically for the case where it is not possible to just install more RAM. Be it because there are no more slots, of limits of the processor, or limits of your budget. The SLOG is optional, but it never needs to be very big. A number of GBs of SLC flash is all you need, it is only holding writes that have not been flushed to the regular storage devices yet. The reason the documentation talks about SLC specifically is because your SLOG needs a very high write endurance, something never the newest NVMe devices cannot yet provide. Of course you can use NVMe devices with ZFS, lots of people do. All flash ZFS arrays are for sale right now. Other than maybe a little tuning of the device queue depths, ZFS just works and there is nothing to think about. However, to say there is nothing happening in this space is woefully inaccurate. The previously mentioned allocation classes code can be used to allocate metadata (4 KB blocks) on SSD or NVMe, while allocating bulk storage data (up to 16 MB blocks) on spinning disks. Extended a bit beyond what Intel is building for their super computer, this will basically create hybrid storage for ZFS. With the metaslab classes feature, it will even be possible to mix classes on the same device, grouping small allocations and large allocations in different areas, decreasing fragmentation. Then there's the question of flexibility, or lack thereof. Once you build a ZFS volume, it's pretty much fixed for life. There are only three ways to expand a storage pool: Replace each and every drive in the pool with a larger one (which is great but limiting and expensive) It depends on your pool layout. If you design with this in mind using ZFS Mirrors, it can be quite useful Add a stripe on another set of drives (which can lead to imbalanced performance and redundancy and a whole world of potential stupid stuff) The unbalanced LUNs performance issues were sorted out in 2013-2016. 2014: OpenZFS Allocation Performance (http://open-zfs.org/w/images/3/31/Performance-George_Wilson.pdf) 2016: OpenZFS space allocation: doubling performance on large and fragmented pools (http://www.bsdcan.org/2016/schedule/events/710.en.html) These also mostly solved the performance issues when a pool gets full, you can run a lot closer to the edge now Build a new pool and “zfs send” your datasets to it (which is what I do, even though it's kind of tricky) This is one way to do it, yes. There is another way coming, but I can't talk about it just yet. Look for big news later this year. Apart from option 3 above, you can't shrink a ZFS pool. Device removal is arriving now. It will not work for RAIDZ*, but for Mirrors and Stripes you will be able to remove a device. I've probably made ZFS sound pretty unappealing right about now. It was revolutionary but now it's startlingly limiting and out of touch with the present solid-state-dominated storage world. I don't feel like ZFS is out of touch with solid state. Lots of people are running SSD only pools. I will admit the tiered storage options in ZFS are a bit limited still, but there is a lot of work being done to overcome this. After all, reliably storing data is the only thing a storage system really has to do. All my important data goes on ZFS, from photos to music and movies to office files. It's going to be a long time before I trust anything other than ZFS! + I agree. + ZFS has a great track record of doing its most important job, keeping your data safe. + Work is ongoing to make ZFS more performance, and more flexible. The import thing is that this work is never allowed to compromise job #1, keeping your data safe. + Hybrid/tiered storage features, re-RAID-ing, are coming + There is a lot going on with OpenZFS, check out the notes from the last two OpenZFS Developer Summits just to get an idea of what some of those things are: 2015 (http://open-zfs.org/wiki/OpenZFS_Developer_Summit_2015) & 2016 (http://open-zfs.org/wiki/OpenZFS_Developer_Summit_2016) Some highlights: Compressed ARC Compressed send/recv ABD (arc buf scatter/gather) ZFS Native Encryption (scrub/resilver, send/recv, etc without encryption keys loaded) Channel Programs (do many administrative operations as one atomic transaction) Device Removal Redacted send/recv ZStandard Compression TRIM Support (FreeBSD has its own, but this will be more performant and universal) Faster Scrub/Resilver (https://youtu.be/SZFwv8BdBj4) Declustered RAID (https://youtu.be/MxKohtFSB4M) Allocation Classes (https://youtu.be/28fKiTWb2oM) Multi-mount protection (for Active/Passive failover) Zpool Checkpoint (undo almost anything) Even more Improved Allocator Performance vdev spacemap log ZIL performance improvements (w/ or w/o SLOG) Persistent L2ARC What I don't think the author of this article understands is how far behind every other filesystem is. 100s of Engineer years have gone into OpenZFS, and the pace is accelerating. I don't see how BtrFS can ever catch up, without a huge cash infusion. Writing a NetBSD kernel module (https://saurvs.github.io/post/writing-netbsd-kern-mod/) Kernel modules are object files used to extend an operating system's kernel functionality at run time. In this post, we'll look at implementing a simple character device driver as a kernel module in NetBSD. Once it is loaded, userspace processes will be able to write an arbitrary byte string to the device, and on every successive read expect a cryptographically-secure pseudorandom permutation of the original byte string. You will need the NetBSD Source Code. This doc (https://www.netbsd.org/docs/guide/en/chap-fetch.html) will explain how you can get it. The article gives an easy line by line walkthrough which is easy to follow and understand. The driver implements the bare minimum: open, close, read, and write, plus the module initialization function It explains the differences in how memory is allocated and freed in the kernel It also describes the process of using UIO to copy data back and forth between userspace and the kernel Create a Makefile, and compile the kernel module Then, create a simple userspace program to use the character device that the kernel module creates All the code is available here (https://github.com/saurvs/rperm-netbsd) *** DragonFlyBSD Desktop! (https://functionallyparanoid.com/2017/07/11/dragonflybsd-desktop/) If you read my last post (https://functionallyparanoid.com/2017/06/30/boot-all-the-things/), you know that I set up a machine (Thinkpad x230) with UEFI and four operating systems on it. One, I had no experience with – DragonFlyBSD (other than using Matthew Dillon's C compiler for the Amiga back in the day!) and so it was uncharted territory for me. After getting the install working, I started playing around inside of DragonFlyBSD and discovered to my delight that it was a great operating system with some really unique features – all with that BSD commitment to good documentation and a solid coupling of kernel and userland that doesn't exist (by design) in Linux. So my goal for my DragonFlyBSD desktop experience was to be as BSD as I possibly could. Given that (and since I'm the maintainer of the port on OpenBSD ), I went with Lumina as the desktop environment and XDM as the graphical login manager. I have to confess that I really like the xfce terminal application so I wanted to make sure I had that as well. Toss in Firefox, libreOffice and ownCloud sync client and I'm good to go! OK. So where to start. First, we need to get WiFi and wired networking happening for the console at login. To do that, I added the following to /etc/rc.conf: wlans_iwn0=”wlan0″ ifconfig_wlan0=”WPA DHCP” ifconfig_em0=”DHCP” I then edited /etc/wpa_supplicant.conf to put in the details of my WiFi network: network={ ssid=”MY-NETWORK-NAME” psk=”my-super-secret-password” } A quick reboot showed that both wired and wireless networking were functional and automatically were assigned IP addresses via DHCP. Next up is to try getting into X with whatever DragonFlyBSD uses for its default window manager. A straight up “startx” met with, shall we say, less than stellar results. Therefore, I used the following command to generate a simple /etc/X11/xorg.conf file: # Xorg -configure # cp /root/xorg.conf.new /etc/X11/xorg.conf With that file in place, I could get into the default window manager, but I had no mouse. After some searching and pinging folks on the mailing list, I was able to figure out what I needed to do. I added the following to my /etc/rc.conf file: moused_enable=”YES” moused_type=”auto” moused_port=”/dev/psm0″ I rebooted (I'm sure there is an easier way to get the changes but I don't know it… yet) and was able to get into a basic X session and have a functional mouse. Next up, installing and configuring Lumina! To do that, I went through the incredibly torturous process of installing Lumina: # pkg install lumina Wow! That was really, really hard. I might need to pause here to catch my breath.