Podcasts about Arduino Uno

Send us a textWe are on a short spring break at AI for Kid. We look forward to seeing you all in May. In the meantime, check out this replay with Archi Marrapu, a remarkable young inventor. • Explaining artificial intelligence as a "fake brain" that can mimic human intelligence and sometimes exceed human capabilities• Creating Project Pill Tracker, a 3D-printed medication management system with AI features that prevent medication errors• Working with tools like Arduino Uno kits, 3D printers, Flutter, and coding languages including Java and Python• Starting with curiosity and coding as entry points to learning about AI• Building confidence to overcome challenges and persist through failuresLinks to Resources: VoyceProject Pill TrackerOnchi 3d printingAutodesk inventorTinkercadArdino unoFlutter app developmentAndroid studiosJavaNIHStemifyGirlsContact Archi:Archi Marrapu LinkedInEmail: stemifygirls@gmail.com or founder.stemifygirls@gmail.comSupport the showHelp us become the #1 podcast for AI for Kids.Buy our new book "Let Kids Be Kids, Not Robots!: Embracing Childhood in an Age of AI"Social Media & Contact: Website: www.aidigitales.com Email: contact@aidigitales.com Follow Us: Instagram, YouTube Gift or get our books on Amazon or Free AI Worksheets Listen, rate, and subscribe! Stay updated with our latest episodes by subscribing to AI for Kids on your favorite podcast platform. Apple Podcasts Amazon Music Spotify YouTube Other Like our content, subscribe or feel free to donate to our Patreon here: patreon.com/AiDigiTales...

This week's Electromaker Show is now available on YouTube and everywhere you get your podcasts! Welcome to the Electromaker Show episode 142! This week we give away a Raspberry Pi 5, look into Bare Metal Assembly coding on the Arduino Uno, learn about Nordic's new flagship Cellular IoT System in Package, and find out about LattePanda's new x86 System on Module, the Mu! Tune in for the latest maker, tech, DIY, IoT, embedded, and crowdfunding news stories from the week.   Watch the show! We publish a new show every week. Subscribe here: https://www.youtube.com/channel/UCiMO2NHYWNiVTzyGsPYn4DA?sub_confirmation=1 We stock the latest products from Adafruit, Seeed Studio, Pimoroni, Sparkfun, and many more! Browse our shop: https://www.electromaker.io/shop Join us on Discord! https://discord.com/invite/w8d7mkCkxj​ Follow us on Twitter: https://twitter.com/ElectromakerIO Like us on Facebook: https://www.facebook.com/electromaker.io/ Follow us on Instagram: https://www.instagram.com/electromaker_io/ Featured in this show: MU: New product release from LattePanda Electromaker Blog (in reference to Embedded World interview) Raspberry Pi 5 4gb POTW giveaway Hardware Pioneers update Learn ARM Assembly on the ATMega328p with 1o_o7 AVRASM2 download (Forum link, use at own risk!) Nordic update their Cellular IoT line: nRF9161 & nRF9161 DK Nordic nRD9161 DK DECT Forum NR+ info

This week's Electromaker Show is now available on YouTube and everywhere you get your podcasts! Welcome to the Electromaker Show episode 131! This week we delve deeper into Nordic's Arduino compatible WiFi 6 IC, learn about MQTT on the Raspberry Pi, and discover the Robo Uno+ - a stem focused spin on the original Arduino Uno! Tune in for the latest maker, tech, DIY, IoT, embedded, and crowdfunding news stories from the week.   Watch the show! We publish a new show every week. Subscribe here: https://www.youtube.com/channel/UCiMO2NHYWNiVTzyGsPYn4DA?sub_confirmation=1 We stock the latest products from Adafruit, Seeed Studio, Pimoroni, Sparkfun, and many more! Browse our shop: https://www.electromaker.io/shop Join us on Discord! https://discord.com/invite/w8d7mkCkxj​ Follow us on Twitter: https://twitter.com/ElectromakerIO Like us on Facebook: https://www.facebook.com/electromaker.io/ Follow us on Instagram: https://www.instagram.com/electromaker_io/ Featured in this show: New Arduino Cloud Banana Pi BPI R4 Router Nordic nRF7002 EK Product of the Week + Giveaway Robo Uno+ on Crowd Supply MQTT on Raspberry Pi Tutorial Series

Chris and Elecia discuss the pros and cons of completing one project or starting a dozen.  Elecia's 2nd edition of Making Embedded Systems is coming out in March. (Preview is on O'Reilly's Learning System.) She's working on a companion repository that is already filled with links and goodies: github.com/eleciawhite/making-embedded-systems.  If you'd like to know more about signal processing, check out DSPGuide.com aka The Scientist and Engineer's Guide to Digital Signal Processing By Steven W. Smith, Ph.D. And as noted in last week's newsletter, there is an interesting overlap between smoothies and the Fourier Transform.  Giang Vinh Loc used  Charles Lohr's RISCV on Arduino UNO to boot Linux (in 16 hours).  We also talked a bit about Greg Wilson's recent episode with Elecia (Embedded 460: I Don't Care What Your Math Says). Transcript Thanks to Nordic for sponsoring this week's show! Nordic Semiconductor empowers wireless innovation, by providing hardware, software, tools and services that allow developers to create the IoT products of tomorrow. Learn more about Nordic Semiconductor at nordicsemi.com, check out the DevAcademy at academy.nordicsemi.com and interact with the Nordic Devzone community at devzone.nordicsemi.com.

This week's EYE ON NPI is a new spin on an old familiar classic, it's Arduino's UNO R4 Minima and R4 WiFi Boards (https://www.digikey.com/en/product-highlight/a/arduino/uno-r4-minima-and-r4-wifi-boards) now in stock at DigiKey for folks who want a 5V microcontroller board with classic UNO-compatibility but a ton more speed, flash and RAM! The UNO R4 comes in two flavors, the Minima (https://www.digikey.com/short/r70jbj93) is low cost, only $20, whereas the UNO R4 WiFi (https://www.digikey.com/short/qj072pnm) is $27.50 and adds WiFi and BLE via an ESP32-S3 plus a cute monochrome LED grid for scrolling messages or displaying status icons. This pair of dev boards look just like those classic Arduino boards you probably learned to code and hack on, they've been around for almost 20 years, the first board looked very similar, but had a RS232 serial port instead of USB, and all through-hole components (https://blog.arduino.cc/2021/12/09/one-board-to-rule-them-all-history-of-the-arduino-uno/). Through various iterations and improvements, the original board was redesigned to add USB and update to the ATmega168 with the Diecimila (https://docs.arduino.cc/retired/boards/arduino-diecimila) and then the ATmega328 plus auto-power-switching Duemilanove (https://docs.arduino.cc/retired/boards/arduino-duemilanove) in 2009. In 2010 the most popular Arduino to date was released, the UNO, which updated the USB port to use an ATmega16u2 and through various small revisions added the IOref pin to allow 3V power/logic and separate I2C pins since A4/A5 were no longer always connected to a TWI peripheral. Since about 2012, which was the release date of the UNO R3, not a lot has happened with that particular configuration/shape. Arduino the company has released a ton more boards but in different form factors, all available at DigiKey: Nano, Due, MKR, Portenta etc. (https://www.digikey.com/en/supplier-centers/arduino) and you should definitely check them out! But it's also a big deal when the main workhorse of the family gets a respin. Particularly since the new R4 takes a very different direction than the previous UNOs: instead of just upgrading the atmegaxx8 chipset, Arduino has gone with the totally different ARM Cortex-based RA4M series which we've covered on a previous EYE ON NPI (https://blog.adafruit.com/2023/05/25/eye-on-npi-renesas-ra4m1-microcontroller-series-eyeonnpi-digikey-renesasglobal-digikey-adafruit/) In that video we covered a lot about the chip itself so check it out if you're interested in the specifics of that chip family. The chip itself is a similar family to the ARM Cortex M0-based SAMD21 'Arduino Zero' (https://store-usa.arduino.cc/products/arduino-zero?selectedStore=us) but thanks to the Renesas version of this core, we now get the 5V-run RA4M. From Arduino's description, here are some of the updates: - Hardware compatibility with UNO form factor: The UNO R4 Minima maintains the same form factor, pinout, and 5 V operating voltage as its predecessor, the UNO R3. This ensures a seamless transition for existing shields and projects, leveraging the extensive and unique ecosystem already established for the Arduino UNO. - Expanded memory and faster clock: Prepare for more precise calculations and the ability to handle complex projects with ease. The UNO R4 Minima boasts increased memory and a faster clock speed, empowering you to tackle demanding tasks effortlessly. - Extra on-board peripherals: The UNO R4 Minima introduces a range of on-board peripherals, including a 12-bit DAC, CAN BUS, and OP AMP. These additional components provide you with expanded capabilities and flexibility in your designs. - Extended 24 V tolerance: The UNO R4 Minima now supports a wider input voltage range, allowing power supplies up to 24 V. This enables seamless integration with motors, LED strips, and other actuators, simplifying your projects by utilizing a single power source. - SWD connector: Debugging is a critical aspect of any project. Simply connect an external debugger to the UNO R4 Minima and effortlessly monitor the inner workings of your system. Stay in control and gain valuable insights. - HID support: The UNO R4 Minima comes with built-in HID (Human Interface Device) support, enabling it to simulate a mouse or keyboard when connected to a computer via a USB cable. This convenient feature makes it a breeze to send keystrokes and mouse movements to a computer, enhancing usability and functionality. At $20 a piece, these new Arduino UNO R4s (https://www.digikey.com/short/qj072pnm) are a great price for the high quality you get from Arduino - and there's lots of them in stock at DigiKey for immediate shipment! Grab both the UNO R4 Minima (https://www.digikey.com/short/r70jbj93) and UNO R4 WiFi (https://www.digikey.com/short/qj072pnm), and they'll ship immediately so you can get started moving your 8-bit micro projects to Cortex-M4 by tomorrow afternoon

This week's Electromaker Show is now available on YouTube and everywhere you get your podcasts! Welcome to the Electromaker Show episode 114! This week we look at the new Arduino Uno R4 WiFi and Minima, meet the Electromakers of the Month for June, and much more! Tune in for the latest maker, tech, DIY, IoT, embedded, and crowdfunding news stories from the week.   Watch the show! We publish a new show every week. Subscribe here: https://www.youtube.com/channel/UCiMO2NHYWNiVTzyGsPYn4DA?sub_confirmation=1 We stock the latest products from Adafruit, Seeed Studio, Pimoroni, Sparkfun, and many more! Browse our shop: https://www.electromaker.io/shop Join us on Discord! https://discord.com/invite/w8d7mkCkxj​ Follow us on Twitter: https://twitter.com/ElectromakerIO Like us on Facebook: https://www.facebook.com/electromaker.io/ Follow us on Instagram: https://www.instagram.com/electromaker_io/ Featured in this show: The Arduino Uno R4 is here! Nordic nPM1300 EK Dangerous Hotdog Cooker Electromaker of the Month - June 2023 Winners Product of the Week: nRF5430 Audio DK RedHat annoys absolutely everyone

we just got our UNO R4 WiFi, featuring the Renesas RA4M1 series of chips https://blog.adafruit.com/2023/05/25/eye-on-npi-renesas-ra4m1-microcontroller-series-eyeonnpi-digikey-renesasglobal-digikey-adafruit/ an ESP32 wifi co-processor, an adorable LED grid, and a JST SH 4-pin connector...a.k.a a Qwiic port! Yay it is so great to see this connector becoming standardized on so many platforms. It means that all of our STEMMA QT devices https://www.adafruit.com/category/1018 will work plug-and-play. Here we're testing it with an OLED https://www.adafruit.com/product/938 and SHT41 breakout https://www.adafruit.com/search?q=sht4 we only had to update our demo to use Wire1 instead of Wire, since the secondary I2C bus is used for this connector. No soldering required! #adafruit #arduino #renesas 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/ ----------------------------------------- @Arduino @RenesasPresents

This week's Electromaker Show is now available on YouTube and everywhere you get your podcasts! Welcome to the Electromaker Show episode 105! This week we look at the exciting new changes to the Arduino Uno, look at an inventive IR based Smart Home funding campaign, and see the prize winning Electromaker of the Month projects! Tune in for the latest maker, tech, DIY, IoT, embedded, and crowdfunding news stories from the week.   Watch the show! We publish a new show every week. Subscribe here: https://www.youtube.com/channel/UCiMO2NHYWNiVTzyGsPYn4DA?sub_confirmation=1 We stock the latest products from Adafruit, Seeed Studio, Pimoroni, Sparkfun, and many more! Browse our shop: https://www.electromaker.io/shop Join us on Discord! https://discord.com/invite/w8d7mkCkxj​ Follow us on Twitter: https://twitter.com/ElectromakerIO Like us on Facebook: https://www.facebook.com/electromaker.io/ Follow us on Instagram: https://www.instagram.com/electromaker_io/ Featured in this show: Experimental Pong on WS2812B LED strips Electromaker of the Month - March winners Aeroh Link - hackable IR board Pi Pico fingerprint/screen/joystick HAT Product of the Week: Adafruit's PIR Motion sensor module. The Arduino Uno just got a massive Upgrade STLINK-V3PWR is an all in one Debugger and Power monitor

we spent this evening updating this cute menorah project we've had for over a decade, from an Arduino UNO to run on a RP2040 QT Py board (https://www.adafruit.com/product/4900) with our prototype "IoT Button BFF" board to increment through the nights. we used PaintYourDragons' LED candle flicker code from this halloween project (https://learn.adafruit.com/circuit-playground-jack-o-lantern) and sorta mixed it with Liz's NeoPixel menorah project from last year (https://learn.adafruit.com/neopixel-menorah). this project predates NeoPixels - all we had were WS2801's at the time! we think it looks pretty nice now, and its a lot more compact :) #Hanukkah #menorah #circuitpython 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/ -----------------------------------------

Az első, megfizethető és könnyen programozható Arduino Uno-tól a Raspberry Pi-on, ESP8266 alapú Sonoff-on és Shelly-n keresztül ismerjük meg az alulról építkező okosotthon technológiák múltját, hogy megérthessük a jelenét és jövőjét.Support the showItt kereshetsz minket: info@okosotthon.club Hosztok: Zsák Péter FacebookWeb Fabó Gergő BeReal OkosOtthon Club WebFacebookYoutubeInstagram

Hoy es Miercoles 7 de Septiembre y es miércoles de proyectos Máquina de hacer cerámica con almidón de maíz Construir un torno de alfarero es un proyecto relativamente sencillo. Construir un dispositivo para alfarería de arcilla de almidón de maíz, respetuosa con el medio ambiente, es más complicado. Y usar las piezas recuperadas de un viejo reproductor de CD y una impresora ya es llevar las cosas a otro nivel, pero así es exactamente cómo surgió esta ingeniosa creación impulsada por el Arduino Mega 2560. El viejo reproductor de CD hace girar la pieza para el trabajo manual, mientras que los motores de la impresora se utilizan para añadir detalles a la pieza terminada. Hecho por: Guillermo Perez Guillen Más información en: Hackaday.io Acceso de seguridad En este tutorial se explica el funcionamiento de un lector RFID y cómo este puede ser la base de un sistema de seguridad. Necesitas un Arduino Uno, un chip breakout de lector RFID y algunas tarjetas RFID/NFC. El proyecto está bien documentado y es fácil de construir. Hecho por: Aritro Mukherjee Más información en: Arduino Project Hub. Robot de dibujo Aquí tienes un proyecto fácil y divertido, apto para principiantes. Aunque el robot de dibujo tenga el aspecto de una solución casera, en realidad es preciso, fácil de construir y muy barato. Podrás fabricar las piezas necesarias con tu impresora 3D y un Arduino Uno se encargará de todos los movimientos. Hecho por: DAZ projects Más información en: Arduino Project Hub Velocímetro ¿Quieres saber a qué velocidad se mueve una pelota de tenis, tu perro o tu coche? Con un Arduino Nano y un sensor de ultrasonidos puedes construir este pequeño velocímetro. Mide la distancia de un objeto en movimiento en el intervalo de 1 segundo y, a continuación, calcula el movimiento del objeto en cm/s. Hecho por: mircemk Más información en: Arduino Project Hub Radar Con un poco de ayuda de un sensor de ultrasonidos, un trozo de cartón y un pequeño servomotor, necesario para hacer rotar todo el conjunto, puedes construir una pequeña estación de radar portátil. Conéctala a una pantalla para ver los datos de los gráficos en verde fluorescente, al más puro estilo ochentero. Hecho por: Dejan Más información en: How To Mechatronics

This week's EYE ON NPI is right on time with the MAX31329 Low Current Real-Time Clock RTC (https://www.digikey.com/en/product-highlight/a/analog-devices/max31329-low-current-real-time-clock), which will fit wonderfully into your power, board size and materials budget no matter how small. We are digging this fully-integrated RTC, with a lot of li'l extras that make it an excellent choice for compact products. A Real Time Clock a.k.a. RTC (https://en.wikipedia.org/wiki/Real-time_clock) is a specialty chip that is designed to be ultra low power, so even when everything else in the circuit is turned off, it can still sip power from a super capacitor or tiny battery and keep track of time. It's how your computer and devices can go all the way down to 0% power and yet still know what time it is when recharged/re-powered. Note this is different than storage memory because details like your WiFi password don't need updating every second whereas an RTC has to keep ticking second after second until main power comes back up. Just about everything you own has an RTC in it because timekeeping is so essential to functionality. There are some chips that have built in RTCs but often these are just counters and are not as low power as a true RTC chip. The MAX31329 for example, has a "240nA Timekeeping Current", whereas only the most power-optimized microcontrollers can get below 1uA. Compare it to the DS1307 which has twice the current, ~500nA! With such low currents, you can even use a super cap (https://www.digikey.com/en/products/detail/elna-america/DSK-3R3H703T414-HRL/2171199) instead of a lithium battery to keep time, meaning no special shipping management or battery replacements. Wondering how big a capacitor you'd need? Maxim's got ya covered with their handy super-cap calculator (https://www.maximintegrated.com/en/design/design-tools/calculators/product-design-calculators/supercap.html) OK, so it's low power. What else is so great about it? We also really like that the crystal is in-package integrated! Every RTC needs a crystal oscillator, the thing that actually does the counting of time. The crystals are almost always 32.768KHz crystals (https://www.digikey.com/en/products/detail/abracon-llc/ABS25-32-768KHZ-T/675361?s=N4IgTCBcDaIIYCMBOcDGB7AdgAgIICEBlMAVgFoBmMAOgHYA2ADgGkAJALTIBUQBdAXyA) so the chips count the vibrations into a 16-bit counter. When the counter overflows, a second has passed. Often the crystal is the same size as the chip, or if it's integrated, the chip is pretty large. like in the case of the DS3231.(https://www.adafruit.com/product/3013) In this case, we keep the nice smol size. A nice side effect of having a crystal integrated is improved tuning! Having a precise crystal, say +-5ppm like the Citizen CM315D32768 (https://www.digikey.com/en/products/detail/citizen-finedevice-co-ltd/CM315D32768HZFT/5970266) adds another 50 cents to the bill of materials. Not needed here, it's inside and tuned to that fancy 5ppm. Ideally they'd have a temperature-compensated version in the future, since that can get the precision down to 2ppm but 5ppm is still four times better than most low cost 32khz crystals. Finally, a few small but kind details we caught in the datasheet (https://www.maximintegrated.com/en/products/analog/MAX31329.html): the RTC is 1.6V thru 5V logic friendly, so you can use it with any kit you've got. There's 64 bytes of battery-backed SRAM. I2C has a timeout feature in case of I2C bus jitters which happen at low power dips. Automatic power-switchover to battery when main power droops. Trickle charging with built-in diode and various internal resistors. External clock source select, such as GPS 1pps or line power 50/60hz. This is a nice RTC, at a nice price, and you can book your order for the Maxim MAX31329 at Digi-Key right now (https://www.digikey.com/short/vqrcfdw3) for shipment the moment they come in stock. According to the lead time estimates, this part will be shipping in about 3 weeks / mid-June so you can start designing it into your PCB and chips will come in right when the prototype PCB is complete. While you're waiting you can also pick up one of the MAX31329 shield evaluation boards (https://www.digikey.com/short/ztdw8wfj) which can be plugged into any Arduino-Uno-like microcontroller and also comes with a development board if you just want to use the built in firmware/software.

This week's Electromaker Show is now available on YouTube and everywhere you get your podcasts! Welcome to the Electromaker Show episode 80! This week we look at machine learning running on an Arduino Uno, a new kind of vision sensor, and Framework's plan for old laptop mainboards. Tune in for the latest maker, tech, DIY, IoT, embedded, and crowdfunding news stories from the week.   Watch the show! We publish a new show every week. Subscribe here: https://www.youtube.com/channel/UCiMO2NHYWNiVTzyGsPYn4DA?sub_confirmation=1 We stock the latest products from Adafruit, Seeed Studio, Pimoroni, Sparkfun, and many more! Browse our shop: https://www.electromaker.io/shop Join us on Discord! https://discord.com/invite/w8d7mkCkxj​ Follow us on Twitter: https://twitter.com/ElectromakerIO Like us on Facebook: https://www.facebook.com/electromaker.io/ Follow us on Instagram: https://www.instagram.com/electromaker_io/ Featured in this show: Vilima's Minority Report Kitchen Timer NXP Cup Video Updates TinyML on an Arduino UNO Mini Billiards Game Bean Counter USB to TTL Kickstarter Metavision Vision Sensor Framework providing tools to stop E-Waste Seeed testing LoRaWan

Joining us today is Kaleb Clark, to talk about some of his projects including a Helicopter Collective Joystick Control and a Conversion Calculator made with the Arduino Uno! This is an exciting conversation for all makers who enjoy DIY projects alike!  Kaleb's youTube Channel: https://www.youtube.com/channel/UCZbQgfShqdTABBYJ8xd4kSg Element14 Community Page: https://community.element14.com/challenges-projects/element14-presents/project-videos/w/documents/4810/episode-440-diy-arduino-helicopter-collective-joystick-control Helicopter Collective Joystick Control: https://community.element14.com/challenges-projects/element14-presents/project-videos/w/documents/8664/episode-455-arduino-unit-conversion-calculator?CMP=SOM-YOUTUBE-PRG-E14PRESENTS-ARDUINO-UNIT-CONVERSION-CALCULATOR-COMM Buy access to all our courses now - For a limited time just 19USD per month with a 30 day satisfaction or your money back "No Hassle" guarantee! https://bit.ly/3xllpd ***About Us:*** This Arduino lesson was created by Programming Electronics Academy.  We are an online education company who seeks to help people learn about electronics and programming through the ubiquitous Arduino development board. ***We have no affiliation whatsoever with Arduino LLC, other than we think they are cool.***

Dans le bonus de notre épisode #332 : Google > Google ferme enfin la Google Toolbar. (source) G7 > Tesla suspendu par les taxis G7 parisiens. (source) IA > Un cadre éthique pour les IAs proposés par des chercheurs européens. (source) T'as pas dit.... > 10M d'arduino Uno vendu et,une version mini. (source) Réparable > Dell annonce des laptops réparables. (source)

Join Scott today as he gets CircuitPython going on the Raspberry Pi Zero 2W. Visit the Adafruit shop online - http://www.adafruit.com 0:00 Getting Started 0:00:45 hello 0:03:34 working on bare metal Circuit Python (CP) on raspberry pi 0:04:30 USB issues (dmesg) on Scott's linux computer 0:05:30 Comparing M1 Mac vs. Desktop computer 0:07:01 Housekeeping / Intro 0:08:30 Next week - Friday, taking Thanksgiving weekend off 0:09:25 Tom's Hardware Pi Cast next Tuesday 11:30 AM Pacific Time 0:11:50 SD card library search and progress ongoing 0:16:15 Ethernet / NetBoot ( SD card boot is more reliable ) 0:17:10 Q: What would you recomend for recording data from 9DOF IMU sensor. Maybe Pi Zero or Pico or is Arduino Uno or Nano better for this 0:18:23 netboot over TFTP 0:20:01 Using the SparkFun SD card breakout 0:20:49 switch to desktop - attempt to use netboot 0:21:40 Do you have any recommendations for making string formatting a bit faster in CircuitPython code? Or is it just one of those convenient things that takes a ton of cycles no matter what? 0:22:30 f-strings on CP just get translated to format() 0:24:05 To the comment on Twitter. Seeing Circuit Python written in Rust at some point would be fun. Getting it running on an Raspberry Pi would also be fun. Calling it RPy would be full circle on many levels 0:26:18 highpoint technology 4-port USB RocketU 1244A 0:28:22 switching configuration to Pi-Zero ( no HMI USB adapter today ) 0:30:14 Zero-2 with Debug ‘hat', and power supply 0:33:15 Start with Pi-4, then Zero 2, then the other architectures 0:34:20 starting with 64 bit builds - others might need to switch compilers 0:35:40 the main problem is having the USB broken out directly 0:37:11focus on the build process - make * zero2w * 0:38:05 Q:If the Zero is supported, would the RPi Model B (w/256mb) be supported since they use the same SoC? 0:40:33 boot and LED 0:41:55 If the Zero is supported, would the RPi Model B (w/256mb) be supported since they use the same SoC? 0:43:40 dig into OpenOCD and Pi 0:47:10 install lsof to see which process is using port 0:49:00 source tinyusb gdbinit 0:49:20 system timer is not working 0:51:06 Jinja built on top of SVD 0:53:10 Pin muxing in gen_svd.py - bcm2837_lpa.svd 0:54:16 update peripheral addresses - 2837 base address ultibo.org 0:55:17 base address is mapped 0:58:03 generate svd files and headers - 42,000 line xml file 0:58:31 generates bcm2837_lpa.h 0:59:37 svn_load peripherals/svd/gen/bcm2837_lpa.scd ( in gdb ) 1:00:31 svd UART1 to read memory 1:01:10 I'd like to drive HDMI or DisplayPort from the FPGA fabric (This part I'm pretty good at) and run CircuitPython from the HPS (There it's over my head…). 1:04:37 Note: time zone change next week here in the USA 1:07:17 bcm2835-peripherals map physical 1:07:59 raspi3-tutorial 07 delays 1:08:59 MMIO BASE should be correct 1:09:40 let's just see if it works … 1:11:37 include appropriate file based on BCM_VERSION ( 2837 vs. 2711 ) 1:12:43 add BCM_VERSION to Makefile 1:13:37 use rg to search for includes of bcm2711_lpa.h that need to be updated 1:18:57 now only defines.h includes it 1:19:50 generated file is “empty” - ?? 1:20:22 rebuilding 1:21:00 free running counter doesn't seem incrementing 1:23:42 back to the memory map 1:24:40 totally off topic Q... in CPY/MPY, when using MP_DEFINE_CONST_FUN_OBJ_KW with 1-7 kwargs, how do I determine which were actually set? I want to update members of a struct, but only the ones that were passed in. I have it working, but it stomps all with the default const if that kwarg was not passed. 1:26:50 How does one ask the MMU what physical address it is reading? 1:29:30 uart output? ( garbage, but at least it is something ) 1:31:54 mailbox call to set clock 1:33:49 look how others ( tutorial etc) set clock 1:36:00 try adjusting the clock frequency 1:38:26 boot messages - readable now! 1:41:27 openocd - HardFalt handlers 1:41:57 How much memory do we “really” have ? 1:42:36 The bootloader is closed-source but there are a few stubs available 1:43:52 check how the memory is set up in the MMU 1:52:24 wrap up memory addressing in mmu.c 1:54:00 reboot with changes - to REPL !!! ( output looked good -then crashed ) 1:57:05 consider the interrupt stuff ( may be wrong ) 2:00:08 next: edit interrupts.c ( handle_irq ) for zero 2:01:43 - see github 2:07:57 housekeeping and wrap up - USA changes time zone this weekend 2:09:54 Pi Cast next Tuesday 2:10:32 cat cam 2:11:12 have a great weekend! ----------------------------------------- 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/ -----------------------------------------

Could this week's EYE ON NPI help you with communicating with far away I2C sensors and devices? Yes, indeed it CAN! This week we're featuring the Analog Devices LT3960 (https://www.digikey.com/en/product-highlight/a/analog-devices/lt3960-high-speed-transceiver), a handy chip that will let you take advantage of the noise-durability of CAN with the universality of I2C. The LT3960 is a high-speed transceiver which creates the functional equivalent of a single-master I2C bus in the CAN physical layer and is powered from a single wide-ranging input voltage. Using two integrated CAN transceivers, the LT3960 creates a differential proxy for each of the single-ended I2C clock and data signals which is capable of traversing harsh or noisy environments across two twisted pairs. Please note! The LT3960 is not a I2C to CAN bus converter/adapter. It isn't like your CAN devices will appear on an I2C bus or vice versa. It's just a physical-layer converter: basically it lets you use your existing I2C controllers and peripherals but without the restrictive single-ended transmission layer: It should be noted that while the LT3960 uses the CAN physical layer to conduct bidirectional I2C data, the CANSCL and CANSDA buses created by the LT3960 are not traditional CAN buses carrying traditional CAN data. As such, the CANSCL and CANSDA buses between LT3960 devices cannot be shared with standard CAN transceivers in a multidrop configuration. However, you can (ha!) have multiple I2C sensors on the end of the long cable, either by having multiple sensors connected to one LT3960 or multiple LT3960's tied to the I2CAN bus along the route. A nice touch is the separate VIN pin, connected to a high-voltage LDO that can drop 60V down to 3.3V so you could also pass a high voltage power signal down the cable that could be then regulated at the end, locally, to provide power to the transceiver and sensor. This could do a great job for automotive/robotics/industrial/agricultural sensor systems with long distances or electrically-noisy environments, without having to go to wireless or having 'smart' nodes. OK so why not just use CAN bus straight-up, instead of this converter? Well, I2C is the vastly more popular protocol for a variety of sensors and devices - it's supported by every microcontroller and microcomputer we've ever seen. If you wanted to use CAN, you'd have to connect an existing I2C sensor to a microcontroller/computer with CAN and then write and support the converter firmware. But most low cost microcontrollers don't have native CAN - it's considered an advanced peripheral, so now you have to go with a pricey chip like the STM32F405 (https://www.digikey.com/en/products/detail/adafruit-industries-llc/4382/10673113) or you could try tacking a CAN converter chip (https://www.digikey.com/en/products/detail/microchip-technology/MCP2515T-I-SO/593681) onto your existing nodes, also not cheap and now adds another failure risk. So whether you're using an Arduino UNO, STM32F405 or Raspberry Pi main controller or data logger, you can take advantage of the existing I2C controller you've already got. Then use this low cost chip on either side of your sensor network to create a durable network without the added complexity of having I2C-to-CAN nodes. So for example, if you have a greenhouse with a plethora of SHT30-based soil sensors (https://www.digikey.com/en/products/detail/adafruit-industries-llc/4099/10230011), each on I2C, you can stick this chip on the end of each sensor and voila, the data can be run all the way to the end of the building (and with that 60V LDO, your CAT-5 cable (https://www.digikey.com/en/products/detail/amphenol-cables-on-demand/MP-5ERJ45UNNB-003/6052293) can provide power too). Sprinkle a few of these over your design and sweep away your EMI and stray capacitance problems with no change in firmware. This NPI just dropped, so sign up at digikey.com to be notified the moment the LT3960's (https://www.digikey.com/short/9wp0j1f5) are in stock!

All are welcome, show your 3D printing project, Arduino project, CircuitPython project, Raspberry Pi project, work bench, your work from home desk set up, your cat, your dog, the things your kids made over the last week while home from school. There is no better time to come together, we’ll see you there! and stop by Discord to get the link to join LIVE! Join the Discord https://adafru.it/discord Watch the Playlist on YouTube https://www.youtube.com/playlist?list=PL7E1FAA9E63A32FDC Guide: How to join Show and Tell https://learn.adafruit.com/show-and-tell Visit the Adafruit shop online - http://www.adafruit.com​ ---------------------------------------------------------------------------------------------- Sherry @0:34 Maker Music Festival preview John @5:37 rotary encoder breakouts Jeff @8:11 RGB Matrix on ESP32S Phil B. @9:03 automated pin references Melissa @11:14 Adafruit FunHouse water sensor Dan @13:00 dynamic USB descriptors in CircuitPython Liz @17:36 Adafruit FunHouse solder fume extractor Micha @19:30 kernel development Mark @21:37 Adafruit FunHouse house number control Cristobal @24:25 Arduino Uno tv-b-gone

All are welcome, show your 3D printing project, Arduino project, CircuitPython project, Raspberry Pi project, work bench, your work from home desk set up, your cat, your dog, the things your kids made over the last week while home from school. There is no better time to come together, we’ll see you there! and stop by Discord to get the link to join LIVE! Join the Discord https://adafru.it/discord Watch the Playlist on YouTube https://www.youtube.com/playlist?list=PL7E1FAA9E63A32FDC Guide: How to join Show and Tell https://learn.adafruit.com/show-and-tell Visit the Adafruit shop online - http://www.adafruit.com​ ---------------------------------------------------------------------------------------------- Sherry @0:34 Maker Music Festival preview John @5:37 rotary encoder breakouts Jeff @8:11 RGB Matrix on ESP32S Phil B. @9:03 automated pin references Melissa @11:14 Adafruit FunHouse water sensor Dan @13:00 dynamic USB descriptors in CircuitPython Liz @17:36 Adafruit FunHouse solder fume extractor Micha @19:30 kernel development Mark @21:37 Adafruit FunHouse house number control Cristobal @24:25 Arduino Uno tv-b-gone

Thinking about getting an Arduino and not how how to set it up? Want to see a use for the Arduino that requires zero programming? Stay tuned and I will ... The post Your First Project with Arduino Uno R3 to experience Cryptomining first appeared on TechBytes With Ron Nutter.

Today on Mushroom Hour we are blessed by the presence of Noah Kalos, founder of the groundbreaking Youtube and social media channels “MycoLyco”. This work is a blend of his passions for nature, mycology and electronic music. He originally got hooked on electronic music production at the age of 17, but in the past 6 years Noah took that passion to the next level, getting deep into digital music hardware and electrical engineering. Noah majored in studio art at Oberlin College and then spent 5+ years living in the woods transitioning between outdoor roles as a camp counselor and nature therapist. During his time in the wild, he became familiar with all kinds of wild foods and has been a longtime mycology enthusiast. In the wake of the pandemic, Noah decided to focus on growing mushrooms. His plan was to convert his music studio into a mycology lab, but after a fateful connection between mycelium and synth electrodes, the studio and lab became one in the same. Now with his MycoLyco project, Noah has been giving us all a window into the incredible musical frequencies of fungi. (Intro and Outro music is the sound of mushrooms from the new MycoLyco album!)Topics Covered:Noah’s Origin Story Years Spent Living in Nature Mushroom Cultivation & Cordyceps Marriage of Synth and Mushroom - Birth of Myco Lyco Waves and Resistance Converting into Digital Sounds Biodata Sonification Responses to Stimuli & Rhythmic Spiking Behaviors Hooking up Crystals, Cacti and Orchids to the Synthesizer Unique Hallmarks of Mushroom Sound Waves Is there Sonic Communication Between Mushrooms? Mycelium Sentience Fungi Offering New Perspectives Explosion of Citizen Science and Autodidactic Learning Tips for Exploring Modular Synth Future Plans for Myco Lyco Episode Resources:Myco Lyco Youtube: https://www.youtube.com/channel/UCsmw-u-2kzPQPO5n9sTpcyA Myco Lyco Tik Tok: https://www.tiktok.com/@mycolyco?lang=en Myco Lyco IG: https://www.instagram.com/mycolyco/ Myco Lyco FB: https://www.facebook.com/mycolycomycology/ Midisprout/Plantwave: https://www.midisprout.com/ Instruo Scion: https://www.instruomodular.com/ MAKEN0ISE YT: https://www.youtube.com/user/MAKEN0ISE Divkid YT: https://www.youtube.com/user/DivKidVideo Andrew is Music YT: https://www.youtube.com/user/songstowearpantsto Arduino Uno: https://store.arduino.cc/usa/arduino-uno-rev3 Biodata Sonification Github: https://github.com/13-37-org/midi-biodata

Special guest Timon (@timonsku) joins us to show off his home-made CM4 carrier module, which is as small as an Arduino Uno board. Les demos his Raspberry Pi-controlled Christmas tree and Avram shows you how to set up a Pi as a network drive.

This all-in-one Metro design is Arduino UNO shaped so it works with shields, and features an iMX RT1011 500 MHz processor with 128K of RAM and QSPI memory. Even though it doesn't have a ton of RAM, it's got a nice speediness to it which we really dig. Here we are testing out CircuitPython 6 with the AirLift WiFi co-processor to get data from the interwebs and display it on an OLED. The OLED plugs right into the stemma QT connector so its really easy to get sensors and displays attached! This is coming soon and will be here - https://adafruit.com/new #nxp #adafruit #iMXRT1011 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 new Metro features the USB/WiFi/PSRAM capable ESP32 module - we are testing it with Arduino (there's a branch for ESP32S2 support and it seems to work OK!) This Metro has built-in LiPoly battery support, STEMMA QT connector, and its 'Arduino UNO' shaped so our shields can be tested as well. Here we're trying out our 2.8" TFT Shield, the SPI is incredibly fast zooom. You can sign up to be notified when these are in the shop and ready to buy here - https://www.adafruit.com/product/4775 #esp32s2 #arduino #adafruit 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/ -----------------------------------------

En la entrega número 10, exploramos la última ocurrencia de Elon Musk, el Neuralink. Es decir, implantarnos un Arduino Uno en la quijotera. Además, reflexionamos sobre universos futuros donde la cerda Gertrude se convierte en la pionera de una superraza de ciberjamones de ciberjabugo.Por último, intentamos adelantar qué desastres traerá la expansión de la tecnología Neuralink, para una gente tan monkey como nosotros.

Nuevo capítulo de la quinta temporada esta vez le toca a Arduino UNO y la historia de la placa que dio origen al hardware y software libre. Más información en https://programarfacil.com/blog/arduino-uno-r3/

Nuevo capítulo de la quinta temporada esta vez le toca a Arduino UNO y la historia de la placa que dio origen al hardware y software libre.Más información en https://programarfacil.com/blog/arduino-uno-r3/

Our Online Puzzle Games: https://www.fortescapegames.com/games KSGR Soldering Iron:https://usa.banggood.com/V2_1S-T12-Digital-Temperature-Controller-Soldering-Station-Electric-Soldering-Iron-Tips-T12-K-907-Handle-p-1338117.html?rmmds=myorder&cur_warehouse=USACompatible KSGR Soldering Iron Tips: https://usa.banggood.com/Drillpro-10pcs-T12-Soldering-Iron-Tips-Set-for-HAKKO-FX951-FX952-p-1191594.html?rmmds=myorder&cur_warehouse=CNWhite Desk Lamp: https://amzn.to/3dF5g6O Circuit Board Holder: https://amzn.to/2BLzcjG Ryobi 18V Soldering Iron: https://amzn.to/2XGFklQ Ryobi 18V Hot Glue Gun: https://amzn.to/2zeSbCl Heat Gun: https://amzn.to/2Yk7pyy Butt End Connectors with Solder Sleeve: https://amzn.to/2AOFSx2 WAGO Clips: https://amzn.to/3f0h6su Arduino Uno: https://amzn.to/2UmVvTcMicrocenter Arduino: https://www.microcenter.com/product/486544/inland-uno-r3-mainboardWAVGAT Arduino (not recommended): https://www.aliexpress.com/item/4000587244657.html?spm=a2g0o.productlist.0.0.56675cb7UBeuO0&algo_pvid=7a39cf9e-4e18-4824-8e54-0545dc6235db&algo_expid=7a39cf9e-4e18-4824-8e54-0545dc6235db-2&btsid=0ab50f4415916310697714232e56ce&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_Arduino Shield: https://amzn.to/2A7ffU6

AdaBox: Curated Adafruit products, unique collectibles, and exclusive discounts (0:04) https://www.adabox.com/ DIN Rail Mount Bracket for Raspberry Pi / BeagleBone / Arduino (0:34) https://www.adafruit.com/product/4557 DIN Rail Terminal Block Adapter to Grand Central or Arduino Mega (0:34) https://www.adafruit.com/product/4555 DIN Rail Terminal Block Adapter to Metro or Arduino Uno (0:34) https://www.adafruit.com/product/4556 Flirc Aluminum Case for Raspberry Pi 4 (3:13) https://www.adafruit.com/product/4553 Adafruit LPS25 Pressure Sensor - STEMMA QT / Qwiic - LPS25HB (4:46) https://www.adafruit.com/product/4530 Squishy Circuits Standard Kit (5:58) https://www.adafruit.com/product/4550 Adafruit LSM6DSOX + LIS3MDL - Precision 9 DoF IMU - STEMMA QT / Qwiic (7:15) https://www.adafruit.com/product/4517 ----------------------------------------- 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/ -----------------------------------------

AdaBox: Curated Adafruit products, unique collectibles, and exclusive discounts (0:04) https://www.adabox.com/ DIN Rail Mount Bracket for Raspberry Pi / BeagleBone / Arduino (0:34) https://www.adafruit.com/product/4557 DIN Rail Terminal Block Adapter to Grand Central or Arduino Mega (0:34) https://www.adafruit.com/product/4555 DIN Rail Terminal Block Adapter to Metro or Arduino Uno (0:34) https://www.adafruit.com/product/4556 Flirc Aluminum Case for Raspberry Pi 4 (3:13) https://www.adafruit.com/product/4553 Adafruit LPS25 Pressure Sensor - STEMMA QT / Qwiic - LPS25HB (4:46) https://www.adafruit.com/product/4530 Squishy Circuits Standard Kit (5:58) https://www.adafruit.com/product/4550 Adafruit LSM6DSOX + LIS3MDL - Precision 9 DoF IMU - STEMMA QT / Qwiic (7:15) https://www.adafruit.com/product/4517 ----------------------------------------- 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/ -----------------------------------------

El HX711 es un amplificador de célula de carga que te permite medir la fuerza (peso) con un Arduino, un ESP8266 o cualquier otra placa microcontroladora.Recuerdo un alumno del curso de Arduino que desarrolló un sistema de pesado de bombonas de butano.Sabiendo cuánto pesa una bombona vacía, fácilmente se puede controlar el estado de la bombona utilizando células de carga y el amplificador HX711 conectado a un Arduino.Si además lo conectas a un ESP8266, puedes hacer un seguimiento a lo largo del tiempo enviando los datos a alguna plataforma en la nube para el IoT o utilizando Node-RED.Es este tutorial paso a paso te voy a enseñar cómo hackear una báscula y poder medir el peso con un Arduino UNO para mostrarlo por el monitor serie.Pero lo primero es entender qué es una célula de carga.Más información en https://programarfacil.com/blog/arduino-blog/hx711-arduino-bascula-digital/

El ADS1115 es un convertidor analógico digital ADC de 16-bit que puede resultar muy útil para ciertos proyectos con Arduino y ESP8266.Aunque las placas de Arduino suelen tener algún convertidor analógico digital ADC incorporado, el ADS1115 tiene más funcionalidades y más resolución.Por ejemplo, el Arduino UNO incorpora 6 ADC de 10-bit sin embargo el ADS1115 tiene una resolución de 16-bit.Por otro lado, al utilizar un convertidor analógico digital ADC externo, conseguirás liberar al procesador.En el caso del ESP8266, sólo incorpora un convertidor analógico digital de 10-bit que mide en el rango de 0V y 1V. Esto hace que la conversión dependa de las resistencias que se utilicen para hacer el divisor de tensión.Utilizando el ADS1115 ganarás bastante en precisión y calidad de conversión.La comunicación entre el convertidor analógico digital externo ADS1115 y Arduino o ESP8266 es a través de I2C.Todo esto es lo que irás viendo en este tutorial pero antes, déjame que te muestre qué es analógico, digital y el convertidor analógico digital.Más información en https://programarfacil.com/blog/arduino-blog/ads1115-convertidor-analogico-digital-adc-arduino-esp8266/

Anja stürzt sich motiviert in ein neues Thema: Elektrotechnik, Schaltkreise und Programmierung mit einem Arduino Uno. Dafür hat sie sich ein Arduino-Starterkit besorgt und Max um Unterstützung gebeten. Zusammen kämpfen sie sich durch die ersten Kapitel des Projektbuchs und basteln Anjas ersten elektrischen Schaltkreis.

El TPL5110 es un temporizador de bajo consumo basado en controlador MOSFET (transistor). Básicamente lo que hace este dispositivo es, a través del MOSFET, activar o desactivar la alimentación.Se puede decir que es un relé que te permite cortar la alimentación de la batería y activarlo por tiempo. En el TPL5110 se puede configurar un tiempo entre 100 ms a 2 horas.Lo interesante de este dispositivo es que cuando está desactivado sólo consume 35 nA, una corriente muy pequeña. Esto hace que cuando alimentamos un Arduino con baterías, podamos ahorrar mucha energía.Por ejemplo, si tienes una estación meteorológica con un NodeMCU que toma medidas cada hora, en estado de reposo o ahorro de energía puedes llegar a consumir entre 1 mA y 6 mA durante la hora de inactividad. Con este componente reduces este consumo hasta los 0.000035 mA.En este tutorial te mostraré cómo puedes trabajar con el TPL5110 con diferentes placas como Arduino UNO, la gama de Arduino MKR, Adafruit Feather HUZZAH ESP8266, NodeMCU y Wemos D1 Mini.Elige tu placa preferida y prepárate a alargar la vida de tus pilas o baterías con Arduino.Más información en https://programarfacil.com/blog/arduino-blog/tpl5110-bajo-consumo-arduino-esp8266

Las sentencias condicionales if con Arduino son las más utilizadas en programación de proyectos Maker. Sirven para que tu programa haga una cosa u otra dependiendo de cada situación.Imagínate la función loop() de un código de Arduino que se repite indefinidamente dentro de nuestro programa. Es donde realmente suceden las cosas. Se repite muy rápido y la velocidad depende directamente del reloj de la CPU del microcontrolador.Si hablamos de Arduino UNO su velocidad es de 20 MHz es decir, 20.000.000 de instrucciones por segundo. Y en un ESP8266 la velocidad del reloj es 80 MHz (80.000.000 de instrucciones por segundo).Seguramente te estés preguntando, si se repite una y otra vez el mismo código que está dentro de la función loop() ¿por qué obtenemos resultados diferentes?Más información en https://programarfacil.com/blog/arduino-blog/if-else-arduino/

Visit the Adafruit shop online - http://www.adafruit.com ----------------------------------------- LIVE CHAT IS HERE! http://adafru.it/discord https://plus.google.com/+adafruit 1) Add +Adafruit Industries to your circles 2) Post a message/comment HERE and say you want to show off a project and we will add you the “Show and Tell” circle. Then just look for the hangout announcement on the very same page later for your invite. There’s an 8 to 10 (at the same time) people limit per hangout, so if it’s full try later or just pop by next week same time. Some weeks are packed! At 7:30pm ET you will see a link to the hangout. Just keep your mics muted until we call on you and have your project ready. For those who just want to watch, you’ll be able to watch it live on Google+ ‘s broadcast feature on Adafruit’s page AND it will be recorded and uploaded to YouTube automatically. Want to join the #showandtell Here’s how: https://learn.adafruit.com/how-to-get-added-to-the-adafruit-google-plus-show-and-tell-circle/about-show-and-tell Adafruit on Instagram: https://www.instagram.com/adafruit Subscribe to Adafruit on YouTube: http://adafru.it/subscribe Join our weekly Show & Tell on G+ Hangouts On Air: http://adafru.it/showtell New tutorials on the Adafruit Learning System: http://learn.adafruit.com/ ----------------------------------------- #adafruit #arduino #electronics #hardware #opensource #projects #raspberry #computer #raspberrypi #microcontrollers #LEDs #LED #gemma #flora #bluetooth #bluefruit #neopixel #neopixels #wearables #art #askanengineer #showandtell #madewithcode #teamarduinocc #WHChamps #NationOfMakers #micropython #circuitpython ----------------------------------------- Scott @ 0:44 - join us at adafru.it/discord for World Maker Faire; also going to Open Hardware Summit; Game Boy Pocket with sound effects from PICO-8 Celeste cartridge Phil B @ 2:40 - HalloWing Minotaur Maze demo 3D graphics on a microcontroller John Edgar Park @ 5:13 - HalloWing tilt BMP viewer Noe & Pedro @ 7:58 - 3D-printed enclosure for HalloWing that can be worn as a necklace or outfitted with a belt clip Collin @ 10:00 - digital potentiometers synth demo via Feather M0 and MCP41100 digi-pot Mike Barela @ 12:10 - also a HalloWing badge project for Maker Faire and Circuit Playground Express book Jonatan @ 17:28 - Costa Rica Independence Day anthem on Arduino Uno

This week, Avram Piltch gives us a hands-on with the Elegoo EL-KIT-012 Smart Robot Car Kit V 3.0, an Arduino-powered robot kit he purchased on Amazon Prime Day 2018. The kit comes with everything you need to get started: an Arduino UNO, chassis, wheels, ultrasonic distance finder, IR controller and more. One oddity is that the instructions come on a DVD, but thankfully the company also offers them on their website, for those of us without an optical drive. Avram built the robot in a few hours with his son and highly recommends it to anyone interested in experimenting with Arduino.

This week, Avram Piltch gives us a hands-on with the Elegoo EL-KIT-012 Smart Robot Car Kit V 3.0, an Arduino-powered robot kit he purchased on Amazon Prime Day 2018. The kit comes with everything you need to get started: an Arduino UNO, chassis, wheels, ultrasonic distance finder, IR controller and more. One oddity is that the instructions come on a DVD, but thankfully the company also offers them on their website, for those of us without an optical drive. Avram built the robot in a few hours with his son and highly recommends it to anyone interested in experimenting with Arduino.

Comenzamos el nuevo año con el primer capítulo del 2018. Hoy trato de responder las preguntas de los oyentes, ¿por qué Arduino UNO?, por dónde empezar con Arduino y sistema de riego automático con SigFox y LoRa.Han pasado ya unas cuantas semanas desde que publiqué el último capítulo. Este tiempo de reflexión me ha ayudado a ordenar las ideas sobre el blog, el Campus y el podcast.Si sigues la web, te habrás dado cuenta de que la página de inicio ha sufrido modificaciones. De primeras he abierto un curso de Introducción a Arduino gratuito para todo el mundo. Sólo te tienes que inscribir en la lista de distribución y recibirás las indicaciones para inscribirte en el curso.En el Campus he hecho también modificaciones. Ahora tengo un seguimiento de los alumnos y además, los alumnos también tienen un seguimiento de lo que van haciendo. Era necesario este cambio y por fin ya lo tienen a su disposición todos los alumnos :)Respecto al podcast. Ya sabes que mi intención era hacer un podcast semanal. El problema es que para hacer esto necesitaba mucho tiempo debido al extenso artículo que acompañaba a cada capítulo.Mi decisión ha sido hacer cambios en el contenido del podcast. Esto quiere decir que a partir de ahora los capítulos será de diferentes formas:Capítulos, como el de hoy, donde de respuesta a las preguntas de los oyentes.Otros capítulos donde José Manuel, Germán y yo tratemos temas de actualidad como proyectos, noticias y recursos.Las entrevistas no faltarán nunca. Aprendemos mucho de ellas :)Monográficos dedicados a una tecnología, componente, placa o lo que surja.Además de todo esto, estoy abierto a cualquier proposición siempre y cuando no sea indecente ;)Por último el blog. Voy a seguir escribiendo artículos de los que a mi me gustan. Pequeñas guías de Arduino, NodeMCU, ESP8266 y demás tecnologías del movimiento Maker. Pero casi todo orientado a proyectos.Una de las cosas que más me gusta es hacer proyectos. Este tipo de artículos lleva su tiempo sobre todo por la documentación. Iré publicando poco a poco diferentes proyectos y para ello he hecho una lista de los que más me interesan:Mejorar la estación meteorológica que mide radiación UV con Arduino MKRFOX1200.Sistema de monitorización y riego de plantas.Sistema de monitorización de un acuario incluído un medidor de PH.Posicionamiento de GPS preciso con Arduino MKRFOX1200 y un panel solar.Pulsómetro con Arduino.Medidor de consumo de componentes eléctricos.Estos son los proyectos que había pensado pero estoy abierto a cualquier otro que me recomiendes y que vea interesante.Dicho todo esto, vamos a empezar con el programa de Preguntas de los Oyentes.Más información en https://programarfacil.com/podcast/empezar-con-arduino-uno/

I Expect You To be Bored Mr. BondEpisode 100 is coming up! It’ll be a Q&A session - so send in your questions to podcast@macrofab.com 2nd Annual Star Wars Xmas Special Engineering Podcast. Check out the video from last year! Parker Built a mounting surface for the Jeep Electronics Stephen Failure of the Science Museum Project Was expecting soft foam at the bottom of the "well" to move the cones of the drill bit Hard plastic was installed instead Coupling bent up that connects the rotational shaft to the large nema 34 stepper Safety first, equal amounts of time spent on safety as engineering the rest of the project Pick Of the Week (POW) How to reduce Arduino Uno power usage by 95% - Deferred Procrastination Replace the linear regulator with a DC-DC converter Adjust the USB-to-Serial circuit so it’s only powered from the USB port Cut out (or desolder) the always-on LED’s on the board Use the processor sleep mode. Before: 53mA After: 2.5mA DC -DC convertor used was a Traco TSRN-1 for $6.07 Rapid Fire Opinion (RFO) Internet of Toilet Paper Holder - HackADay Revolutionized entire toilet paper supply management life cycle Tracks usage statistics - Manage wiping data and share on social media Instructables to make your own! Man is about to launch himself in his homemade rocket to prove the Earth is flat - The Washington Post Self-taught rocket builder Mike Hughes - 61 yr old limo driver Holds record for biggest limo jump Plans to launch himself 1,800 feet high U.S. Bureau of Land Management (BLM) "told me they would not allow me to do the event ... at least not at that location," Will have to reschedule the launch Not atmosphere its atmosflat $20,000 rocket had a fancy coat of Rust-Oleum paint and “RESEARCH FLAT EARTH” inscribed on the side Visit our Slack Channel and join the conversation in between episodes!Tags: Arduino, electronics podcast, Houston Museum of Natural Science, IoT Toilet Paper, Jeep, Low Power, MacroFab, macrofab engineering podcast, Man, MEP, Podcast, Rocket

Im aktuellen c't uplink vergucken wir uns zuerst alle in den kleinen Roboter Anki Cozmo, den Sven Hansen mitgebracht hat. Wie mit dem ebenfalls auf dem Tisch herumfahrenden Lego Boost sollen Kinder damit spielerisch die Grundzüge des Programmierens lernen. Um uns aber nicht zu sehr abzulenken, musste der Cozmo die Sendung aber trotzdem schlafend beenden. Dorothee Wiegand erklärt danach, wie die derzeit wahlkämpfenden Parteien IT bei ihrer Werbung um Stimmen einsetzen. Zwar legt der Datenschutz ihnen Zügel an, aber wir werden trotzdem ganz gut durchleuchtet. Das liegt auch an den Demoskopen, die dank ausgefeilter Methoden immer noch sehr genaue Prognosen produzieren. Schließlich stellt Nico Jurran noch die verschiedenen Standards vor, die den Einzug kontrastreicher HDR-Bilder ins Fernsehen begleiten. Zwar klingen deren Namen teilweise sehr ähnlich, ein Chaos erwartet er aber nicht. Zum Schluss gibt es noch eine Verlosung mehrere Produkte aus dem heise Shop: Wer uns an uplink@ct.de, in den Kommentaren auf Youtube oder bei ct.de die Wahlprognose schickt, die dem amtlichen Endergebnis der Bundestagswahl am nächsten kommt, gewinnt einen Pi Desktop. Für die nächstbesten fünf gibt's jeweils die zwei Ausgaben der Make Arduino inklusive eines Arduino Uno. Bitte dafür die eigene Prognose im Format Union;XX,X;SPD;XX,X;Linke;XX,X;Grüne;XX,X;FDP;XX,X;AfD;XX,X;Sonstige;XX,X schicken. Mit dabei: Dorothee Wiegand, Martin Holland, Nico Jurran und Sven Hansen Die c't 19/17 gibt's am Kiosk, im heise Shop und in der c't-App für iOS und Android. Alle früheren Episoden unseres Podcasts gibt es unter www.ct.de/uplink.

Im aktuellen c't uplink vergucken wir uns zuerst alle in den kleinen Roboter Anki Cozmo, den Sven Hansen mitgebracht hat. Wie mit dem ebenfalls auf dem Tisch herumfahrenden Lego Boost sollen Kinder damit spielerisch die Grundzüge des Programmierens lernen. Um uns aber nicht zu sehr abzulenken, musste der Cozmo die Sendung aber trotzdem schlafend beenden. Dorothee Wiegand erklärt danach, wie die derzeit wahlkämpfenden Parteien IT bei ihrer Werbung um Stimmen einsetzen. Zwar legt der Datenschutz ihnen Zügel an, aber wir werden trotzdem ganz gut durchleuchtet. Das liegt auch an den Demoskopen, die dank ausgefeilter Methoden immer noch sehr genaue Prognosen produzieren. Schließlich stellt Nico Jurran noch die verschiedenen Standards vor, die den Einzug kontrastreicher HDR-Bilder ins Fernsehen begleiten. Zwar klingen deren Namen teilweise sehr ähnlich, ein Chaos erwartet er aber nicht. Zum Schluss gibt es noch eine Verlosung mehrere Produkte aus dem heise Shop: Wer uns an uplink@ct.de, in den Kommentaren auf Youtube oder bei ct.de die Wahlprognose schickt, die dem amtlichen Endergebnis der Bundestagswahl am nächsten kommt, gewinnt einen Pi Desktop. Für die nächstbesten fünf gibt's jeweils die zwei Ausgaben der Make Arduino inklusive eines Arduino Uno. Bitte dafür die eigene Prognose im Format Union;XX,X;SPD;XX,X;Linke;XX,X;Grüne;XX,X;FDP;XX,X;AfD;XX,X;Sonstige;XX,X schicken. Mit dabei: Dorothee Wiegand, Martin Holland, Nico Jurran und Sven Hansen Die c't 19/17 gibt's am Kiosk, im heise Shop und in der c't-App für iOS und Android. Alle früheren Episoden unseres Podcasts gibt es unter www.ct.de/uplink.

Im aktuellen c't uplink vergucken wir uns zuerst alle in den kleinen Roboter Anki Cozmo, den Sven Hansen mitgebracht hat. Wie mit dem ebenfalls auf dem Tisch herumfahrenden Lego Boost sollen Kinder damit spielerisch die Grundzüge des Programmierens lernen. Um uns aber nicht zu sehr abzulenken, musste der Cozmo die Sendung aber trotzdem schlafend beenden. Dorothee Wiegand erklärt danach, wie die derzeit wahlkämpfenden Parteien IT bei ihrer Werbung um Stimmen einsetzen. Zwar legt der Datenschutz ihnen Zügel an, aber wir werden trotzdem ganz gut durchleuchtet. Das liegt auch an den Demoskopen, die dank ausgefeilter Methoden immer noch sehr genaue Prognosen produzieren. Schließlich stellt Nico Jurran noch die verschiedenen Standards vor, die den Einzug kontrastreicher HDR-Bilder ins Fernsehen begleiten. Zwar klingen deren Namen teilweise sehr ähnlich, ein Chaos erwartet er aber nicht. Zum Schluss gibt es noch eine Verlosung mehrere Produkte aus dem heise Shop: Wer uns an uplink@ct.de, in den Kommentaren auf Youtube oder bei ct.de die Wahlprognose schickt, die dem amtlichen Endergebnis der Bundestagswahl am nächsten kommt, gewinnt einen Pi Desktop. Für die nächstbesten fünf gibt's jeweils die zwei Ausgaben der Make Arduino inklusive eines Arduino Uno. Bitte dafür die eigene Prognose im Format Union;XX,X;SPD;XX,X;Linke;XX,X;Grüne;XX,X;FDP;XX,X;AfD;XX,X;Sonstige;XX,X schicken. Mit dabei: Dorothee Wiegand, Martin Holland, Nico Jurran und Sven Hansen Die c't 19/17 gibt's am Kiosk, im heise Shop und in der c't-App für iOS und Android. Alle früheren Episoden unseres Podcasts gibt es unter www.ct.de/uplink.

• Finalist, BT Young Pioneers Award 2016 • Winner, Tech4Good People’s Award 2016 • Winner, Tech4Good Winner of Winners Award 2016 Aged just nine years old, Arnav Sharma studied the cause, diagnosis and effect of asthma and came up with a solution; the AsthmaPi kit. Using a Raspberry Pi hooked up to a range of sensors it helps anyone living with asthma and is particularly useful to anyone not sure about the diagnosis of asthma. Using email and SMS text message alerts, patients receive prompts to take medication and reminders for review visits, and the accompanying booklet makes it easy to understand asthma. Arnav started with two Raspberry Pis and added a Sense Hat, MQ-135 Gas Sensor, Sharp Optical Dust Sensor and an Arduino Uno – which he programmed using Python and C++. https://www.tech4goodawards.com/finalist/arnav-sharma/ (https://www.tech4goodawards.com/finalist/arnav-sharma/) https://www.educationonfire.com (https://www.educationonfire.com) http://khanacademy.org (http://khanacademy.org) (http://raspberrypi.org) Support this podcast

There are a couple good use-case scenarios for making a secret knock detector using an Arduino. You are a spy who needs to authenticate your cohorts You are a super hero who wants a secret knock to open the entrance to your lair Whatever the reason - by the end of this tutorial you will know how to use an Arduino, a piezo transducer and a couple other cheap components to make secret knock detector. Here is an overview of exactly what we will talk about in this lesson: The components you will need and how to set up this simple circuit. The concept of operation of this secret knock detector A thorough description of each block of code in the Arduino sketch Why North American grizzly bears love piezo transducers For this secret knock detector circuit you need: Arduino (I use the Arduino Uno) [1] Solderless breadboard [1] 1 Mohm Resistor [1] Piezo transducer (aka buzzer) [1] Jumper wires [4] 5.1V Zener diode (for extra protection) [1] No spill stopper for a “to-go” coffee cup How to set up the Circuit: This is a really simple circuit to setup, below are step-by-step instructions and a breadboard diagram. Place the piezo transducer on the breadboard, with the positive lead and the negative lead on separate rails. Connect the positive lead to pin A0 on the Arduino and the other lead to ground. Finally, use the 1Mohm resistor to connect the leads of the piezo transducer. As an additional level of protection, you might consider adding a 5.1V zener diode between the leads to protect against high voltage spikes from frying your input pin - you might call it a cheap insurance policy. An Overview of this Secret Knock Detectors operation Here is the basic concept of how this will work. We want something to happen when you tap out a secret code. We will create a sequence of soft and hard taps - this will be our secret code which will be represented as 0’s and 1’s in an array. For example: secretKnock[secretKnockLength] = {0, 0, 1, 0}; The code above represents a secret code of soft , soft , hard, soft . The piezo transducer will turn the mechanical pressure created by the tap into a signal that the Arduino analog pin can read. The level of the signal will determine whether a tap gets characterized as soft or hard. The threshold of a soft vs hard tap need to be determined empirically, once you have the circuit built - it will depend on what you have the piezo transducer attached to - I have mine taped to a piece of paper. You should start with the default threshold values provided in the sketch and change them to suit your specific setup. Once a tap signal is picked up by the Arduino, the sketch will compare the entered sequence of taps to the secret code, one tap at a time. If the code is entered correctly, then we will trigger an action on the output pin. In this code below, we trigger an LED to turn on for a couple seconds - but you could trigger a servo arm, a pump, or whatever you might need. If the code is entered incorrectly - nothing happens. Here is the code for your hacking enjoyment: /* A simple sketch to detect a secret knock using a piezo transducer Created JUL 2015 by Michael James http://www.programmingelectronics.com/ This code is in the public domain */ const int outputPin = 6; // led indicator connected to digital pin const int knockSensor = A0; // the piezo is connected to an analog pin const int thresholdHIGH = 150; // threshold value to decide when the detected knock is hard (HIGH) const int thresholdLOW = 120; // threshold value to decide when the detected knock is gentle (LOW) const int secretKnockLength = 4; //How many knocks are in your secret knock /* This is the secret knock sequence * 0 represents a LOW or quiet knock * 1 represents a HIGH or loud knock * The sequence can be as long as you like, but longer codes increase the difficulty of matching */ const int secretKnock[secretKnockLength] = {0, 0, 1, 0}; int secretCounter = 0; //this tracks the correct knocks and allows you to move through the sequence int sensorReading = 0; // variable to store the value read from the sensor pin void setup() { //Set the output pin as an OUTPUT pinMode(outputPin, OUTPUT); //Begin Serial Communication. Serial.begin(9600); } void loop() { // read the piezo sensor and store the value in the variable sensorReading: sensorReading = analogRead(knockSensor); // First determine is knock if Hard (HIGH) or Gentle (LOW) //Hard knock (HIGH) is detected if (sensorReading >= thresholdHIGH) { //Check to see if a Hard Knock matches the Secret Knock in the correct sequence. if (secretKnock[secretCounter] == 1) { //The Knock was correct, iterate the counter. secretCounter++; Serial.println("Correct"); } else { //The Knock was incorrect, reset the counter secretCounter = 0; Serial.println("Fail - You are a spy!"); }//close if //Allow some time to pass before sampling again to ensure a clear signal. delay(100); //Gentle knock (LOW) is detected } else if (sensorReading >= thresholdLOW) { //Check to see if a Gentle Knock matches the Secret Knock in the correct sequence. if (secretKnock[secretCounter] == 0) { //The Knock was correct, iterate the counter. secretCounter++; Serial.println("Correct"); } else { //The Knock was incorrect, reset the counter. secretCounter = 0; Serial.println("Fail - You are a spy!"); }//close if //Allow some time to pass before sampling again to ensure a clear signal. delay(100); }//close if else //Check for successful entry of the code, by seeing if the entire array has been walked through. if (secretCounter == (secretKnockLength) ) { Serial.println("Welcome in fellow Illuminante!"); //if the sececret knock is correct, illuminate the LED for a couple seconds digitalWrite(outputPin, HIGH); delay(2000); digitalWrite(outputPin, LOW); //Reset the secret counter to 0. secretCounter = 0; }//close success check }//close loop If you enjoyed this lesson, you should join our free Arduino Crash Course - it has 19 Video Training lessons all about using Arduino (you can sign up below).

This week Michael sits down with Ray from Electrosmash to talk about his invention ‘The pedalSHIELD UNO’, a programmable guitar pedal that works with the Arduino UNO. The two discuss how Ray was able to blend his love of programming and music (2:15), how Electrosmash users can program unique guitar tones using their open source hardware (5:35), and how he’s striving to make his products accessible for users of all experience levels (13:00).

Discussion: This lesson continues our quest of learning more about programming and electronics.  In previous lessons, we already discussed several reasons why we have chosen to use an Arduino board as the tool to help us learn. Specifically, we chose the Arduino Uno board.  The Uno is the baseline Arduino board, being the one around which other Arduino boards are designed . Therefore, the Uno is a great place for us to start digging in.  It’s also a fantastic launchpad if you decide to move on to other platforms in the future. In this lesson, we'll do a high-level overview of the Arduino Uno hardware.  Specifically, we’ll cover: The Concept of an Arduino Board The Three Types of Pin Header Rows: Digital, Analog, and Power Other Miscellaneous Valuable Tidbits The Concept of an Arduino Board As we discuss the hardware, I recommend holding your Arduino board in your hand.  Pause the video as needed to take a closer look at the board as we discuss the different components. First, I want to point out that the integrated circuit is the brains behind the Arduino board.  It’s very likely that the circuit is the Atmel ATmega 328, which is an 8-bit microcontroller. Don't worry about that fancy name.  The only thing I want you to understand is that everything on the Arduino board is meant to support that integrated circuit.  So, the Arduino exists to make it easy to use this microcontroller. If you look closely at the microcontroller, it may look slightly different from mine, depending on which model you have.  It might be really small, called a surface mount component, or it could be a big one like mine, which is called a DIP. Either way, there will be little metal prongs that stick out of the side.  These are called pins. These pins are how the microcontroller is able to do stuff.  These are used to interface with other hardware and circuitry, such as LEDs, sensors, or even your computer. Therefore, we need to know how to actually connect them to other things.  That's where the pin headers come into play. Pin headers, sometimes referred to as just headers, are the plastic rows of holes that stick up from the Arduino board.  They are all along the border. Inside of the holes are little metal clips.  When you stick a wire down into the hole, that wire will stick and stay there. For example, you can stick the wire that comes out of an LED or a resistor into those holes.  The wires are called leads, by the way.  The wire makes an electrical contact in that hole. In other words, the wire sticks in the pin header.  The metal clamp inside the header clamps onto the wire, and an electrical connection between that wire and a specific pin on the microcontroller is then created. Digital Pin Headers There are three categories of headers: digital, power, and analog.  The first one we’ll discuss is the digital category. Digital pin headers make up the longest row on the Arduino board. They are numbered from zero to 13.  That means there are a total of 14 digital pins that we can use. To make this lesson as practical and easy as possible, for our purposes when I say digital, I mean something that is a discrete state. Let's use color as an analogy.  Something that is digital can only be either black or white.  Digital does not care about any point of gray in-between. Therefore, digital pins are used in one of two ways.  They can be used as inputs to do things like read a voltage.  Otherwise, they are used as outputs, such as applying a voltage. When they operate as an input, they can only read two different voltage states - high or low.  The same is true when they act as outputs.  They can only output two voltage states - five volts (high) or zero volts (low). Just as in anything else in life, there is an exception to this.  You'll notice that some of these pins have a little squiggly mark next to them. There should be six of them, located at pins three, five, six, nine, 10, and 11.  These specific pins allow you to use a technique called pulse width modulation, or PWM. PWM is a technique that we'll dive into later in the course.  It enables us to use digital pins in such a way that they appear as though they are outputting a varying amount of voltage. Again, we'll get into PWM in much greater depth later.  Right now I just want to point out those pins, and why they are special. I also want to point out two other pins.  Notice that pins zero and one have a “TX” and “RX” next to them with little arrows.  That stands for transmit and receive. The Arduino uses these two pins to communicate between the board and the computer.  For example, maybe you need to upload your code. Maybe executing your sketch performs serial communication between the Arduino and the computer.  Serial communication is another concept we'll be learning later in the course. It’s only important that you understand these pins used to transmit and receive.  Therefore, it’s best to only use pins zero and one as a last resort if you’ve run out of available pins. The reason for this is that sometimes adding additional circuitry to these pins can interfere with serial communication.  This will make a lot more sense when we get to that section of the course.  For now, just know it’s a good rule of thumb to leave pins one and zero alone. There are also two on-board LEDs labeled “TX” and “RX”.  These blink every time you send information back and forth between the Arduino Uno and the computer. If you have the Arduino hooked up, and it’s supposed to be communicating with the computer, you should see these blinking.  If not, it’s a good indication that you probably don't have the Arduino set up correctly in the IDE, and communication is unsuccessful. Lastly, pin 13 is also worth noting. That is where an on-board LED is attached.  You can use that LED as though it were externally connected through a resistor to the Arduino. Analog Pin Headers The next category of headers are analog pin headers.  These are labeled A0 through A5, giving us six analog pins. As you might have guessed, “A” stands for analog. Before we said that digital means discrete states - either high or low, one or zero, black or white.  However, analog is a lot more colorful. When we say something is analog, it means that it can be in any number of states.  Analog embraces all of the various shades of gray between black and white. Many sensors create analog signals.  They're not just on or off.  They can be all of the states in-between. However, our integrated circuit really only knows discrete digital states.  Therefore, the microcontroller handles analog inputs by using a tool called an analog-to-digital converter, or simply an ADC. The ADC is part of the integrated circuit, built right into the chip.  The analog pins have access to it. The ADC takes all of the variation in an analog signal and cuts it up into discrete steps.  In other words, instead of having an endless list of possibilities from your low to high limit, the ADC would cut that expanse from the low value to the high into a certain number of “chunks”. In addition to being able to use the ADC, analog pins can also act just like digital inputs or outputs.  So, they are very versatile.  We’ll do a deeper dive on this later in the course, as well. Power Headers The last row of pin headers is the power header row.  They are next to the analog headers. There are only a handful of pins I want to point out right now.  The first one is labeled “5V”. That stands for five volts.  If you have the Arduino hooked up to the computer via USB, or if you have external battery power applied, this pin can provide five volts to a circuit.  We'll be using this pin extensively throughout the course when we're setting up our circuits. The pin next to it is labeled “3.3V”, which stands for 3.3 volts. Obviously, it provides 3.3 volts to the circuit. Next to these pins are two pins labeled “GND”, which stands for ground. These two pins give us access to the lowest voltage on the Arduino board, which is zero volts. Miscellaneous Goodies to Know There is yet another ground pin located up next to the digital header row. It’s important to keep in mind that all of these ground pins are one in the same.  They are all connected to each other.  Therefore, throughout the course when we set up our circuits, it doesn't matter which one you decide to use. Let me make one final note about the pin headers.  You may hear a term thrown around called the “Arduino Footprint”.  That’s simply how the Arduino headers are aligned. If something is said to match the "Arduino Footprint", it means that it has that same header layout as the Arduino board.  The most common example of this would be an Arduino shield because, by default, the headers on a shield are almost always going to match the board. That term is not really all that important to know, but I wanted to make sure you had heard the term if you ran into it. Another item that is helpful is the reset button. Just as the name implies, when you press that button, the program currently running on your Arduino board will start back at the beginning.  It doesn't erase the program.  It just starts the program over. There is also a reset pin on the Arduino. If you apply a low voltage to that pin, it does the same thing as the reset button.  It will reset the current program running on the Arduino. Next, the Arduino Uno has a power on LED. It is illuminated anytime power is being applied to the Arduino.  This is true no matter if the Arduino is powered through a USB cable or through an external power jack. Review Wow! Lots of components! How about we go back over the highlights? We talked about kind of the overall concept of the Arduino board.  It is built to support the integrated circuit. We also discussed the three different pin header rows.  We went into detail about the digital, analog, and power headers. Finally, we covered a few miscellaneous components.  The Arduino Uno has a reset button, a reset pin, and a power on LED. Hey, don’t worry if you still have a lot of questions!  That's to be expected this early in the course.  A lot of terminology and some new concepts were thrown around. Remember, though, this was only meant to be an overview of the Arduino hardware.  As we move further into the course and delve deeper into the specifics of these concepts, it will all begin to come together.  Patience, young grasshopper.

Discussion: Now that you have downloaded and set preferences, you need to become familiar with the Arduino Integrated Development Environment, or IDE for short.  It works just like a text editor program. I'm only going to cover what I think is important for us to know right now.  We do a deeper dive on an as needed basis as we progress through the course.  Specifically, in this lesson we'll cover: Selecting an Arduino Board and Serial Port Saving an Arduino File The Editor, Message Area, and Console A Few Other “Good to Know” Items So let's open the Arduino Integrated Development Environment (IDE) and get started.  Do this by clicking the Arduino icon. Which Board and Serial Port Should I Use? The first thing we're going to discuss is selecting the correct board.  We have to let the Integrated Development Environment know what Arduino board you're using. Go to the “Tools” tab, and then go down to where it says “Board”.  You'll notice I selected the Arduino Uno since that is what I will use throughout the course. I recommend that you use an Uno or an Uno derivative throughout the course, as well.  This will standardize our work in these lessons. Once you've selected the board, next you need to select your serial port.  People can sometimes be intimidated by this technical term, but you don’t have to be. Serial ports are just the different things connected to your computer.  The easiest way to find out which of the ports listed is your Arduino is to first unplug the Arduino from the computer. Go to the ports list under the “Tools” tab, and write down the names of these ports. You only need to write enough to differentiate one from the next - maybe the last word or last few letters. Then, close your Arduino IDE.  Plug your Arduino board back in via the USB cable to your computer.  Open the Arduino IDE. You should now be able to see an additional serial port not on the list you originally wrote down.  That will be the serial port to which your Arduino is connected. For Mac, you'll usually see cu or tty after the “dev/”.  Those are the common ways Arduino will show up on the serial port for a Mac. For a PC, it shows up as a COM port, but it's hard to know which one it will be.  It could be one, two, four, etc. That’s why the best method, although primitive, is just to unplug and plug the Arduino back into that port. Once you’ve chosen the board and port the first time, these settings will stay the same for any subsequent times you reopen the Arduino IDE. The reason I point this out is that if you happen to get a different board at some point, you will have to remember to change the board that is selected. The Arduino File When you open the Arduino IDE for the first time, it will open up a file for you, giving it a default name.  That default is sketch, underscore, and the current date. That name also appears at the top of the IDE, along with the version of Arduino you're using. To save this, go to the “File” tab and then to “Save”.  It's just like saving any other file.  Notice it asks you to save the file in “Documents”. Remember that in Arduino, files are referred to as sketches.  So, the collection of our sketches is known as the sketchbook.  The sketchbook folder is where all of the sketches we write will be saved. Of course, you can also nest your files in that folder just like you could in any other program where you're saving files.  It's really no different. Take a look at the name I chose for my file.  There are certain rules you must follow when choosing a name for your sketch. When you're naming a file, you can't use any spaces between the words.  One common method is to use an underscore where you would have normally preferred a space. You can't use special characters, either.  You can use numbers in the name, but you can't have a number as the first character.  Lastly, the names are limited to 64 characters. So, using these rules, name your sketch and save it. You'll see that the name on the tab and at the top of the screen now displays the name of your newly saved sketch. So, saving is really easy.  The shortcut command is Ctrl S.  There is also a down arrow that you can click. The Editor, Message Area, and Console There are three main areas of the Integrated Development Environment:  the editor, the message bar, and the console. The editor is the big white space.  It’s where you type the Arduino code. It has number lines down the side - as long as that was one of the preferences you checked from our last lesson on choosing your settings. Right now it shows one through nine.  If we were to add more code or move our cursor down further, it would adds numbers as lines are added. I want to point out one thing in this name here.  Do you see the little funky looking “s”? Every time you make a change to the sketch that has not been saved, that s will be displayed.  If I save the file, it goes away. If I were to type something in the sketch again, the funky little s would come back.  It’s just a visual reminder to save your changes. Personally, I am a save fanatic.  For just about every single line of code I write, I use the shortcut key Control S to save before I go on to the next line. I want to make sure I don't lose anything in the event that I have an issue with either the Arduino IDE, my computer, unexpected interruptions, or whatever might happen. There is something interesting you might have noticed when you open a new sketch in Arduino.  It auto-populates two of the mandatory functions for coding in Arduino. This is why you see void setup an void loop.  We'll talk about these in depth later, but it's perfectly normal for these to show up.  It’s just a way of helping you save time when you code. On top of the editor area are two very important buttons. The first one is a check mark.  It is the Verify button.  When you click this, the code gets compiled. Compiling, as discussed before, is taking the human readable code that we've written and translating it into machine code.  As it compiles, the program will point out any errors found in that code. It also does some optimization.  This is a way behind the scenes concept that you don't have to worry about right now, though. You constantly want to check for errors in your code.  I like to verify my code at almost every line of code I write along the way. The more you verify, the more quickly you can identify where you might have introduced an error into the code, i.e. find and fix a bug.  We'll be using this verify button all the time. The shortcut key for verify is Command R or Control R.  You can also verify by going to the “Sketch” tab. That other button is the Upload button.  That takes all of the code that we've written and uploads it to the Arduino board. When you click that button and look at your Arduino board (assuming that it’s hooked up to your computer via the USB cable), you'll see two lights blinking rapidly.  That is the TX and RX buttons. This is a good visual indicator that you have a good connection between the Arduino board and the computer.  The IDE is recognizing that you have a board hooked up.  In other words, the lights tell you that the code is successfully being uploaded to the board. The shortcut key to upload is Control U or Command U.  It is available in the dropdown under the “Sketch” tab, as well. The second main area of the IDE is this blue bar.  It is the message bar. It will display information about what you've done recently in the program.  For example, I just uploaded.  You can see that it says, “Done Uploading.” If I press Control S to save, it would say, “Done Saving.”  There are other pertinent messages that display while you are using the program. The third main area of the IDE is the black space below the message bar.  It is called the Console. Now, you probably won't hear it referred to as the console very often.  Many people just call it the error section, or some other generic term. If you want to increase the console’s space, there is a bar you can drag up.  It may be hard to see, so I put a box around it. The console displays the error messages.  It will tell you information about the current operation that you did. For illustration purposes, let me introduce an error into the code and verify it.  I’ll just type a crude, uncoded line somewhere in the editor area. You can see that we get definitely get a reaction out of the Arduino IDE.  First, the message bar gives us a quick note saying that you wasn’t declared. Again, don't worry about understanding the error itself or any of the terminology displayed.  I just want you to see where different types of information shows up. Then, in the console much more detailed information about the error is displayed.  It tells you what file it was in, what function it was in, and even the line of code.  Here it says the error was in line three. If we look back up at line three in the editor, we can see that it gets highlighted.  That's where we can start looking for our error. Unfortunately, it will not always point out the correct line of code for the error.  You might have to do a little searching around, but that is a discussion for another time and another lesson. You now know the three big pieces of the Arduino IDE.  We walked through the editor, the message bar, and the console. Miscellaneous Tidbits There are a few final items we should discuss that are good to know.  At the very bottom of the IDE is a number.  Currently ours shows the number three. That simply refers to the line of code where your cursor is located.  It seems like such a small detail, but it is very handy. Once you begin to work with larger and larger sketches, it may be harder to keep track of your cursor.  This is especially true if you decide not to display line numbers down the side. Also, in the far right corner you'll see some additional information. It is the name of the Arduino board and which serial port that you identified earlier that you’re using. In the top right, there is a little magnifying glass.  This is for the Serial Monitor. If you click it, a window like this opens: The Serial Monitor window allows us to see communication occurring between the Arduino and the computer, and vice versa.  We'll have an entire lesson later down the road about the Serial Monitor and communications. For now, just know that the button is there.  The shortcut key for the Serial Monitor is Shift-Control(or Command)-M. Now Get Going! You now know enough information to start using the Arduino IDE.  You can see it's not too complex.  The IDE is very simple and streamlined. Arduino was designed for ease of use.  There's not a bunch of bells and whistles that can sometimes get in your way.  I have no doubt you’ll be an Arduino pro in no time.

Discussion: In this video, I’ll explain what parts you'll need to complete this Arduino Crash Course. Immediately below this discussion section, there is a summary checklist of links for these parts. You're welcome to check it out! The links take you to Jameco, a United States based electronics supplier. I'm actually one of their affiliates. So, if you decide to click any of those links below, you’ll be helping to make me a multi-millionaire and continue to buy fuel for my yacht. So that would be awesome. All joking aside, you might already have a lot of this stuff laying around. It just depends on how much you've been into electronics thus far. The first thing you'll need is an Arduino UNO. As you may or may not know, Arduino has all types of derivatives out there. An Arduino UNO There is a company named Arduino that made the board. That is the official Arduino, but Arduino is open-source hardware. In other words, the Arduino company made the board’s schematics and everything publicly available. Therefore, anybody can take access that information and replicate the board. Anyone can duplicate it, modify it, and even legally sell it. That’s why there are so many derivatives, or clones, out there of an Arduino UNO board. They are basically the exact same thing as your official Arduino UNO. Sometimes you’ll find that maybe one or two customizations have been made. My recommendation to you is to get an authentic, official Arduino UNO from the Arduino company while working through this course. The reason is because that prevents any discrepancies and concerns about hardware when following the tutorials. If you're following everything in the lesson, and something is amiss, then you can at least know it's not the hardware. You’ll know that you have the same hardware with which I’m working. Again... that’s just my recommendation. Now, if you already have an Arduino clone or derivative, feel free to use it. It will probably work just fine. The next thing you'll need is a USB cable to plug your Arduino into your computer. Basic procedure is to write code on the computer and then transfer that code, uploading it to the Arduino board. An AB USB cord The USB we’ll be using in this course is an A-B type. One end looks like your typical USB that just plugs into a computer, and the other end is almost square - or maybe more like a little house, depending on your imagination. This other end is what would typically go into the back of a printer. You will also need light-emitting diodes, or LEDs. An LED It’s best to get at least 10 of the five millimeter type. Any color of mix of colors is fine. I usually use red or white. Next on the list are resistors. Resistors Resistors, as the name suggests, resist the flow of current in a circuit. The bigger the number of the resistor, the more current they resist. When it resists current, the resistor takes that electrical energy and transforms it into heat energy. Therefore, it’s important to note resistors can get hot. Just file that away as a quick mental note for later down the line when we begin setting up circuits. You may not notice it that much for the lower level things we will be doing. However, I wanted to make you aware just in case. This is the list of required resistors: ten 220 Ohm resistors and two 10,000 Ohm resistors (also referred to as 10 K resistors). You’ll also need a potentiometer. Potentiometers It really doesn't matter what size you get. I’ll be using a 10 K potentiometer for this course. If you have one around, you can just use that. A potentiometer is similar to a resistor, but it's resistance can vary. That allows you to create something called a voltage divider. We won't get into that now. Just know that you need a potentiometer of any size. Next, you'll use a solderless breadboard. No, we won’t be cutting bread - although food does sound really good right now…. But I digress, a solderless breadboard is a circuit board where you can connect electrical components together without having to solder them. It has a bunch of little holes in it, and in the holes are all these little copper clips. A solderless breadboard The holes are aligned in a bunch of rows and columns. The columns are electrically connected, but the rows are not. So, you stick the leads of your electrical components, such as an LED, into the holes for the metal clips. This will complete the circuit, connecting the electronics. This is an example of how you'll use the breadboard. Don’t worry, it’s a lot easier than it sounds. For prototyping, like we'll be doing, it's a great tool since it permits quick and easy setup and changes to your circuit. The next required items are jumper wires. Jumper wires These fit down into the little holes on a breadboard and into the little holes on the Arduino board. (We'll be talking about the Arduino board more later, but those are called the headers.) Anyway, the jumper wires allow you to extend your electrical connections, giving you some extra space with which to work. You'll need 12. Two momentary push-buttons are also on the course list. A push button This button is normally off. That means if you're not pressing the button, no electrical connection is made between either side of the button. The button is off until you push it. When you’re holding the button down, though, an electrical connection is made. Once you remove your finger, the button pops back out again, breaking the electrical connection. They come in all different styles. However, if you follow the links below, you'll get an idea for what to look. Finally, you'll need some alligator clips. Alligator clips These help you connect leads together if, for some reason, we need to connect them in a way a little different than using the holes on the solderless breadboard. It may seems like quite a bit of equipment, but it’s really not that bad. I kept convenience in mind when creating this list. All of these items are relatively cheap. There are a couple of other things you'll need, though. I assume that you already have a computer running Windows, Mac, some type of Mac software, or Linux. Of course, an internet connection is also required because you'll have to download the Arduino software. I’ll explain the Arduino software in a later lesson. There are few things that are optional. These are not covered in this crash course, but they would be fun to have in order to experiment with your code. This is the optional equipment. You could get a photoresistor, a temperature sensor, maybe some additional potentiometers, and an RGB LED. RGB means red, green, blue LED. It's kind of an all in one, and they are pretty neat use. I believe that's it for the required and optional equipment. Again, the parts list is below. I’m looking forward to jumping into the course with you. See you in the next video! Hardware List for the Arduino Crash Course Below is the list of items you will need to get you through the course. The quantities of each provide a little leeway in case your cat eats an LED or you loose a resistor in your shag carpet. I have made every effort to keep this list minimal to provide the lowest cost to entry. NOTE: The links below take you to Jameco, of whom I am an affiliate. The cost to you is the same, but I get a small commission for purchases that helps me keep the site running and allows me to buy giant yachts. I use Jameco for a bunch of stuff - I like and trust them. I also use Digikey, Mouser, Adafruit, Makershed and Sparkfun. Required: Arduino Compatible Board USB Cable to plug in Arduino (A/B type - one end is typical USB, the other is what would go into a printer) LEDs AKA Light Emitting Diodes (10) 10K potentiometer (1) 220 Ohm Resistor (10) 10K Ohm Resistor (2) Jumper Wires (12) Solderless Breadboard (1) Pushbutton (2) Alligator Clips (3) Another option is to buy our Kit-on-a-Shield for Arduino:   Click here to learn more.   You'll need this stuff too: Now there are certain things I am assuming you have access to that you will also need, these include the below items. A computer running Windows, Mac OS, or Linux An internet connection to download the Arduino Software Optional stuff: While the list above will meet all your needs, sometimes having a little extra stuff to play with makes for a more fun and diverse learning experience. Below are items you can easily experiment with alongside this course: Photo Resistor Additional potentiometers RGB LEDs - red, green and blue all in one LED matrix Temperature sensors Arduino Kit just for this course from Jameco: I have had the pleasure of working with Jameco to create a kit that provides all the needed items for the Arduino Crash Course. You can check it out here.

Desde que irrumpió el ESP8266 en el mercado, han surgido muchas variantes de este microcontrolador. En el podcast puedes escuchar el capítulo que dedicamos al ESP8266 donde hablamos de las diferentes alternativas. Quizás el más famoso entre los Makers sea el ESP01 debido a que fue el primero y a su bajo coste. De este precisamente voy a hablarte hoy en este artículo.La primera vez que compré un Arduino UNO, quedé fascinado al encender un simple LED. Tras varios años haciendo proyectos, me entró la curiosidad y empecé a investigar las posibilidades que nos ofrece Arduino conectado a una red o Internet.Rápidamente me compré un Shield Ethernet y la verdad, funciona muy bien. La gran pega es que tiene que tener una toma de red cerca para que se conecte. Una alternativa para evitar esto es comprar un Shield WiFi, pero el precio tira para atrás. Cuesta 4 veces más que la propia placa de Arduino, no tiene sentido.De repente, descubrí que una empresa de China había sacado un módulo WiFi de muy bajo coste y que permitía conectarse a un Arduino UNO a través de él. Este módulo era el ESP-01 y la empresa Espressif. Cuando lo compré estaba en una etapa muy temprana sin apenas documentación y muy complicado de programar.Tras unas semanas probando y configurando lo metí en un cajón donde ha permanecido mucho tiempo. Su dificultad a la hora de utilizarlo con Arduino era máxima y no merecía la pena.Con el tiempo ha ido evolucionando y en la actualidad se puede utilizar como un módulo autónomo sin necesidad de utilizarlo con Arduino es decir, como si fuera un Arduino. Hay que recordar que el ESP8266 es un microcontrolador y como tal, puede hacer las mismas funciones que un Arduino UNO. Eso si, tiene sus limitaciones.Más información en https://programarfacil.com/podcast/como-configurar-esp01-wifi-esp8266/@programarfacilc@ldelvalleh@gmag12

Cuando empezamos a trabajar con el Hardware Libre el primer proyecto que hacemos es encender un LED. Luego pasamos a mover motores, medir la temperatura o ver los datos en una pantalla LCD. En este artículo te voy a explicar 5 proyectos con Arduino que no sólo te van a enseñar a utilizar esta placa, también serán útiles en tu día a día. En ocasiones nos preguntamos ¿para qué quiero aprender Arduino?, pues aquí te doy 5 ejemplos prácticos para introducirte. En ellos aprenderás electrónica, montaje de circuitos y como no, programación.A lo largo de estos 5 proyectos con Arduino podrás entender conceptos básicos como salidas y entradas digitales y analógicas, utilización de diferentes componentes y cómo programar Arduino a través de su código nativo. También podrás aplicarlo a algún lenguaje visual como Scratch o Snap! e incluso con Visualino.[toc]5 proyectos con Arduino para introducirte en el mundo MakerEn los 5 proyectos he realizado la misma secuencia de pasos. Lo primero una descripción donde te explico, brevemente, qué es lo que hace y que situación queremos resolver. Luego explico el objetivo donde explico los requerimientos y funcionalidades. Por último veremos los componentes de todos diseños con Arduino.Aunque tengas todo bien explicado y puedas construirlo siguiendo los tutoriales, te aconsejo que una vez hayas leído la descripción y el objetivo, intentes hacerlo por ti mismo. Es un ejercicio práctico muy bueno para asentar los conocimientos sobre la computación física.Material necesarioEn los 5 proyectos con Arduino te doy un listado de los diferentes componentes electrónicos que vas a necesitar. Pero además de esos componentes, necesitarás lo siguiente.Arduino UNO o similarCable USB para conectar ArduinoProtoboardCablesComprueba las pilas con ArduinoEste sistema nos permitirá comprobar las típicas pilas que tenemos en multitud de aparatos en nuestra casa. Muchas veces no somos capaces de saber si un aparato eléctrico está roto o, simplemente, sus pilas se han acabado. Solo podremos comprobar pilas AA, AAA, C y D debido a las limitación de entrada de 5V en los pines analógicos. Este es uno de esos proyectos con Arduino útiles en nuestro día a día.Medidor de carga de bateriasObjetivoPoder detectar cuando una pila tiene suficiente energía o no a través de tres LEDs y Arduino. Cuando este tipo de pilas están completamente cargadas, suministran un voltaje de 1,5V. Según se van desgastando el voltaje disminuye. Con este diseño serás capaz de detectar esta situación.Para avisar utilizaré 3 LEDs, verde, amarillo y rojo. Si la pila está totalmente cargada, se encenderá el verde, y según se va gastando pasará al amarillo y al rojo.Componentes3 x resistencias 220 Ω1 x resistencia 2,2 kΩ1 x LED verde1 x LED amarillo1 x LED rojo[icon name="lightbulb-o" class="" unprefixed_class=""] Podemos cambiar la resolución de las entradas con analogReference para conseguir más resolución.[icon name="exclamation-triangle" class="" unprefixed_class=""] Medir más de 5V por alguna entrada analógica puede dañar la placa.[icon name="exclamation-triangle" class="" unprefixed_class=""] Cuidado con invertir las polaridades es decir, el positivo con negativo o viceversa.Sensor aparca cochesEste es el típico sensor que tienen los coches modernos. Su función es avisar de lo cerca o lejos que estamos de otro vehículo u objeto a la hora de aparcar. Nos avisa con un sonido y con unas luces que te indican lo cerca o lejos que estás de colisionar. Dentro de los diferentes proyectos con Arduino, este nos muestra un caso de la vida real.aparca-cocheObjetivoSimular el sistema que utilizan los coches más modernos a la hora de aparcar. Nos sirve para no colisionar con los otros vehículos u objetos. Según nos acercamos a un objeto el pitido va subiendo en frecuencia. Los LEDs también nos ayudan a saber lo cerca o lejos que estamos del objeto en cuestión.Si estamos lejos, el sonido se emite con una frecuencia baja y se enciende el LED verde. Si estamos en una posición intermedia, el pitido aumenta la frecuencia y se encenderá el LED amarillo. Por último, si estamos demasiado cerca el pitido será muy agudo, una frecuencia alta, y se encenderá el LED rojo.Componentes3 x resistencias 220 Ω1 x LED rojo1 x LED amarillo1 x LED verde1 x piezoeléctrico1 x sensor de ultrasonidos[icon name="lightbulb-o" class="" unprefixed_class=""] Utilizar varios sensores de ultrasonidos para poder detectar en un mayor rango.[icon name="lightbulb-o" class="" unprefixed_class=""] Se puede sustituir el sensor de ultrasonidos por un sensor de infrarrojos.Semáforo inteligenteUno de los proyectos con Arduino más típicos es el semáforo es uno de los típicos. En este caso le daré una vuelta de tuerca y lo haremos "inteligente". Este diseño con Arduino nos permitirá controlar dos semáforos dependiendo de si hay algún coche esperando o no.Puede ser muy útil para las personas aficionadas a las maquetas de tren o de otro tipo. Si tu eres uno de ellos ya conocerás Miniatur Wunderland (Maravillas en Miniatura) que es la maqueta más grande del mundo con más de 6.000 m². Mira el siguiente vídeo y verás lo impresionante que es.ObjetivoEl objetivo es poder simular un cruce con semáforos donde se detecte la presencia de los coches para activar o desactivar los semáforos. Para esta simulación utilizaremos unos pulsadores que nos indicará que ha llegado un coche al cruce.En un estado inicial habrá un semáforo en verde. Mientras no haya coches en el otro semáforo se mantendrá en verde. Cuando llegue un nuevo coche al semáforo en rojo dejará pasar un tiempo y se pondrá en verde cerrando el otro semáforo. Así se irán alternando uno y otro.Componentes6 x resistencias 220 Ω2 x LEDs2 x LEDs2 x LEDs2 x pulsadores2 x resistencia 10 k (pull down)[icon name="lightbulb-o" class="" unprefixed_class=""] Este proyecto es muy interesante para utilizar interrupciones.[icon name="exclamation-triangle" class="" unprefixed_class=""] Cuidado con utilizar retardos y tiempos con las interrupciones, no funcionan.Theremín con infrarrojosEl Theremín es un instrumento musical que fue inventado en el año 1919 por el ruso Lev Termen. Fue el primer instrumento musical electrónico de la historia y el precursor de lo que se conoce hoy como música electrónica. Los instrumentos han avanzado mucho desde entonces, pero en aquella época fue toda una revolución.Lo que diferencia a este instrumento de otros es que, no es necesario el contacto físico para que suene. Aplica la física y teoría de antenas para producir el sonido. Utiliza la capacitancia de los seres humanos para aumentar o disminuir el sonido y cambiar la frecuencia de éste.ObjetivoEn este proyecto con Arduino, el objetivo es simular un Theremín en cuanto al cambio de frecuencia. La filosofía va a ser la misma lo único que en vez de utilizar la capacitancia, vamos a utilizar un sensor de infrarrojos. Cuando acercamos la mano al sensor, el sonido aumentará de frecuencia (más agudo) y cuando la separamos, la frecuencia disminuye (más grave).Debemos de ser capaces de discretizar el espectro audible entre 20 Hz y 20 KHz en muestras para que, dependiendo de donde se encuentre la mano suene de una manera o de otra.Componentes1 x piezoeléctrico1 x sensor de infrarrojos[icon name="lightbulb-o" class="" unprefixed_class=""] Podemos utilizar un sensor de ultasonidos en vez de un sensor de infrarrojos.Dado eléctricoSeguro que has jugado al parchís o a algún otro juego donde es necesario utilizar un dado para jugar. Los proyectos con Arduino donde tocamos el lado lúdico, tienen más éxito debido a su carácter divertido. En este caso vamos a simular un dado de 6 caras, un cubo. Existen otro tipo de dados que tienen más caras y se utilizan en otro tipo de juegos. Se podría llegar a simular y solo deberíamos cambiar parte de nuestro código.ObjetivoEl objetivo es conseguir un número aleatorio del 1 al 6 cuando se pulse un pulsador. Este número saldrá representado en un display de 7 segmentos. Hay que llevar mucho ojo con los números aleatorios con Arduino ya que si no se hace bien, siempre obtendrás el mismo o la misma secuencia.Dados para juegos Componentes1 x pulsador1 x display 7 segmentos1 x resistencia 10 k(pull down)1 x resistencia 220 Ω[icon name="lightbulb-o" class="" unprefixed_class=""] En este proyecto también se pueden utilizar interrupciones. Te animo a que lo hagas.Proyecto Halloween con ArduinoComo extra os dejo un proyecto que propone la marca BQ donde podemos hacer una calavera para que los niños se diviertan en día de Halloween. Podemos descargar el material para imprimir en su página web.ObjetivoDentro de los proyectos con Arduino este es muy interesante para crear con nuestros hijos o alumnos el día de Halloween. Consiste en una calavera de cartón que se articula con un servomotor. Dentro tiene un sensor de infrarrojos y cuando detecta que alguien mete la mano para coger las chuches, la calavera se cierra y suena un sonido. Muy divertido y temático para este día tan especial para los pequeños.Componentes1 x servomotor1 x piezoeléctrico1 x sensor infrarrojosPuedes escuchar este programa en, iVoox, iTunes y en Spreaker. Si lo haces, por favor valora y comenta, así podremos llegar a más gente.

En este capítulo voy a hablar de la computación física desde el punto de vista de Arduino. Para entender este concepto, tenemos que ser conscientes que la programación o computación física, involucra algo más que programar en un lenguaje de programación. Esto es una parte de esta disciplina y por lo tanto, se debe tratar como tal. Otra de las áreas involucradas dentro de la programación física es el hardware. En este punto, el Open Hardware (o hardware abierto) juega un papel muy importante. Por último, debemos conocer las herramientas necesarias para poder desarrollar este concepto en toda su extensión.Durante este artículo y el capítulo del podcast que acompaña, voy a dar una visión general de este concepto y todo lo que involucra.Necesito que me hagas un favor, votar por Programarfacil en los premios Bitácoras. Solo te llevará 2 minutos, muchas gracias ;).ejemplo_boton_300¿Qué es la computación física?Se centra en diseñar dispositivos, objetos e incluso entornos que permitan establecer un canal de comunicación entre el mundo físico y el mundo virtual. Aunque esto suene a algo relacionado con el futuro, la realidad es que llevamos conviviendo con esta disciplina mucho tiempo. Solo tenemos que pensar en un ordenador o en un dispositivo móvil. Estos dispositivos ponen en contacto nuestro mundo, el mundo físico, y el mundo virtual de las máquinas y ordenadores.El diálogo se realiza a través de interfaces hardware como un teclado, ratón, micrófono, pantallas, altavoces etc... La finalidad de la computación física es diseñar estas interfaces para que sean capaces de detectar alteraciones en el medio físico y traducirlas a señales que entiendan las máquinas. Esto se hace tanto a través de software como de hardware.En la actualidad, cuando desarrollamos un software para un ordenador o un dispositivo móvil, estamos aplicando computación física. El problema que existe es que solo tocamos una de las patas de esta disciplina. Las interfaces hardware de los dispositivos actuales, nos limita a la hora de diseñar software para esas interfaces. Gracias al Open Hardware, esto está cambiando.En resumen, para avanzar en el mundo de la computación física, necesitamos de ciertos componentes hardware (transductores) que conviertan los cambios de energía producidos por las alteraciones en el medio físico, en señales eléctricas entendibles por los ordenadores y máquinas. Aquí es donde entran en juego los sensores. Son los encargados de transformar una magnitud física en una señal eléctrica. Pero como esta comunicación es bidereccional, también necesitaremos actuadores que convierten las señales eléctricas en magnitudes físicas.Los ordenadores, ya sean microprocesadores o microcontroladores, son los encargados del control de los sensores y actuadores. Deben ser capaces a la vez, de comunicar con otras máquinas para mostrar los datos en pantallas multimedia o almacenar información en base de datos o en la nube.Proceso Computacion FísicaDiseño de interfaces hardware en la computación físicaComo ya hemos visto, una de las partes importantes dentro de la computación física es el hardware. Aquí se ve involucrado tres componentes de hardware a nivel básico.Los sensores serán los encargados de detectar esas alteraciones en el medio físico y transformarlas en señales eléctricas. Tenemos como ejemplos el sensor de temperatura LM35 o el DHT11 que además mide la humedad. Dentro de esta categoría podemos encontrar también el sensor de ultrasonidos HC-SR04 con el que podemos hacer un sensor de nivel de agua.Los actuadores harán lo contrario, convertir señales eléctricas en magnitudes físicas que activan procesos. Los motores paso a paso de las impresoras 3D o los relés son ejemplos de actuadores. Incluso un LED funciona como tal.El microcontrolador será el encargado de controlar y gestionar los sensores y actuadores. Podríamos pensar en utilizar un microprocesador, nos daría más potencia y funcionalidades y es verdad, pero los microntroladores tienen ciertas características por las cuales es la opción más óptima. Dentro del propio chip viene todo integrado, memoria RAM donde se almacenan datos temporales, memoria ROM o Flash para almacenar los programas y dispone de entradas y salidas que nos permitirán conectar los sensores y actuadores.Además, los requerimientos que vamos a necesitar no son muy exigentes, solo procesaremos la señal de entrada y salida. Los microcontroladores son más económicos y más compactos que los microprocesadores. Por último, nos permite comunicar con otras máquinas a través de diferentes protocolos, una característica que se requiere a la hora de diseñar interfaces hardware para la computación física.Y cuando hablamos de microcontroladores, se nos viene a la cabeza Arduino. Sin duda alguna es la mejor opción para realizar nuestros proyectos.¿Qué es Arduino?Arduino es una placa microcontroladora para el prototipado. No voy a entrar en contar otra vez su historia pero si que hay que dejar claro ciertos aspectos. Fue creada en el año 2005 por cinco señores entre los cuales está David Cuartielles, un español de Zaragoza del cual debemos estar muy orgullosos. En principio estaba destinada a estudiantes para que pudieran conectar componentes y hacer sus desarrollos.Dos características hacen única a esta placa, su bajo coste y su sencillez a la hora de utilizarlo tanto a nivel de software como de hardware. Además, cuando adquirimos un Arduino no solo estamos comprando una placa, también tenemos a nuestra disposición una plataforma totalmente abierta. Tenemos un entorno de desarrollo de código abierto, podemos bajarnos su código fuente, y una documentación muy extensa.Por lo tanto, si vas a adquirir uno, piensa antes de comprar una copia, ¿quieres que el proyecto y la plataforma sigan siendo libres y de acceso a todo el mundo?Pero quizás la idea más fantástica que tuvieron estos cinco señores fue publicar el diseño de la placa microcontroladora con licencias libres Creative Commons. Esto significa que cualquiera puede fabricar una replica o modificar y adaptar el diseño a sus requerimientos sin pedir permiso. Es más, podemos llegar a comercializar la placa sin ningún problema eso si, siempre respetando la imagen de marca.Dentro de la gama de productos que nos ofrece Arduino, el más utilizado y comercializado es el Arduino UNO.

Podcast Notes Parker got the bootloader on the EFM8 working. The Errata shows that EFM8 chips younger then data code 1601 do not have a working bootloader. Should have an article out next week about using the EFM8 MCUs. EFM8 Factory Bootloader User Guide and the associated software. Has open source Python code for the uploader. DTR - Data Terminal Ready : RTS - Request To Send Stephen - "C is awesome" Parker thinks someone should make an IDE where you can click on register names and it will open up the datasheet to the correct spot. MacroDuino: "Better version of the Arduino Uno". Has USB Type-C, a FT230X, and a non working power management. See Figure 1. Stephen was out for most of the week for his wife's surgery. They used the DaVinci Machine. It is a "ridiculous medical like robot, anime, mecha, crazied" 4 armed robot where the doctor sits in a pod and controls everything remotely. Video of the DaVinici Machine skinning an apple. While waiting during surgery, Stephen designed a voltage controlled amplifier for a synthesizer design he is working on. See Figure 2. It uses a THAT Corporation THAT2180. Does 0dB down to -120dB using only two ICs. Silicon Labs released the Thunderboard Sense. Has loads of sensors! Relative Humidity and Temperature Sensor Si7021 UV and Ambient Light Sensor Si1133 Pressure Sensor BMP280 Indoor Air Quality and Gas Sensor CCS811 6-axis Inertial Sensor ICM-20648 MEMS Microphone SPV1840 Snap Chat is in the Hardware game now. The Spectacles are glasses that capture 10 sec videos. Looks super hipster.  Has wireless but no would on what kind of connectivity. Probably Bluetooth. Will it survive where Google Glasses failed? Parker wants to put a light tower on the outside of the new shops bathroom to indicate the current status. Smart bathrooms are the way of the future. Hot Wheel brand capacitors. Why? Special thanks to whixr over at Tymkrs for the intro and outro!

Ya escribí un artículo donde explicaba con un caso práctico para usar las interrupciones en Arduino. En este capítulo del podcast vamos a ver todo lo que necesitas saber sobre este sistema que permitirá que nuestros programas sean más eficaces y más legibles. Además liberan al procesador de rutinas innecesarias en muchas ocasiones. ¿Cuántos sketchs o programas hemos realizado donde comprobábamos si un pin estaba en alto o bajo en cada iteración del bucle? Esto se ha acabado ya. Si eres capaz de dominar las interrupciones te limitarás a programar lo verdaderamente importante dentro de tus proyectos.En el proyecto que estoy llevando a cabo, el tiesto inteligente, me han surgido varios problemas que debo de resolver. Sobre todo a la hora de implementar el algoritmo que permita que el DFRobot se mueva solo. La idea es poder usar interrupciones en Arduino que me permitan centrarme en lo verdaderamente importante y organizar el código de una manera más limpia y eficaz.Antes de continuar te quiero hacer dos recomendaciones. La primera es que escuches el capítulo 42 del podcast La Hora Maker, donde César y Uribex tratan un tema muy interesante pero a la vez, muy controvertido.Por otro lado, el día 8 de octubre de 2016 se celebra en Murcia el Mur Mak, la Murcia Maker Fest a la cual asistiré como visitante. Si estás por los alrededores te recomiendo que vayas. Habrán talleres, cursos y exposiciones muy interesantes.Y ahora si, vamos a comenzar el capítulo por qué usar las interrupciones en Arduino.¿Qué son las interrupciones en Arduino?Vamos a verlo con un símil de la vida real. Imagínate que estás viendo una película o una serie en el salón de tu casa. Te abres una cerveza y estás dispuesto a pasar unas cuantas horas de evasión y fuera de la rutina. Pero estás esperando que te llegue una carta muy importante, tan importante que en cuanto la tengas en tus manos la tienes que abrir sin demora.Lo normal es que tengas dos opciones. La primera sería que el cartero dejara la carta en el buzón y tu fueras a por ella. Al ser tan importante, si quieres leerla inmediatamente nada más que la deje, tendrías que ir a comprobar cada dos por tres si ha llegado la carta al buzón. Esto sería un poco incómodo ya que deberías parar la película, ir al buzón y comprobar si está. Pero existe una segunda opción, que la carta te llegue con acuse de recibo es decir, que el cartero llame a tu puerta y tu recibas la carta firmando el recibo.Esto es lo que sucede dentro del código de nuestro proyecto. Cuando queremos leer un pin digital lo podemos hacer de dos maneras. Estar leyendo constantemente el pin con la función digitalRead(numPin) o usar un mecanismo por el cual, se interrumpa la ejecución del programa normal o principal para hacer algo concreto.Las interrupciones permiten que el microcontrolador esté pendiente de un evento para realizar una acción concreta. No hace falta estar consultando constantemente el pin digital que queramos leer. El sistema es totalmente automático y está implementado dentro de la electrónica del microcontrolador.¿Por qué usar las interrupciones en Arduino?Lo primero que hay que decir es que no siempre es conveniente usar las interrupciones en Arduino. Dependerá de cada situación. La norma dice que siempre que el código que se vaya a ejecutar interrumpa el funcionamiento normal, deberemos utilizar una interrupción. Si por el contrario, ese código es como consecuencia de que se termina una acción, no se deben utilizar interrupciones.Se trata de un proceso asíncrono, algo que sucede en cualquier momento mientras se ejecuta el programa normal. El microcontrolador es el encargado de estar pendiente del evento que lanza la interrupción. Nosotros solo indicamos cuándo y qué se tiene que ejecutar.No hay que confundir esta técnica con la multitarea. Los microcontroladores en la mayoría de los Arduino, no soportan la ejecución de procesos en paralelo. El funcionamiento normal consiste en ejecutar una tarea tras otra, de forma secuencial.Por lo tanto, usar interrupciones en Arduino, no vamos a conseguir multitarea. Pero si que vamos a conseguir que nuestro código sea más eficiente y más legible. Aunque sea un proceso asíncrono, nos permitirá sincronizar de una manera precisa ya que capturamos el evento justo en el momento que se produce evitando así que se pierda en el olvido.El ejemplo típico es capturar un pulsador. Si queremos capturarlo en cualquier momento, de forma asíncrona, el método más optimo es a través de interrupciones.Dentro de las interrupciones existen varios tipos.Tipos de interrupciones en los microcontroladoresPodemos catalogar las interrupciones en 3 tipos.Interrupciones externasYa hemos visto el símil de la carta que llega a nuestra casa. Este sería el caso de una interrupción externa. Es algo que sucede fuera del microcontrolador y que es captado por los pines destinados a las interrupciones.Arduino UNO tiene dos pines, el 2 y el 3. Para configurar las interrupciones lo haremos a través del software. Podemos hacerlo de dos maneras, a través de la SDK de Arduino o a través de registros. Se recomienda la primera opción por facilidad.Básicamente debemos de tener en cuenta tres parámetros, el pin que vamos a utilizar, la función ISR (Interrupt Service Routine) que será el código que se ejecuta y el modo, que indica qué evento lanzará la interrupcion (si están estado bajo, si pasa de bajo a alto, si pasa de alto a bajo, etc....)Se pueden utilizar en muchos cosos, cambiar la velocidad de parpadeo de un LED a través de botones, detectar movimiento a través de un sensor PIR, contar revoluciones de un motor, etc....Interrupciones con temporizadorFuncionan igual que las interrupciones externas y también es un proceso asíncrono. La diferencia es que el evento, en este caso, es temporal. Cada cierto intervalo de tiempo se ejecuta la función asociada a la interrupcion, ISR.Para conseguir determinar si ha pasado el tiempo utiliza los ciclos de reloj del procesador. Arduino cuenta con varios temporizadores que se utilizan para diferentes fines. Par controlar la función delay() o millis(), para generar señales PWM, etc...Si queremos utilizar interrupciones temporales deberemos hacer uso de estos temporizadores. La librería TimerOne nos facilita el uso de este tipo de interrupciones.Un ejemplo muy típico es cuando en algún proyecto necesitamos un LED parpadeando como notificación de que todo funciona correctamente. Lo más conveniente es utilizar una interrupción temporal para encender y para apagar el LED. Esto permite que no se entorpezca la ejecución normal del programa.Interrupciones por softwareSon las que se producen a través de una instrucción dentro del programa. Arduino y los microcontroladores de 8 bits no soportan este tipo de interrupciones. Pero podemos simularlas de una manera muy sencilla.Si configuramos un pin como interrupción, solo debemos poner dicho pin en el estado adecuado para que el evento se dispare y pare la ejecución normal del programa. Esto sería la manera de simular este tipo de interrupciones.Interrupciones InternasEn el capítulo 93 donde hablaba del ESP8266, comentábamos que una de las ventajas que tienen las placas como Arduino es que eran Plug&Play, conectar y listo. Cuando estamos programando con el módulo ESP-01, uno de los inconvenientes es que si quieres cargar un nuevo programa debes resetear de forma manual la placa. Esto no sucede en Arduino.Precisamente es debido a las interrupciones internas. Una de ellas es la función de reset, que se ejecuta cuando queremos cargar un sketch nuevo al microcontrolador.Pero existen multitud de interrupciones internas a las cuales, podemos tener acceso. Pero esto es un tema algo complicado y complejo de programar. Si no es necesario, no recomiendo acceder a ellas bajo ningún concepto ya que podemos dejar la placa bloqueada.Si quieres profundizar más sobre este tipo de interrupciones puedes ver la hoja de especificaciones técnicas del microcontrolador Atmel.Buenas prácticas para usar interrupciones en ArduinoTarde o temprano vamos a tener que utilizar esta técnica en alguno de nuestros proyectos. Yo te voy a dar unos consejos muy básicos que te ayudarán a que tu código sea más óptimo, eficaz y legible.La función asociada (ISR) debe ser lo más breve posibles. Mientras se está ejecutando el resto del programa está parado.No utilizar dentro de las rutinas las funciones de tiempo delay(), millis(), etc...Tener en cuenta la prioridad e las interrupciones. Al no poder ejecutar diferentes procesos en paralelo, las interrupciones tienen una prioridad de ejecución, tenlo en cuenta.Mientras se esté ejecutando una rutina asociada a una interrupción, Arduino no podrá capturar otra interrupción.Las variables que utilicemos tanto dentro como fuera de las funciones ISR deben ser declaradas globales con la palabra reservada volatile.Puedes escuchar este programa en, iVoox, iTunes y en Spreaker. Si lo haces, por favor valora y comenta, así podremos llegar a más gente.Conocer como funciona el mundo es la única manera de poder cambiarlo.

Comenzamos esta segunda parte de la serie de capítulos donde voy a montar el proyecto del tiesto inteligente. En este caso te hablaré del robot Pirate 4WD Mobile Platform y del Motor Shield de Adafruit, en este enlace puedes ver un tutorial muy completo que he creado.He trabajado duro esta semana con estos dos componentes y te voy a contar mi experiencia. Eso si, sin apenas programar, que es lo que a mi me gusta. Como ves, está completamente montado y además del Motor Shield también he añadido un sensor de ultrasonidos. Hoy no te voy a hablar de este sensor, eso lo veremos en el siguiente capítulo. Te recuerdo que en el capítulo 90, veíamos el concepto general de este proyecto.Pirate 4WD Mobile PlatformYa te he hablado de este robot. Esta semana la he dedicado a ensamblarlo completamente y me ha dejado gratamente sorprendido. El tamaño es algo que me ha chocado, no es todo lo grande que esperaba, pero puede ser de gran ayuda. Además, recuerda que esto es un prototipo, siempre tendremos tiempo de cambiar cualquier componente.Mientras lo montaba he ido grabando vídeos y quiero hacer un pequeño tutorial sobre este robot. Dentro de poco lo tendrás en la web. Mientras tanto te dejo el primer vídeo donde monto el chasis principal, los motores y el interruptor.https://youtu.be/w615enUMoewPuedes ver más vídeos como este en el canal de Youtube de Programarfacil.La verdad es que no resulta complejo pero si que hay que llevar especial cuidado con ciertos aspectos. Por ejemplo, vamos a necesitar soldar cables al interruptor y entre ellos. Al final, se aprende a soldar a base de practicar. El resultado puedes verlo a continuación.Lo más importante de todo es tener paciencia y seguir el manual que viene dentro de la propia caja. Si tienes alguna duda, ponte en contacto conmigo.Motor Shield de AdafruitNo te voy a contar mucho de esta placa, tienes un tutorial completo donde te detallo hasta el más mínimo detalle. Solo te voy a dar las especificaciones básicas que tiene el Adafruit Motor Shield.Se comunica por I2C con Arduino.Puedes conectar hasta 32 motor shield en serie.Tiene dos conexiones para servos de 5V.Puede mover motores desde 4,V a 13,5V.Admite diferentes tipos de motores.4 motores DC o de corriente continua.2 motores paso a paso o stepper (unipolar o bipolar)2 servomotores.Posibilidad de utilizar dos fuentes de alimentación. Para Arduino y para el motor shield. Importante para reducir el ruido.Compatible con Arduino UNO y Mega.Disponible librería de Adafruit para controlar la placa. Muy sencilla.Compatible con niveles lógicos de 5V y 3,3V.Yo voy a utilizar los 4 puertos para conectar los 4 motores del DFRobtot. Además utilizaré un zócalo de pines para el servomotor. Me he pasado una semana muy divertida montando el robot y la placa. El resultado del primer prototipo lo puedes ver en el siguiente vídeo.Todavía queda mucho trabajo por hacer pero poco a poco hay que ir avanzando. La siguiente semana te hablaré del sensor de ultrasonidos y del algoritmo que evite que choque contra los obstáculos.Puedes escuchar este programa en, iVoox, iTunes y en Spreaker. Si lo haces, por favor valora y comenta, así podremos llegar a más gente.Conocer como funciona el mundo es la única manera de poder cambiarlo.

Después de unas semanas de vacaciones en este periodo estival, vuelvo a la carga con un nuevo capítulo del podcast La Tecnología Para Todos. Hoy voy a hablarte de cómo eliminar el ruido en Arduino.Tarde o temprano te verás expuesto a esta señal parasitaria que se acopla a tu señal útil y perturba tus mediciones. Por eso es necesario saber qué es el ruido, cuáles son las fuentes que lo producen y como podemos atajarlo.Al igual que en muchos factores involucrados en la electrónica y en la programación, no hay una fórmula mágica para la eliminación del ruido, pero si que podemos aplicar ciertas técnicas que nos ayuden a mitigarlo en la medida de lo posible.Eliminar el ruido en ArduinoAntes de comenzar con tema que voy a tratar hoy, decirte que el 14, 15 y 16 de Octubre, estaré en las XI JPOD (Jornadas de Podcasting) en Málaga. En este evento nacional realizaré un directo junto a Gabriel Viso del podcast Pitando. Si vas a estar por allí, espero verte.¿Qué es el ruido?, conocerlo nos ayudará a eliminar el ruido en ArduinoPodemos encontrar muchos artículos, libros e incluso vídeos sobre el ruido en Internet. El objeto de este capítulo no es profundizar hasta tal detalle, solo quiero dejar claro cómo afecta a nuestros proyectos y cómo podemos eliminar el ruido en Arduino.El ruido no deja de ser una señal eléctrica, al igual que las señales de Arduino, normalmente una señal continua de 5V, y de otros sistemas eléctricos que trabajan con señales alternas que pueden ir, por ejemplo, de 220V a -220V.Por lo tanto, el ruido es una señal de interferencia que se añade o se suma a nuestra señal útil produciendo efectos perjudiciales. Vamos a verlo con un ejemplo. Imagínate un sensor de temperatura cuya relación temperatura-voltaje es de 1º-10mV. Esto quiere decir que cada grado, se incrementa en 10mV la tensión obtenida. Si medimos la temperatura en algún lugar donde sabemos que hay 20ºC exactamente, el resultado será 200mV. Al conectar el sensor a Arduino comprobamos que el voltaje obtenido es de 220mV, lo que equivale a una temperatura de 22ºC. Esos 20mV de más ¿qué son? Precisamente eso es el ruido, una señal parasitaria que se añade a nuestra señal útil y por lo tanto la altera.Diseñamos con casos ideales que no contemplan el ruido en nuestros proyectosCuando estamos diseñando nuestro proyecto, utilizamos la típica Ley de Ohm o Leyes de Kirchhoff. Estas leyes se basan en desarrollos matemáticos que no tienen en cuenta el efecto del ruido. Podemos probar a crear un circuito muy sencillo con una resistencia y un LED. Si hacemos los cálculos y obtenemos los voltajes, comprobaremos con un multímetro que aunque se parezcan, el resultado no es el mismo. Esto es debido al ruido inherente de la propia placa de Arduino, los componentes e incluso el multímetro. En consecuencia debemos contemplar esta señal perjudicial y por lo tanto eliminar el ruido en Arduino.La señal de ruido no afecta de igual manera a las señales analógicas que digitalesYa hemos visto el ejemplo de un sensor de temperatura con una señal analógica. Pero no afecta en igual medida a las señales digitales, dependerá de la amplitud del ruido. En términos generales, la señales analógicas son más sensibles al ruido.Si en el ejemplo anterior del sensor de temperatura, la señal de ruido tuviera 0.3mV en vez de 20mV, no afectaría a nuestras medidas. Por lo tanto la amplitud de la señal es importante. En el caso de las señales digitales, la amplitud también es importante, pero solo afectará si dicha amplitud es lo suficientemente grande para cambiar de estado de alto a bajo o de bajo a alto.Cómo funcionan las señales digitalesHagamos un paréntesis para ver cómo funcionan las señales digitales en Arduino. Estamos acostumbrados a hablar de alto y bajo y relacionarlo con 0V y 5V. Pero eso no es realmente lo que sucede dentro de la placa. Existen unos márgenes para identificar si la señal está en estado alto o bajo.Precisamente este es uno de los puntos fuertes de Arduino, gracias a la amplitud de ese rango la señal digital soporta una gran cantidad de ruido. A continuación puedes ver la imagen donde se representan esos márgenes para el microcontrolador ATmega328 del Arduino UNO.Niveles lógicos digital ArduinoComo comprobamos, de 0V a 1,5V se considera un estado bajo. De 3V a 5V se considera un estado alto. Por último de 1,5V a 3V se considera una indeterminación. Supongamos que tenemos un nivel bajo en la señal digital con un valor de 0,5V. Para que se produzca un cambio a una indeterminación necesitaremos que la amplitud del ruido sea de más de 1V y para que cambie a estado alto más de 2,5V.Por lo tanto, el ruido no afecta en la misma medida a las señales digitales eso sí, cuando afecta los resultados pueden ser "catastróficos". Vamos a verlo con un ejemplo de la vida realEn el año 2010 se produjo el apagón analógico, se pasó de emitir la televisión en analógico a digitalRecordarás que antes la televisión se veía de diferente manera. Antes del año 2010, se emitía con una señal analógica. A partir de ese año se empezó a emitir en digital a través de la TDT (Televisión Digital Terrestre).Con la televisión analógica, cuando había interferencias por ruido, la señal se distorsionaba y se producía el típico efecto nieve. Aún así se conseguía ver la televisión, aunque sin calidad. Con la TDT se consiguieron varias cosas entre ellas una mejor calidad, la necesidad de menor potencia para emitir y la optimización del ancho de banda. El gran problema de este tipo de señales es que si le afecta el ruido, la televisión se deja de ver. Seguramente te habrá pasado alguna vez donde la televisión se ha quedado en negro. Esto sucede por lo anteriormente comentado, la señal de ruido tiene tanta amplitud que hace cambiar de estado a los bit digitales.En resumen, el ruido es otra señal que interfiere con nuestra señal útil. Afecta en mayor medida a señales analógicas que digitales, pero cuando estas últimas son afectadas, su recuperación es complicada. Si queremos eliminar el ruido en Arduino, debemos conocer las fuentes y factores que lo producen.

In this extra long episode Peter adds a display to his Arduino Uno. Emile visits the W5SLA hamfest. George explains how a triode tube amplifier works. Our friend from the Great White North, Mike Morneau, VE3MIC demonstrates the Universal Digital Repeater Controller operating D-Star on a competing format repeater. We unwrap a 'Mystery Package' that arrived from a foreign country. George and Tommy sample fine Canadian cuisine and Marmite for the first time. Which wins the title of most awful taste ever, Marmite or Vegemite? Plus plenty of the usual fun and some great viewer photos. 1:55:40

In this extra long episode Peter adds a display to his Arduino Uno. Emile visits the W5SLA hamfest. George explains how a triode tube amplifier works. Our friend from the ‘Great White North’, Mike Morneau, VE3MIC demonstrates the Universal Digital Repeater Controller operating D-Star on a competing format repeater. We unwrap a ‘Mystery Package’ that arrived from a foreign country. George and Tommy sample fine Canadian cuisine and Marmite for the first time. Which wins the title of most awful taste ever, Marmite or Vegemite? Plus plenty of the usual fun and some great viewer photos. 1:55:40

Hasta ahora siempre hemos hablado de prototipado. Pero llega un momento en que queremos dar un paso más y queremos realizar un producto final. En este capitulo os vamos a contar las herramientas para Makers que tenemos disponibles. Con ellas nos convertiremos en profesionales de este mundo y llegaremos a convertir nuestra idea en un producto final preparado para comercializarlo o utilizarlo en su emplazamiento definitivo.Pero antes de empezar queremos darle las gracias a Gabriel Viso por dejarnos estar en su programa y por tener una charla tan amena en su podcast pitando. Si quieres escuchar la charla que tuvimos puedes hacerlo desde aquí. No os la podéis perder, hablamos de Arduino y del proyecto que estamos hablando y también damos nuestras impresiones sobre estas materias y la educación en España.Queremos recordaros, que un par de semanas cumplimos nuestro primer año publicando este podcast y queremos celebrarlo con todos vosotros. Nos podéis enviar mensajes diciéndonos que es lo que más os gusta y lo que menos del programa, si añadiríais alguna sección, si echáis en falta algún tema... en definitiva lo que queráis decirnos y en ese programa lo veremos. También nos podéis enviar mensajes de audio con algún mensaje para la comunidad o para nosotros, recordad presentaros en el audio.Y como siempre, para contactar con nosotros y enviarnos cuanlquier mensaje, duda o sugerencia lo puedes hacer de diferentes maneras, a través del formulario de contacto, en el e-mail info@programarfacil.com, en Twitter (@programarfacilc) o en Facebook. También puedes mantenerte al día a través de la lista de distribución.Y vamos en materia con el programa. La finalidad de este capítulo es ver los pasos que queremos seguir y las herramientas que necesitamos para crear un proyecto de principio a fin. Vamos a dividir el capítulo en 4 secciones:Análisis y prototipado.Fabricación PCB.Diseño chasis o carcasas.Fabricación chasis.Pero lo primero es decidir que proyecto queremos hacer y su finalidad. Los ejemplos clásicos son:Estación meteorológica.Medidor de contaminación.Sistema domótico.Brazo robótico.Análisis y prototipadoEn esta fase que a su vez la podemos dividir en dos. Lo primero es coger "papel y boli" y ver las necesidades que vamos a tener, los componentes que vamos a necesitar, las herramientas que vamos a utilizar y la lógica del programa que queremos implementar. Y comenzaremos a prototipar realizando pruebas de circuitos y de programación para ver si realmente nuestro proyecto cumple la finalidad que le hemos propuesto. Veamoslo todo detenidamente.Elección de hardware:En esta fase inicial escogeremos una placa de Arduino UNO, Mega o 101. En un paso posterior ya sabremos que placa se ajusta más a nuestras necesidades y elegiremos la definitiva. En este punto también deberemos ver que componentes vamos a necesitar y las herramientas como mutímetro, alicates, etc... vamos a utilizar. En el capitulo "kit de iniciación" hablamos de todas estas herramientas.Elección de software:Esta elección es bastante personal, ya que a cada uno nos sentimos más cómodos con un IDE que con otro. Pero siempre hay que mirar las caracteristicas que tienen unos y otros y nuestras necesidades ya que no siempre el IDE va a cumplir nuestras necesidades. Por ejemplo, los lenguajes visuales no son adecuados para este tipo de proyecto, ya que estan limitados y solo son una elección a la hora de aprender a programar, no de utilizarlos profesionalmente.También deberemos ver si tenemos conexión a internet o no para elegir un IDE online o uno de escritorio o si el IDE tiene alguna caracteristica imprescindible para nuestro proyecto. De esto hemos hablado largo y tendido en el capitulo dedicado a los entorno de desarrollo para Arduino pero aqui os dejamos un listado de los más interesantes:Arduino IDE oficialArduino Create (online)Codebender (online)Visual Micro (Visual Studio)Atmel Studio 7Elección de visualización de datos:No es lo mismo visualizar los datos en una pantalla TFT o LCD, que en un web, en un móvil o en una app de escritorio. Esta elección nos cambiara por completo el proyecto, la conexión que tendremos con otro hardware y por lo tanto la lógica de nuestro programa.Almacenamiento de datos, computación en la nube:Es posible que nos interese almacenar nuestros datos en la nube para que estén accesibles a otro dispositivo utilizando servicios web. A continuación os listamos algunos de los servicios más recomendables:AzureAWS Amazon CloudApp Engine de GoogleOracleBluemixY uno especializado en el IoT que ya hablamos de él:XivelyDiseño del prototipo del circuito:Entramos en la fase de prototipar el circuito, para ellos tenemos dos herramientas que os hemos hablado en muchas ocasiones:123dcircuits:No es software librePermite simulación.Faltan componentesNo están todas las placas de ArduinoNo permite subir a la placaFritzing:Software libreNo permite simulaciónGran cantidad de componentesPosibilidad de importar componentesBastantes tipos de ArduinoPermite cargar en la placaFabricación de circuito impreso (PCB)Ya tenemos el prototipo ahora hay que construirlo. Dependemos de los objetivos y requerimientos no es lo mismo si vamos a necesitar comunicación con otro dispositivo, con internet o cuando pines digitales y analógicos vamos a necesitar. También debemos tener en cuenta que consumo tiene nuestro circuito, que batería debemos incorporar o las condiciones en la que se va a encontrar, si en la intemperie o dentro de una casa.Con toda esta información vamos a elegir la placa final que vamos a elegir. Empezamos con un Arduino UNO o MEGA, pero estas son muy grandes y puede que no necesitemos tanta potencia o tantos pines. Lo recomendable es escoger una de las siguientes:PlacaArduinoMicroArduinoPro MiniArduinoProArduinoMKR1000Voltaje Operación5V3.3V y 5V3.3V y 5V3.3 VPines digitales2014148PWM7664Pines analógicos12667Conexión-- WIFIY si es por tamaño tenemos las llamadas placas Wearables que aunque estan pensadas para textil nada nos impide utilizarlas en otros proyectos. Estas placas que son circulares tienen un diámetro de 2.7 cm.PlacaArduino GemaArduino LilypadVoltaje Operación3.3 V2.7 V y 5.5 VPines digitales39PWM25Pines analógicos14En cuanto a los componentes tendremos que fijarnos en el consumo, en la precisión que tienen y en el rango de operaciones (temperatura, tensión e intensidad).Diseño del circuito impresoUna vez tenemos claro todos los componentes y realizado el prototipado es hora de construir el PCB (Printed Circuit Board), el circuito impreso. Lo que hacemos es pasar nuestro circuito a una placa o tarjeta eliminando los cables y utilizando pistas de material conductor, normalmente cobre. Y ya iremos dando forma a nuestro producto final.Para realizar esto, podemos utilizar el programa Fritzing, ahí podemos diseñar nuestro diseño PCB y luego este programa nos da la facilidad de enviar este circuito y pedirlo online para que nos produzcan nuestras placas a la que tendremos que soldar nuestros componentes.Diseño de chasis o carcasasY ya solo nos falta aportarle a nuestro producto un chasis o una carcasas, como os hemos dicho antes no es lo mismo si el producto va a estar en la intemperie o en un sitio cerrado. Existe multitud de software para diseño 3D y desde aquí os recomendamos unos cuantos:Software libreFreeCADBlender (animación y modelado 3D)Google SketchUp (Tiene base de datos de modelos 3D sobre todo para construcción)Software de pagoInventor (Autodesk)Autocad (Autodesk)Fusion 360 (Autodesk)SolidworksRhinoceros (Arquitectura)3D Studio (animación profesional)Pero también tenemos la opcion de ir a una base de datos de modelos 3D y escoger uno que se adapte a nuestro prototipo:Una de las más famosas Thingiverser (gracias a Cesar de La Hora Maker)YeggiCG traderGrab CAD3D Content CentralFabricación chasisY ya solo nos queda fabricar ese chasis y ¿dónde podemos fabricarlo?. Pues es recomendable buscar un Fablab en tu ciudad, si buscas en google seguro que encontraras uno cercano, normalmente están vinculados a las universidades como es el caso de Alicante. Y sino tienes uno cerca seguro que tienes una empresa de 3D cerca. Y bueno, siempre nos quedara la opción clásica, por corte láser o fresado.El recurso del diaElectroDroides una aplicación para Android con múltiples herramientas electrónicas y documentación técnica. La aplicación incluye entre otras herramientas: decodificador para el código de resistencias, calculadora de la ley de Ohm, calculadora de reactancia, divisor de voltaje o calculadora de vida de baterías. Una herramienta indispensable que te hará más fácil prototipar tu proyecto.Muchas gracias a todos por los comentarios y valoraciones que nos hacéis eniVoox, iTunes y en Spreaker, nos dan mucho ánimo para seguir con este proyecto.

Cuando realizamos proyectos de Arduino se nos puede dar el caso que necesitamos más salidas digitales de las que nuestra placa de Arduino tiene y se nos presenta el problema de coger otra placa con más salidas o de alguna forma aumentar esas salidas digitales. En este capitulo vamos a ver una técnica para aumentar las salidas digitales en Arduino y también un chip que nos sirve para este propósito.Pero antes de continuar tenemos dos razones que celebrar en programarfacil, la primera es que ya tenemos nuestro primer curso disponible para todos vosotros, "Aprende a programar con Arduino". Entra en nuestro campus y echa un vistazo, si tienes alguna duda puedes utilizar los canales que siempre tenemos habilitados para ti , a través del formulario de contacto, en el e-mail info@programarfacil.com, en Twitter (@programarfacilc) o en Facebook. Este curso esta orientado para gente que se quiera iniciar en la programación y en Arduino. Aprenderemos a programar con lenguajes visuales ya que la curva de aprendizaje es prácticamente plana y como nuestro lema es aprender con constancia pero divirtiéndose hemos preparado dos juegos (Tres en raya y Twister) para que disfrutes mientras aprendes. Y para los más valientes tendremos retos al final de cada modulo.La segunda razón de celebración es que dentro de unas semanas cumplimos nuestro primer año publicando este podcast y queremos celebrarlo con todos vosotros. Nos gustaría que nos enviarais mensajes de vuestras impresiones sobre este primer año de programa. Mensajes que queráis compartir con nosotros y con el resto de los oyentes. Lo podéis hacer de dos formar en redes sociales con el hashtag #AniversarioPF o a través del email info@programarfacil.com. Podéis enviar mensajes de texto y también mensajes de audio. Si enviáis mensajes de Audio no olvidéis presentaros en el audio. Gracias a todos por estar con nosotros este año y dentro de unas semanas lo celebraremos.Y ya vamos a por lo que le dedicamos este programa, a aumentar las salidas digitales de Arduino. En muchas ocasiones tenemos pines de sobra pero hay que optimizar ya que siempre es bueno dejar pines para el futuro y no tener que replantearse el diseño del circuito. También hay ocasiones que no tenemos pines suficientes para nuestro proyecto, por ejemplo en el Arduino UNO tenemos 14 salidas digitales y en el Arduino MEGA tenemos 54. Por este motivo no es necesario tener que comprar una Arduino MEGA que es mucho más potente que la Arduino UNO, el motivo tiene que ser de mayor peso. Otra cosa a tener en cuenta es el consumo en nuestros circuitos pero para esto tenemos pensado dedicarle un programa.Todas las características de las placas las tenéis disponibles en el segundo PDF que os enviamos a los que os que estáis suscritos a nuestra lista de distribución. Y si no estas suscrito, ya tienes una razón más para hacerlo y recibirás varios PDFs con mucha información sobre Arduino.Técnica CharlieplexingShift Register o registros de desplazamientoCon estos chips vamos a poder aumentar a partir de 3 salidas digitales en 8 salidas digitales y no solo vamos a poder controlar LEDs sino cualquier elemento que queramos conectar a una salida digital. En particular os hablamos del chip 74HC595 cuyo valor es inferior a 1€ y suele estar en cualquier kit de iniciación de Arduino.Estos chips se pueden poner en serie para seguir aumentando el número de salidas digitales y siempre a partir de 3 salidas digitales de nuestra placa de Arduino. Por ejemplo, si queremos en una placa Arduino UNO con 14 salidas digitales tener las 54 salidas que tenemos en la placa de Arduino MEGA necesitaremos 54 / 8 = 6,75 ≅ 7 chips.Estas tres salidas de Arduino irán a tres entradas del chip y cada una tendrá una función, una sera la señal de reloj, otra sera los datos que queremos enviar y la tercera la utilizamos como disparador, para pasar los datos a las 8 salidas del chip.Para facilitar el uso de este tipos de chips tenemos una función nativa en Arduino. shiftOut que realiza una comunicación síncrona con el chip. En esta función le enviamos la señal de reloj y los datos que al final son las salidas que queremos que entes activas o no (HIGH o LOW) en las salidas del chip.Para el que quiera profundizar un poco más sobre este chip y esta función, aquí tenéis un articulo donde lo explica con detalle.Existen otros chips que hacen funciones parecidas. Tenemos el 74F675A que muy parecido al anterior pero nos saca 16 salidas digitales. Aunque la diferencia de precio también es mayor. Sale más barato comprar dos de los anteriores que uno de estos.Hay otro chip que realiza la función "contraria", aumentar las entradas digitales que es el 74HC165 pero ya dedicaremos otro programa o articulo para contároslo.Como ejemplo de uso el más típico es el de las luces del coche fantástico pero con 8 LEDs y con múltiples posibilidades como encender las luces de las posiciones pares o impares, solo las n primeras... lo que tu imaginación quiera.El recurso del díaInstructablesProyecto creado por personas pertenecientes al MIT Media Lab y parte de los fundadores del Squid Labs. En este sitio web encontrarás miles de proyectos orientados al mundo Maker y al DIY (Doit Yourself). La gente puede compartir libremente sus proyectos y su trabajo creando una comunidad de grandes personas y oportunidades. Probablemente, una fuente de inspiración, que te puede ayudar y orientar a conseguir tus objetivos.Muchas gracias a todos por los comentarios y valoraciones que nos hacéis en iVoox, iTunes y en Spreaker, nos dan mucho ánimo para seguir con este proyecto.

We cross borders into the world of physical computing to chat about hardware hacking at House4Hack. Kenneth, Kevin & Len are joined by Toby Kurien (@TobyKurien), one of the early founders of House4Hack, a maker space in Centurion, and chat about Raspberry PI, Arduino, hacking telescopes, sub-orbital flight (ok, not really), home automation and lots more. House4Hack is an open space dedicated to providing enthusiasts with a community and space where they can build physical computing projects and embedded systems. CHANCE TO WIN! Tweet your favorite episode (and mention us) by 15/2 for a chance to get a R256 discount on your DevConf ZA ticket. Follow Toby & House4Hack on the internet: * https://twitter.com/TobyKurien * http://tobykurien.com * http://www.house4hack.co.za * http://groups.google.com/group/house4hack * http://www.meetup.com/house4hack-centurion/ Here are some resources mentioned during the show: * Arduino - http://www.arduino.cc * House4Hack High Altitude Glider Project - http://www.house4hack.co.za/high-altitude-glider-video * House4Hack PiScope - http://www.house4hack.co.za/piscope * OpenCV - http://opencv.org * Make your own smart watch - http://www.instructables.com/id/Make-your-own-smart-watch/ * Desktop aquaponics - http://www.house4hack.co.za/desktop-aquaponics * Getting started with Arduino Book - https://store.arduino.cc/product/B000001 * Raspberry PI 2 - https://www.raspberrypi.org/products/raspberry-pi-2-model-b/ * Arduino UNO - https://www.arduino.cc/en/Main/ArduinoBoardUno * ESP8266 - http://www.esp8266.com * Intel Edison - http://www.intel.com/content/www/us/en/do-it-yourself/edison.html * Intel Galileo - https://www.arduino.cc/en/ArduinoCertified/IntelGalileo * Arduino IDE Built-in examples - https://www.arduino.cc/en/Tutorial/BuiltInExamples * Activating a camera shutter with an Arduino - http://www.martyncurrey.com/activating-the-shutter-release/ * How to photograph water droplets - http://www.photosbykev.com/wordpress/tips-and-trick/water-droplet-photography/ * X10 & Arduino - https://www.arduino.cc/en/Tutorial/X10 * Other home automation protocols explained - http://www.digitaltrends.com/home/zigbee-vs-zwave-vs-insteon-home-automation-protocols-explained/ * Ubuntu MATE - https://ubuntu-mate.org * OpenELEC - http://openelec.tv * KODI - http://kodi.tv * RetroPie - http://blog.petrockblock.com/retropie/ * 7 fantastic RetroPie game stations - http://www.makeuseof.com/tag/7-fantastic-retropie-game-stations-can-build-weekend/ * Turning the Raspberry PI into an FM transmitter - https://github.com/rm-hull/pifm * Raspbian - https://www.raspbian.org * Magpi magazine - https://www.raspberrypi.org/magpi/ * Raspberry PI Zero - https://www.raspberrypi.org/products/pi-zero/ * Node-RED - http://nodered.org Suppliers mentioned (no affiliation) * http://za.rs-online.com * http://www.communica.co.za * http://robotics.org.za * http://www.mantech.co.za * http://www.netram.co.za * http://www.hobbytronics.co.za * https://www.adafruit.com * https://www.sparkfun.com * http://www.dx.com * http://www.banggood.com Other local maker spaces * Binary Space in the Vaal Triangle - http://www.binaryspace.co.za * Makerlabs in Randburg - http://makerlabs.co.za * The MakerSpace in Durban - http://themakerspace.co.za * Maker Station in Cape Town - http://makerstation.co.za And finally our picks Kevin: * Johnny-Five - http://johnny-five.io * Arduino Starter Kit - https://www.arduino.cc/en/Main/ArduinoStarterKit Kenneth: * Lanseria Airport - http://lanseria.co.za * Adafruit Learn Arduino Series - https://learn.adafruit.com/series/learn-arduino Toby: * Hacker News - https://news.ycombinator.com * uMatrix browser addon - https://github.com/gorhill/uMatrix * Detect and disconnect WiFi cameras in that AirBnB you're staying in - https://julianoliver.com/output/log_2015-12-18_14-39 Len: * Lichess - http://en.lichess.org/

Hoy vamos a hablar de cómo podemos leer la temperatura ambiente. Para ello vamos a utilizar un sensor de temperatura en Arduino UNO, más concreto el sensor analógico LM35. Como ya hablamos en el capítulo donde tratábamos la API, necesitamos la función analogRead para capturar el valor que nos proporciona el sensor.Si tienes alguna duda sobre Raspberry Pi o algún otro tema de tecnología puedes contactar con nosotros a través del formulario de contacto, en Twitter y en Facebook. También tenemos a tu disposición una lista de distribución.SorteoComo queremos premiar a todos nuestros seguidores fieles y también que os iniciéis en el maravilloso mundo de Arduino, vamos a sortear un KIT DE INTRODUCCIÓN A ARDUINO para que podáis empezar. El sorteo se realizará con todos aquellos que estén suscritos a la lista de distribución hasta el día 27 de Octubre de 2015 a las 24H (hora peninsular española). Si todavía no estás suscrito, a qué esperas.Antes de meternos en faena, recordemos como funcionan las entradas analógicas en Arduino. Aunque estemos hablando de un valor analógico, Arduino discretiza en 1024 valores (0 a 1023). Esto quiere decir que si tenemos un rango de valores de entre 0 V y 5 V, cuando el sensor nos de un valor de 0 V con analogRead tendremos un valor de 0 y cuando nos de 5 V tendremos 1023. Si nos da un valor de 2,5 V simplemente tenemos que hacer una regla de 3 y calcular que valor nos proporcionará dicha función.LM35 sensor de temperaturaEn este artículo vamos a utilizar el sensor LM35. Este sensor, como cualquier otro sensor, tiene unas características de funcionamiento las cuales se pueden ver en su ficha técnica. Este documento es el punto de partida para utilizar cualquier sensor en Arduino. Nos aportará la información necesaria para trabajar con él y es indispensable consultarlo antes de empezar.Lo primero que debemos tener claro es el conexiado. Si nos vamos a la página 3 veremos que el sensor tiene 3 patillas, hay que fijarse en el gráfico que pone LP Package 3-Pin TO-92. Si miramos de frente el sensor, por la parte plana veremos algo parecido a la siguiente imagen.lm35-sensorDonde Vs es la alimentación, normalmente a 5 V que es lo que nos da la placa de Arduino salvo que especifiquemos lo contrario, GND es la toma de tierra y Vout es la salida que proporciona el sensor.Por lo tanto de aquí podemos sacar como debemos conectar el sensor con Arduino. Antes de hacerlo tenemos que estar seguro que el rango de trabajo de este sensor soporta los 5V que nos va a proporcionar nuestra placa. En caso contrario deberíamos hacer algo para reducir esos 5V. En la página número 1 encontramos un apartado que pone Features (características). De aquí podemos sacar mucha información. Si miramos en el apartado que pone Operates from 4 V to 30 V, nos está diciendo que funciona con voltajes de 4 V a 30 V así que estamos dentro del rango permitido.Ahora vamos a fijarnos en la salida que nos proporciona el LM35. Las dos primeras líneas dicen:Calibrated Directly in Celsius (Centigrade)Linear + 10-mV/ºC Scale FactorLa primera línea nos dice que el sensor está calibrado en grados centígrados con lo cual no hará falta realizar ninguna transformación si queremos saber la temperatura en estas unidades. La segunda línea nos viene a decir que los cambios de temperatura son lineales con un factor de escala de 10mV por ºC (grado centígrado) es decir, para 1 ºC tendremos una tensión de 10 mV. Esto es muy importante ya que hay una regla de proporción entre el voltaje de salida y los grados.Si nos fijamos un poco más abajo en las Features (características) encontramos el rango completo de temperaturas de -55 ºC a 150 ºC. Esto quiere decir que a -55 ºC tendremos -550 mV y a 150 ºC tendremos 1.500 mV. Esto también lo puedes ver en la ficha técnica en la primera página el gráfico que pone Full-range Centigrade Temperature Sensor.Por último hay fijarse también en las Features, donde nos dice 0.5°C Ensured Accuracy (at 25°C) que quiere decir que para garantizar la precisión hay que trabajar en este rango de temperaturas de 0.5ºC a 25ºC.Así que ya has podido ver lo importante que son las fichas técnicas de los sensores y dispositivos. Hay que remitirse siempre a la web del fabricante y obtener dicha ficha para sacar el máximo partido a los sensores.Calcular la temperaturaLlega la hora de los cálculos. Como buen programador debes hacer uso de las matemáticas y la lógica y cuando trabajamos con Arduino, debemos hacer exactamente lo mismo. No estoy hablando de hacer ecuaciones diferenciales ni derivadas, aunque en algún caso esta operación matemática nos pueda salvar, estamos hablando que lo más complicado que haremos por el momento será una simple regla de 3.Si os acordáis de cuando hablamos de la API de Arduino, hay una función que se llama analogRead donde le pasamos como parámetro el número de pin que queremos leer y nos da un valor entre 0 y 1023 osea, 1024 valores. Esto quiere decir que si en el pin tenemos 0V nos dará 0 y si tenemos 5V o 3.3V (depende de a que voltaje esté funcionando nuestro Arduino) nos dará 1023, así de sencillo.Por lo tanto si queremos saber que voltaje tenemos en la entrada analógica solo debemos de multiplicar por 5/1024 (0.0048V de precisión). Esto nos da el voltaje de nuestro sensor, ahora hay que transformar los voltios en grados. Ya hemos averiguado, gracias a la ficha técnica, que 1ºC equivale a 10mV (0.01V) por lo tanto solo debemos de dividir el valor de voltaje obtenido antes entre 0.01 y nos dará la temperatura. Para que os quede más claro os dejo aquí la formula que deberíamos aplicar.Temperatura = (Valor * 5 / 1024) / 0.01 = Valor * 5 * 100 / 1024Y con esta fórmula tendríamos la temperatura que nos está facilitando el sensor LM35.Aumentar la precisiónComo ya hemos visto en la ficha técnica, si queremos garantizar la precisión debemos trabajar en el rango de valores de 0.5ºC y 25ºC. Esto no quiere decir que nos tengamos que ceñir a estas temperaturas pero si que nos da una idea de con que precisión deberíamos trabajar. Para estos dos valores de grados corresponden 5mV y 250mV.¿Cómo podemos aumentar la precisión? Ya hablamos en su día de la función analogReference que nos permite establecer el valor de referencia para el valor 1023 en los pines analógicos. Esta función puede tomar tres posibles valores:DEFAULTToma como referencia el valor interno de la placa 3.3V o 5V.INTERNALToma como referencia un voltaje interno de 1.1V.EXTERNALToma como referencia lo introducido en el pin AREF.Si dejamos la primera opción, DEFAULT, utilizaremos la fórmula que hemos visto antes pudiendo detectar temperaturas de hasta 500ºC. No tiene ningún sentido ya que el rango máximo será 150ºC. Así que podemos aumentar la precisión de nuestro sensor utilizando la configuración INTERNAL. Esto nos permite medir hasta un rango de 110ºC. Al cambiar el valor de la referencia, la fórmula cambia, ahora para obtener la temperatura debemos de utilizar la siguiente:Temperatura = (Valor * 1.1 / 1024) / 0.01 = Valor * 1.1 * 100 / 1024Concluyendo, es muy importante fijarse en la ficha técnica de cualquier dispositivo, nos dará información de la precisión, el rango de valores, amperaje y voltaje y factor de escala. Con toda esta información podemos obtener la temperatura de nuestro sensor con simples operaciones matemáticas.En el capítulo hablamos de los siguientes enlacesAll datasheetBases del sorteo Kit de iniciación de ArduinoRecurso del díaCodebenderEs un entorno de desarrollo online para Arduino. Se ejecuta en la nube y te permite programar para cualquier sensor o dispositivo conectado. Tiene modo depuración y cuenta con casi 500 librerías a tu disposición. Puedes trabajar online desde diferentes máquinas manteniendo las cofiguraciones establecidas. Además del entorno de desarrollo, te permite guardar tus proyectos en la nube y poder compartir para que la gente colabore.Muchas gracias a todos por los comentarios y valoraciones que nos hacéis en iVoox, iTunes y en Spreaker, nos dan mucho ánimo para seguir con este proyecto.

Primer capítulo de la serie que os iremos presentando donde veremos como crear un proyecto con Arduino y tecnología web, en este capítulo, Arduino entradas y salidas, os explicaremos como podemos conectar dispositivos al Arduino a través de las entradas y salidas.Pero como siempre ya sabéis, si queréis contactar con nosotros lo podéis hacer a través del formulario de contacto o de Twitter @programarfacilc. También tenéis una lista de distribución a vuestra disposición para que os suscribáis.En el Arduino UNO existen entradas y salidas analógicas (6) y digitales (16). Por un lado las analógicas son utilizadas, generalmente, para dispositivos de entrada y nos permiten leer un rango de valores. En cambio las digitales pueden tener a la entrada o a la salida 0V o 5V, esto nos indica que ese pin está en estado alto (High) o bajo (Low).Entradas/salidas digitalesSe trata de pines donde el usuario puede activar (poner tensión) o desactivar (quitar tensión). Es similar a escribir 0 y 1, como ya hemos dicho 0V y 5V respectivamente.Los pines 0 (Serial In RX) y 1(Serial Out TX), puerto serie, se usan para comunicación entre dispositivos. La característica principal de los puertos serie es que envían la información bit a bit, enviando un bit cada vez. La versión avanzada de este puerto sería el paralelo que nos permite enviar información en paralelo. Para que se pueda entender imaginaros un tanque lleno de agua, si de ese tanque sacamos un grifo para llenar botellas una a una éste sería nuestro puerto serie, ahora bien, si de ese tanque sacamos cuatro grifos para llenar cuatro botellas a la vez, este sería el ejemplo de un puerto paralelo. En ordenadores, el puerto serie, se usa y se sigue usando para conectar un ordenador con módems, ratones, teclados y muchos más periféricos. En el caso concreto del Arduino UNO, el puerto 0 (RX) sería el puerto serie de entrada y el puerto 1 (TX) sería el puerto serie de salida.Los pines 2 y 3 nos permiten interrumpir el funcionamiento del bucle "loop". Ya hablaremos de este bucle más adelante en otro artículo, pero quedaros con la idea de que es lo que se ejecuta continuamente dentro del código de Arduino. Imaginaros que queremos leer un sensor cada segundo. No hace falta escribir el código infinitas veces, en Arduino existe este bloque que repite todo lo que se encuentre dentro de él indefinidamente. Estos pines paran precisamente ese bucle y obligan a ejecutar un código asignado a cada pin.Los pines 3, 5, 6, 9, 10 y 11 que están marcados con el símbolo ˜, son entradas y salidas especiales ya que aunque son digitales y se pueden utilizar como tal, también se pueden utilizar para la comunicación PWM (Pulse-Width Modulation) modulación por ancho de pulsos. Se trata de una técnica que nos permite transferir información o energía a un dispositivo con una señal cuadrada. Como ya hemos dicho, los pines digitales solo atienden a dos estados, bajo (0V) y alto (5V). Si somos capaces de cambiar el estado alto y bajo controlando el tiempo que está en alto y el tiempo que está en bajo, conseguimos tener una onda cuadrada donde el tiempo que esté en estado alto (5V) será el ancho de pulso. La relación que existe entre estos dos tiempos se llama ciclo de trabajo y se expresa en tanto por ciento (%). Nos indica el tiempo que la señal está en alto en comparación con la que está en bajo. Lo podemos ver con el siguiente ejemplo.pwmEn Arduino existe una función que permite utilizar estos puertos, se llama analogWrite. No podemos utilizar cualquier rango de valores, esta función solo admite valores entre 0 y 255 (8 bits). Por lo tanto y con el ejemplo de ciclos de trabajo que tenemos arriba, podemos definir una tabla donde nos diga el valor correspondiente para introducir en la función analogWrite y la salida en volitios que tendríamos.Ciclo trabajo (%)analogWrite (0 - 255)Salida (Voltios)00025641.25501272.5751913.751002555Si por ejemplo tenemos conectado un led a alguna de estas salidas es fácil imaginar que pasará, cuando esté al 25%, el led tendrá una intensidad del 25 % y así sucesivamente.Los pines 10, 11, 12 y 13 son utilizados para conectar varios dispositivos entre sí, por ejemplo varios Arduinos. Son los pines SPI (Serial Peripheral Interface) ya que precisamente utilizan este estándar de comunicación, definido para comunicar circuitos integrados con comunicación serie a través de un bus de comunicación. El pin 10 es el SS (Slave Select) es el puerto esclavo (Slave). Permite seleccionar el Slave desde el Master o para que el Master active el Slave, si es el esclavo. El pin 11 es el MOSI (Master Output Slave Input). Se usa como entrada de datos del Master y la salida de datos del Slave. El pin 12 es el MISO (Master Input Slave Output) es el contrario del pin 11, permite entrada de datos del Master y salida de datos del Slave. Por último el pin 13 SCK (Select Clock) nos sirve de señal de reloj. Se trata de un pulso, como el visto en los pines PWM, que marca la sincronización entre los dispositivos conectados. Cada pulso de ese reloj se envía o se lee un bit.Entradas/salidas analógicasEn el Arduino UNO tenemos 6 entradas analógicas que van marcadas con una A delante. Aunque pueden ser utilizadas como salida, su uso más común es la lectura de datos de dispositivos analógicos. Tiene una resolución de 10 bits lo que implica que tenemos 1024 valores diferentes, es decir, podemos leer un rango de tensiones desde 0V hasta 5V detectando cambios de voltaje de 0.004V (5/1024).Los pines 4 y 5 soportan la comunicación I2C (Inter-Integrated Circuit), muy parecida al bus de comunicación SPI y sirve para conectar varios dispositivos. En este tipo de comunicación cada dispositivo tiene una dirección única y cada dispositivo puede funcionar como maestro (Master) o esclavo (Slave). El pin 4 es el SDA (Serial Data Line) y se utiliza para la transmisión de datos en serie. El pin 5 es el SCL (Serial Clock Line) suministra la señal de reloj para mantener a todos los dispositivos conectados sincronizados.Otras entradas/salidasAdemás de los pines digitales y analógicos ya explicados existen otros pines que nos dan diferentes funcionalidades.GND (Ground) es la toma de tierra, 0V.AREF (Analog Reference) es el pin que nos suministra la tensión para el rango máximo de los puertos analógicos, normalmente 5V.Vin es la entrada de alimentación de la placa Arduino. Esta entrada no está protegida y por lo tanto hay que tener un especial cuidado con el voltaje que suministramos ya que podemos quemar la placa. Se recomienda una alimentación por USB en el periodo de pruebas.5V y 3.3 V suministra una tensión de 5V y 3.3V respectivamente.RESET sirve para resetear el Arduino si aplicamos la tensión máxima posible (IOREF). Reinicia el Arduino volviendo a ejecutar el Bootloader y el programa que tengamos cargado. Importante, esta función no borra el programa que tengamos cargado en la memoria del Arduino.IOREF (Input Output Reference) es el pin que nos suministra la tensión para el estado alto de los pines digitales. Por norma general si conectamos el Arduino a 5V este pin nos dará 5V, en caso contrario serán 3.3V.Pues hasta aquí el programa de hoy, hemos visto todo lo necesario para poder conectar a nuestro Arduino diferentes tipos de dispositivos. Os esperamos en el siguiente capítulo donde veremos más cosas interesantes sobre Arduino.Recurso del día123d.circuits.ioOs presentamos una aplicación on-line muy interesante. Se trata de una web donde podemos crear nuestros propios diseños con Arduino, se llama 123d circuits y es de la casa Autodesk, los creadores de Pixelr, la aplicación web de retoque fotográfico que ya comentamos el capítulo 9.Además del laboratorio de electrónica donde prototipar, también puedes diseñar tu propia placa de circuito impreso PCB (Printed Circuit Board).Lo mejor de todo es que es gratuito, tienes multitud de componentes y entre ellos un Arduino UNO y un Arduino Micro, resistencias, potenciómetros, servos, leds, protoboard, pulsadores y muchos componentes más, aunque tiene ciertas limitaciones. No nos permite usar sus modelos 3D para uso comercial, tenemos acceso a aplicaciones 3D de diseño, acceso ilimitado a los componentes básicos, acceso a 10 modelos premium, espacio de alojamiento ilimitado en la nube e ilimitados proyectos, tutoriales y acceso a foros.Si quieres empezar con Arduino sin comprar uno, esta es la mejor opción para que te adentres en este mundo.Muchas gracias por todos los comentarios y valoraciones que recibimos a través de las plataformas de podcast ivoox, iTunes y Spreaker.

01:47 - An Arduino is a Microcontroller 03:46 - Where Do You Get an Arduino? Arduino Uno SparkFun Adafruit 05:00 - Getting Started (Equipment) Shields 07:58 - Language/Interface Arduino - Software Functions: Setup Loop 13:07 - Raspberry Pi vs Arduino 16:30 - iOS Compatibility WiFi Bluetooth 4.0 The Core Bluetooth Framework Packetizer Firmata 24:12 - Projects [Kickstarter] Wired In - Wireless Productivity Sign With Arduino & HomeKit Wired In Arduino Esplora Electric Imp 32:24 - Patterns 34:41 - Debugging Picks The 7 Day Startup: You Don't Learn Until You Launch by Dan Norris (Alondo) UIKonf 1995 Keynote: Object-Oriented Programming in Objective-C (Andrew) AmScope SE400-Z Professional Binocular Stereo Microscope (Andrew) Charlie Christian Neck for Telecasters (Jaim)

01:47 - An Arduino is a Microcontroller 03:46 - Where Do You Get an Arduino? Arduino Uno SparkFun Adafruit 05:00 - Getting Started (Equipment) Shields 07:58 - Language/Interface Arduino - Software Functions: Setup Loop 13:07 - Raspberry Pi vs Arduino 16:30 - iOS Compatibility WiFi Bluetooth 4.0 The Core Bluetooth Framework Packetizer Firmata 24:12 - Projects [Kickstarter] Wired In - Wireless Productivity Sign With Arduino & HomeKit Wired In Arduino Esplora Electric Imp 32:24 - Patterns 34:41 - Debugging Picks The 7 Day Startup: You Don't Learn Until You Launch by Dan Norris (Alondo) UIKonf 1995 Keynote: Object-Oriented Programming in Objective-C (Andrew) AmScope SE400-Z Professional Binocular Stereo Microscope (Andrew) Charlie Christian Neck for Telecasters (Jaim)

It's ALTV's 9th Anniversary. We give away the IC-7100 complete mobile outfit. Tommy talks about Dynamic DNS and when to use it. Peter prepares for his balloon flight. George presents his CheapoDuino scaled down Arduino Uno clone. Plus what we've been up to

It’s ALTV’s 9th Anniversary. We give away the IC-7100 complete mobile outfit. Tommy talks about Dynamic DNS and when to use it. Peter prepares for his balloon flight. George presents his CheapoDuino scaled down Arduino Uno clone. Plus what we’ve been up to…