<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Joshua Hrisko on Medium]]></title>
        <description><![CDATA[Stories by Joshua Hrisko on Medium]]></description>
        <link>https://medium.com/@joshhrisko?source=rss-10a819574515------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*mjx5FgOzq3V776gZ_f6FMw.jpeg</url>
            <title>Stories by Joshua Hrisko on Medium</title>
            <link>https://medium.com/@joshhrisko?source=rss-10a819574515------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 11:04:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joshhrisko/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Characterizing a Solar Panel using Arduino]]></title>
            <link>https://medium.com/@joshhrisko/characterizing-a-solar-panel-using-arduino-c4238f2f870?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4238f2f870</guid>
            <category><![CDATA[solar-energy]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[makers]]></category>
            <category><![CDATA[arduino]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Mon, 25 Oct 2021 19:50:05 GMT</pubDate>
            <atom:updated>2021-10-25T19:50:05.583Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sCZv3B-MGWcXbN9nzb0row.jpeg" /></figure><p>Photovoltaic cells, commonly referred to as PV cells, are at the center of all solar panels and are responsible for the conversion of solar energy into electricity. The study and theory of photovoltaic power production is quite complex and involves understanding the non-linear relationship between voltage (<em>V</em>) and current (<em>I</em>), which is generated by solar insolation and impacted by the electronics present in a given panel configuration [read more about PV cells and solar arrays <a href="https://ieeexplore.ieee.org/abstract/document/5347680">here</a> and <a href="https://sigmaland.ir/wp-content/uploads/2020/01/Sigmaland-Model-of-Photovoltaic-Module-in-Matlab.pdf">here</a>]. In this tutorial, the aim is to characterize a solar panel by varying the load at (near) peak solar insolation to identify the panel’s nominal values such as open-circuit voltage, short-circuit current, max power voltage and current, and max power output. These values help users understand the expectations from a photovoltaic array and how their power needs may be met with a given PV system. An Arduino board will be used to log the current and voltage values outputted from a small solar panel. The current and voltage are measured using a 16-bit analog-to-digital converter power module, the INA226, which will allow us to track the power outputted from the photovoltaic panel. A potentiometer acting as a rheostat will serve as the varying load on the system, which will be used to identify the peak power points of the system. Finally, analyses will be conducted in Python 3, which will allow us to identify the peak power region and also the total power outputted over a duration of 24 hours.</p><h4>Parts List and Wiring</h4><p>There are many components used in this project, ranging from the solar panel itself to the voltage/current sensor (INA226) and SD module. The full parts list is given below, for reference. We have also developed a kit that contains the most important components used in the project, though all parts can be sourced individually either from our shop or elsewhere.</p><h3>PARTS LIST:</h3><ul><li>Solar Panel (limited to 0.5W for rheostat) — $7.00 [<a href="https://makersportal.com/shop/200mw-solar-panel-2v-120ma">Our Store</a>]</li><li>INA226 Current/Voltage Sensor — $6.00 [<a href="https://makersportal.com/shop/ina226-voltage-and-current-module-for-arduino">Our Store</a>]</li><li>BLE-Nano Board — $15.00 [<a href="https://makersportal.com/shop/ble-nano-arduino-nano-with-cc2540-bluetooth-low-energy-module">Our Store</a>]</li><li>SD Card Module — $8.00 [<a href="https://makersportal.com/shop/arduino-compatible-micro-sd-card-module">Our Store</a>]</li><li>16GB SD Card — $10.00 [<a href="https://makersportal.com/shop/16-gb-micro-sd-card-and-usb-reader">Our Store</a>]</li><li>1kΩ Potentiometer — $11.99 (60pcs Kit) [<a href="https://www.amazon.com/gp/product/B07WDCVGJV/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07WDCVGJV&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=a4d6d370b3cb1d38d5d826fed7c972ce&amp;tag=engineersport-20">Amazon</a>]</li><li>LiPo Battery, 3.7V 600mAh — $15.00 [<a href="https://makersportal.com/shop/3-7v-600mah-lipo-battery-kit-for-arduino">Our Store</a>]</li><li>Electronics Component Box — $3.00 [<a href="https://makersportal.com/shop/electronics-component-box">Our Store</a>]</li><li>Large Breadboard (400 Ties) — $6.00 [<a href="https://makersportal.com/shop/large-breadboard-400-tie">Our Store</a>]</li><li>Jumper Wires — $3.00 (10x Male-to-Male, 10x Female-to-Male) [<a href="https://makersportal.com/shop/jumper-wires">Our Store</a>]</li></ul><p>The wiring diagram for the collective system is given below:</p><p><a href="https://github.com/makerportal/solar-char/raw/main/images/experiment_setup_wiring_github.jpg">https://github.com/makerportal/solar-char/raw/main/images/experiment_setup_wiring_github.jpg</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Rcm6UX70J_9xOlMxTilew.jpeg" /><figcaption>Wiring between Arduino and solar characterization components</figcaption></figure><p>Note: we have omitted any explanation of the wiring configuration in order to declutter the tutorial, however, most of the wiring explanations can be found either on our site or in other literature/forums online. We will discuss the solar panel, potentiometer (rheostat), and INA226 current/voltage configuration later in the experimental setup section. The rest are left for the user to explore.</p><h4>Solar Panel and Photovoltaic Theory</h4><p>Solar panels often consist of an array of photovoltaic cells arranged in a way that produces a desired power output at a given voltage and current configuration. This allows users and operators to select the load based on the desired output or the panel based on the load requirement. This is why the characterization of solar panels and PV cells is of utmost importance, for both the assurance of power generation and safety of operation. That being said, sometimes it is more advantageous to model solar panels rather than develop them and characterize them later. Unfortunately, PV array models are complex and involve many co-dependent components, all of which impact the behavior, and thus the output, of the solar panel. The simplest model for a PV cell can be written as the relationship between voltage and current, as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/339/1*QHv9pLh70Eey9wpn27CiYg.png" /></figure><p>where <em>I</em> is the current and <em>V</em> is the voltage generated through the PV cell. <em>IL</em> is the photogenerated current proportional to the solar irradiance. The variables on the right-hand side of the first minus sign comprise the Shockley diode equation, which is responsible for the finite response of the solar cell (more on this later). <em>I0</em> is called the reverse saturation or leakage current, while <em>Vt</em> represents a thermal voltage generated due to the heating of the solar cell.</p><p>If we were to plot this relationship, we would get the following profile:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eoz7wrWvm7IHS_7uCOaZag.png" /><figcaption>Basic Solar Cell Voltage/Current Profile — Expected output before any electrical components are added to the solar cell system.</figcaption></figure><p>This is the simplest representation for a solar cell. Notice that there are no numbers on the plot — this is due to the fact that we need to know a bit more about the system before we attach any real-world values to anything.</p><p>For any practical application, the solar measurement will include some electrical components which will affect the profile shown in the figure above. Thus, in most models of PV cell power output involve at least shunt and series resistors. The resulting equivalent circuit is as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_krF7D_J3pquf2e6z7gJAg.png" /></figure><p>The following list describes each component in the circuit:</p><ul><li><em>E0</em> ≡ Solar Insolation</li><li><em>IL</em> ≡ Photogenerated current</li><li><em>ID</em> ≡ Diode current</li><li><em>ISH</em> ≡ Shunt current</li><li><em>RSH</em> ≡ Shunt Resistance</li><li><em>RS</em> ≡ Series Resistance</li><li><em>V</em> ≡ Cell Voltage</li><li><em>I</em> ≡ Cell Current</li></ul><p>(don’t pay any particular mind to the lack of subscripts on this platform)</p><p>If we were to setup the equation that solves for current as a function of voltage using the circuit above, we arrive at the common and applicable PV expression:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*k64V9EJqqp0fNvZ7Wp5CNg.png" /></figure><p>And here we have a more complex and difficult to solve implicit equation that relates parameters of the system to the power output potential of the cell (voltage multiplied by current). There are numerous references that have parametrically solved or empirically solved for voltage as a function of current and vice-versa, however, that is surely outside the scope of this tutorial. Often, simplifications are made relating to the series and shunt resistances, which can make the equation above somewhat easier to solve. The equation in almost all circumstances remains an implicit equation, which pushes it just outside our analysis here. We will, however, be able to demonstrate an empirical curve similar to the one shown above, which is part of the final analysis section of this project.</p><p><strong><em>Solar Cell Theory References:</em></strong></p><blockquote><em>- Dittrich, Thomas. “</em><a href="https://www.worldscientific.com/doi/abs/10.1142/9781786344496_0001"><em>Basic Characteristics and Characterization of Solar Cells</em></a><em>.” </em>Materials Concepts for Solar Cells<em>, 2nd. April 2018. pp. 3–43.</em></blockquote><blockquote><em>- González-Longatt, Francisco M. “</em><a href="https://sigmaland.ir/wp-content/uploads/2020/01/Sigmaland-Model-of-Photovoltaic-Module-in-Matlab.pdf"><em>Model of photovoltaic module in Matlab</em></a><em>.” </em>Ii Cibelec<em> 2005 (2005). pp. 1–5.</em></blockquote><blockquote><em>- Hamadani, Behrang H., and Brian Dougherty. “</em><a href="https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=915586"><em>Solar cell characterization</em></a><em>.” </em>Semiconductor Materials for Solar Photovoltaic Cells<em>. Springer, Cham, 2016. pp. 229–245.</em></blockquote><blockquote><em>- Lorenzo, Eduardo. </em><a href="https://books.google.com/books?id=lYc53xZyxZQC&amp;lpg=PP1&amp;pg=PA88#v=onepage&amp;q&amp;f=false">Solar electricity: engineering of photovoltaic systems</a><em>. Earthscan/James &amp; James, 1994. pp. 87–113.</em></blockquote><blockquote><em>- Maammeur, H., A. Hamidat, and L. Loukarfi. “</em><a href="https://www.sciencedirect.com/science/article/pii/S187661021301223X"><em>A numerical resolution of the current-voltage equation for a real photovoltaic cell</em></a><em>.” </em>Energy Procedia<em> 36 (2013). pp. 1212–1221.</em></blockquote><blockquote><em>- Raj, Shubham, Ankit Kumar Sinha, and Ashish K. Panchal. “</em><a href="https://doi.org/10.1063/1.4803748"><em>Solar cell parameters estimation from illuminated I-V characteristic using linear slope equations and Newton-Raphson technique</em></a><em>.” </em>Journal of Renewable and Sustainable Energy<em> 5.3 (2013): 033105.</em></blockquote><h4>Experimental Setup and Results</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8aX3a_t9HfrVHfX3vnfTJQ.png" /></figure><p>We will be using the <a href="https://makersportal.com/blexar">BLExAR app</a> to log the initial solar panel response to the changing rheostat values. The app is not required, however, it allows for real-time monitoring of the rheostat turns to track the voltage and current read by the INA226 meter. The BLExAR app is available for <a href="https://play.google.com/store/apps/details?id=com.makerportal.BLExAR">Android</a> and <a href="https://apps.apple.com/us/app/blexar/id1439459314">iOS</a> at the links below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jFKWWq5XvW0hCtRsV_ubKg.png" /><figcaption><a href="https://apps.apple.com/us/app/blexar/id1439459314">https://apps.apple.com/us/app/blexar/id1439459314</a></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UWmzd7g1rpNwrdP_frWRhw.png" /><figcaption><a href="https://play.google.com/store/apps/details?id=com.makerportal.BLExAR">https://play.google.com/store/apps/details?id=com.makerportal.BLExAR</a></figcaption></figure><h3>TWO ANALYSES WILL BE CONDUCTED IN THIS SECTION:</h3><ol><li>Rheostat Analysis — This involves turning the dial on the potentiometer that is wired as a rheostat. This effectively alters the load on the solar panel. This experiment should be done at near peak solar insolation such that we can tune for optimal voltage. This experiment takes just a few minutes to complete.</li><li>Diurnal Analysis — This involves setting the rheostat to the peak value found above and then leaving the entire system outside for a day or so in order to track a full diurnal (full day profile) output from the solar panel.</li></ol><p>The full set of codes used below can be found at the project’s Github page:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*I_9E2PJofkO-yOU1XKn-Xg.png" /><figcaption><a href="https://github.com/makerportal/solar-char">https://github.com/makerportal/solar-char</a></figcaption></figure><p><strong><em>Rheostat Analysis</em></strong></p><p>We first need to characterize the panel’s output range to find the optimal operating voltage. We do this by turning the rheostat (potentiometer) from minimum to maximum in order to vary the load on the solar panel. First, the Arduino code that logs and prints voltage and current must be uploaded to the microcontroller. In our case, we’re using the BLE-Nano, which acts similar to the Arduino Nano and Uno boards (ATmega328P at the center).</p><p>The code used to log and print voltage and current is given below (and at the <a href="https://github.com/makerportal/solar-char/blob/main/arduino/solar_rheostat.ino">Github repo</a>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/40ac79a04ed7cc7534b601f2598b0bb7/href">https://medium.com/media/40ac79a04ed7cc7534b601f2598b0bb7/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*tmoykaOwDojCwT5kg3i-qQ.png" /></figure><p>BLExAR Printout of Voltage and Current for the Solar Panel Rheostat Experiment</p><p>A few notes on the experiment:</p><ul><li>Make sure the solar panel is in full view of the sun. Try to avoid shadowing.</li><li>Make sure to start from one end of the potentiometer and slowly turn to the other extreme (this will create a nice smooth profile).</li><li>If an error occurs, such as with clouds or accidental covering of the panel, then just restart the Arduino and try again. The program clears the solar log file after each reset.</li><li>The rheostat should produce maximum current and minimum voltage when fully turned counterclockwise, and when turned fully clockwise it should produce maximum voltage and minimum current.</li></ul><p>Assuming the user was able to follow the directions above closely, we can take the data saved to the SD card and analyze it using the Python script entitled:</p><blockquote><a href="https://github.com/makerportal/solar-char/blob/main/python/solar_rheostat.py"><em>solar_rheostat.py</em></a></blockquote><p>The script is not given here, but can easily be found on the project’s <a href="https://github.com/makerportal/solar-char/blob/main/python/solar_rheostat.py">GitHub page</a>.</p><p>In the analysis Python code, we introduce start and end adjustment points — this is based on the fact that some of the initial and final data may be obfuscated by the user interfering when starting or stopping the data acquisition. If the user carried out the experiment correctly and successfully ran the Python 3 analysis script given above, they should see an output plot similar to the one shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i69KCGxZTqP5A7_Un-8Fcg.png" /></figure><p>There are quite a few observations one can make regarding the behavior shown in the plot above:</p><ul><li>The max power, <em>Pmax</em>, is 0.2W at a voltage, <em>Vpm</em>, of 1.6V</li><li>The open-circuit voltge, <em>Voc</em>, is 2.14V</li><li>The short-circuit current, <em>Isc</em>, is 123mA</li></ul><p>(again: don’t pay any particular mind to the lack of subscripts on this platform)</p><p>Some of these parameters may seem arbitrary, however, they identify many of the common benchmarks cited by manufacturers in solar cell and panel specifications. Some models also develop empirical models and extrapolate them to approximate power output over various scenarios and periods of time. An example empirical model can be found at:</p><blockquote><em>- Durgadevi, A., S. Arulselvi, and S. P. Natarajan. “</em><a href="https://ieeexplore.ieee.org/abstract/document/5760162"><em>Photovoltaic modeling and its characteristics.</em></a><em>” </em>2011 International Conference on Emerging Trends in Electrical and Computer Technology<em>. IEEE, 2011.</em></blockquote><blockquote><em>- Petreus, Dorin, Ionut Ciocan, and Cristian Farcas. “</em><a href="https://ieeexplore.ieee.org/abstract/document/5276599"><em>An Improvement on empirical modelling of photovoltaic cells.</em></a><em>” </em>2008 31st International Spring Seminar on Electronics Technology<em>. IEEE, 2008.</em></blockquote><p>In the next section, we will use the peak power voltage to set the load on the rheostat and investigate a full day’s power output from the solar panel at that load setting.</p><p><strong><em>Diurnal Analysis</em></strong></p><p>The next step in analyzing the solar panel power output is to place the panel out in the sun for a longer period of time, preferably a full day. This will allow for calculation of the commonly used daily solar production, written as kWh/m2/day. We can then compare this value with similar observations in the same region as our experiment (San Francisco, CA in our case). This will give us an idea of whether our experiment is successful and the panel is performing as expected.</p><p>For our specific experiment, we left the entire box outside for a day with the solar panel mounted atop the box. The panel was pointed slightly east at an angle less than 15° (due to the slight opening of the box), but mostly vertical to ensure the highest power output. The box was left outside from 8:00 a.m. June 15th, 2021 until roughly 9:00 a.m. June 16th, 2021 in northeastern San Francisco, CA. The rheostat was tuned to 1.65V based on the peak power point found above. Data points were acquired roughly every 60 seconds, based on the longterm Arduino code on the project’s Github page:</p><blockquote><em>- </em><a href="https://github.com/makerportal/solar-char/blob/main/arduino/solar_longterm.ino"><em>solar_longterm.ino</em></a></blockquote><p>After retrieving the box after an entire day’s worth of datalogging, we can then use the Python 3 script for the diurnal analysis:</p><blockquote><em>- </em><a href="https://github.com/makerportal/solar-char/blob/main/python/solar_diurnal.py"><em>solar_diurnal.py</em></a></blockquote><p>Running the diurnal analysis code results in the following plot:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ag74tUQZRUiEyZymb_WG9w.png" /></figure><p>The top plot shows the raw time-series plot of the power output from the solar panel. There were a few drops in output on the morning of June 16th due to cloud cover, which is noted in the weather log for that morning:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/955/1*IUoVH3CCXBQf5Wbv6vs9EA.png" /></figure><p>The bottom portion of the plot shows the average diurnal output of the solar panel on an hourly basis. We can sum these values (since they are hourly) and call this value the daily solar output from the panel. Summing these values we get about 1.5W, which can be interpreted as 1.5W/day. Next, if we use the effective area of each solar cell, which in our case is 30mm x 10mm, multiplied by 4x (<em>n</em> = 4) because of the four cells in the panel, we can get the power density per day:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*O67vjNJV1bTx3bXF1I_hUw.png" /></figure><p>Finally, by assuming the panel material is of crystalline silicon, which is common for smaller and cheaper panels, we can predict an efficiency between 20%-25% (see <a href="https://onlinelibrary.wiley.com/doi/full/10.1002/pip.2909">solar efficiency tables</a> for examples). With this efficiency in mind, we can make a very rough calculation of the incident solar insolation. Since solar insolation is fairly well documented, it will give us a decent idea of how the solar cell is performing. Dividing the power density above by an efficiency of 22% results in the following approximation of incident solar energy:</p><blockquote>E0 ≈ 4.5 kWh/m2/day</blockquote><p>As a check, we can find observations of solar insolation for San Francisco across the literature:</p><blockquote><em>- Dey, Sumon, Madan Kumar Lakshmanan, and Bala Pesala. “</em><a href="https://www.sciencedirect.com/science/article/abs/pii/S0960148118301605"><em>Optimal solar tree design for increased flexibility in seasonal energy extraction.</em></a><em>” </em>Renewable Energy<em> 125 (2018). pp. 1038–1048.</em></blockquote><blockquote><em>- Mitchell, L., et al. “</em><a href="https://ieeexplore.ieee.org/abstract/document/5614704"><em>Impact of microclimates on solar resource: Case study of the solar resource in San Francisco.</em></a><em>” </em>2010 35th IEEE Photovoltaic Specialists Conference<em>. IEEE, 2010.</em></blockquote><blockquote><em>- Karis, Robert. “</em><a href="https://www.sfog.us/solar/sfsolar.htm"><em>San Francisco Solar Power Map.</em></a><em>” (accessed June 16th, 2021).</em></blockquote><p>The observations range from 4.5–5.0 kWh/m2/day, which is inline with our calculation from our solar panel measurements.</p><p>The result calculated above tells us that our solar panel is operating as expected, under the assumption that its efficiency is somewhere around 20% and the solar insolation for the day of observation was somewhere around 4.6 kWh/</p><p>The result calculated above tells us that our solar panel is operating as expected, under the assumption that its efficiency is somewhere around 20% and the solar insolation for the day of observation was somewhere around 4.6 kWh/m2. This is a great result considering the many approximations and liberal assumptions made throughout the experiment. The user could continue this experiment by combining an array of panels or using a larger panel and extrapolating some of the methods used here to characterize and make predictions about the solar output. The user may also find it useful to compare the results with an irradiance meter and use those values to also create a better model of the system. There are many possibilities for taking this experiment to the next step.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZVKZOJRBOeusH52xAWMD8Q.jpeg" /></figure><h4>Conclusion</h4><p>This tutorial focused on a real-world experiment involving a solar panel and Arduino datalogging system. The goal of this work was to explore how the electrical, physical, and solar variables affect the output measured by a solar panel. Using an Arduino board, SD datalogger, LiPo battery, and INA226 power meter — we were able to demonstrate the behavior and identify many of the characteristics of a solar panel. First, we varied the load at (near) peak solar insolation to identify the panel’s nominal open-circuit voltage, short-circuit current, max power voltage and current, and max power output. These values helped us understand the optimal region of operation for the panel, while also opening the door for modeling and power prediction. We also conducted a daylong experiment that acquired data points every 60 seconds. Finally, we were able to identify the total daily power production and approximate the incident solar irradiation for the day. The experiment demonstrated the capabilities of Arduino, low-cost sensors, and the approachability of a real-world experiment with widely available hardware.</p><p>Read the full story at: <a href="https://makersportal.com/blog/solar-panel-characterization-and-experiments-with-arduino">https://makersportal.com/blog/solar-panel-characterization-and-experiments-with-arduino</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4238f2f870" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bluetooth Controlled e-Paper Display with Arduino]]></title>
            <link>https://medium.com/@joshhrisko/bluetooth-controllable-e-paper-display-with-arduino-42b38abe4310?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/42b38abe4310</guid>
            <category><![CDATA[electronics]]></category>
            <category><![CDATA[bluetooth]]></category>
            <category><![CDATA[arduino]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Sat, 28 Aug 2021 21:06:19 GMT</pubDate>
            <atom:updated>2021-08-28T21:27:50.468Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_qOzFSHPGyDZNh6FK4KIuA.jpeg" /></figure><p>Electronic paper, also known as e-Paper, is a common technology used in e-Reader devices such as the Amazon Kindle, Barnes and Noble Nook, and Sony Reader. Many e-Readers use electrophoretic technology, which functions by moving charged particles (ink) by imposing an electric field that sends ink dots to to the front or back of the e-Paper, creating shapes that humans perceive as text or images [learn more about the technology behind e-Paper: <a href="https://sid.onlinelibrary.wiley.com/doi/abs/10.1889/JSID19.2.129">here</a> and <a href="https://sid.onlinelibrary.wiley.com/doi/abs/10.1889/1.2206106">here</a>]. Unlike LCDs, OLED, and other display technologies, e-Paper is highly advantageous for low power, low refresh rate applications due to its ability to retain imagery after being powered off. Application areas for e-Paper range from electronic signage to smart watches, and of course e-Readers. In this tutorial, a 1.54 inch e-Paper module is wired to a BLE-Nano Arduino board to communicates via SPI and display text in real time over Bluetooth. The e-Paper module here can be powered via 3.3V or 5.0V, requires very low power when refreshing (2mA-8mA), and can be completely powered off while retaining its text. An <a href="https://www.amazon.com/gp/product/B08N2FRMPN/ref=as_li_qf_asin_il_tl?ie=UTF8&amp;tag=engineersport-20&amp;creative=9325&amp;linkCode=as2&amp;creativeASIN=B08N2FRMPN&amp;linkId=209bebbca2078012057695215f639e58">Android smartphone</a> and the <a href="https://makersportal.com/blexar">BLExAR app</a> will be used to print text on the e-Paper display in real time, demonstrating the capabilities of electronic paper technology.</p><h4>Parts List and Wiring</h4><p>The main component of this tutorial is the 1.54 inch e-Paper display, which can be found in our store. We are using a specialized library designed by Waveshare with custom examples developed by our team to display text on this particular e-Paper display. Thus, we cannot guarantee that any of the examples provided here will work with other displays. Fortunately, any ATmega328P-based Arduino board can be used with the library (Uno, Nano, BLE-Nano, etc.). We’re also using a Raspberry Pi 4 Computer to interface with the Arduino board. The full list of parts to follow along with the tutorial is given below:</p><ul><li>BLE-Nano Arduino Board — $15.00 [<a href="https://makersportal.com/shop/ble-nano-arduino-nano-with-cc2540-bluetooth-low-energy-module">Our Store</a>]</li><li>1.54 inch E-Paper Display — $20.00 [<a href="https://makersportal.com/shop/e-paper-display-for-arduino">Our Store</a>]</li><li>Mini Breadboard — $3.00 [<a href="https://makersportal.com/shop/mini-breadboard">Our Store</a>]</li><li>Android Smartphone — $699.99 [<a href="https://www.amazon.com/gp/product/B08N2FRMPN/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08N2FRMPN&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=209bebbca2078012057695215f639e58&amp;tag=engineersport-20">Amazon</a>] (Any recent model)</li><li>BLExAR App — $1.99 [<a href="https://play.google.com/store/apps/details?id=com.makerportal.BLExAR">Google Play</a>]</li><li>Raspberry Pi 4 Computer — $69.99 (4GB) [<a href="https://www.amazon.com/gp/product/B07TC2BK1X/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TC2BK1X&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=c901d38290b6e3aa093ba57240409918&amp;tag=engineersport-20">Amazon</a>], $119.99 (8GB Kit) [<a href="https://www.amazon.com/gp/product/B08956GVXN/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08956GVXN&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=8bdd7ce463d01b19ad6634d804b4e7ee&amp;tag=engineersport-20">Amazon</a>]</li></ul><p>The wiring between the BLE-Nano (and any ATmega328P chip) and 1.54 inch e-Paper display is given below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4_l-Ri_Z_4kkkdX3FjD7Ug.png" /><figcaption>e-Paper Wiring to Arduino Board. This wiring will work with any ATmega328P-based Arduino boards (Arduino Uno, Nano, BLE-Nano, etc.)</figcaption></figure><p>A wiring diagram directly between the e-Paper and BLE-Nano is given for additional reference:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KJ-dj82_QeSvHyWLDcu-hw.jpeg" /></figure><p>For the example in this tutorial, we chose to use 3.3V as the supply voltage, however, 5V will suffice as well. The user may also find it useful for power consumption to wire the e-Paper power pin (VCC) to a digital pin on the Arduino and control the power from there. This would be useful for situations of very low power consumption, where the user does not need to update the display often. For the rest of the tutorial, 3.3V will be used to power the e-Paper display, which consumes about 3mA during idle periods.</p><h4>The Arduino e-Paper Library</h4><p>The e-Paper library used here is based on the series of display libraries developed by <a href="https://github.com/waveshare/e-Paper">Waveshare on GitHub</a>. Users may find it helpful to check there for e-Paper displays outside of the 1.54 inch display used in this example. For reference, we are building upon the Waveshare 1.54 inch e-Paper display entitled epd1in54_V2. To follow along with this tutorial, click on the GitHub card below and get started with our library and examples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lumOSSgwDmWWpFFMDP4p_g.png" /><figcaption><a href="https://github.com/makerportal/1_54in_epaper">https://github.com/makerportal/1_54in_epaper</a></figcaption></figure><p>The simplest way to test your e-Paper display is to run the example script entitled:</p><blockquote><strong><em>simple_text_display.ino</em></strong></blockquote><p>The code is also given below for reference:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16612b4fa8b8393d5a350a272bead6ad/href">https://medium.com/media/16612b4fa8b8393d5a350a272bead6ad/href</a></iframe><p>This simple example will print out integer values starting with 0 and marching forward until the count overflows. We are also printing a header, defined by three different texts: “1.54in e-Paper,” “Simple Demo,” and “Maker Portal.”</p><p>The basic setup for the e-Paper library is as follows:</p><pre>Epd epd; <em>// initiate e-paper display [epd]</em><br><strong>unsigned</strong> <strong>char</strong> image[1024]; <em>// memory for display</em><br>Paint paint(image, 0, 0); <em>// setup for text display</em></pre><p>First, we instantiate the e-paper display (EPD) also known as the electrophoretic display. Then we assign a print function called ‘paint’ that uses the pre-allocated variable called ‘image.’ Next, we want to initialize, clear, and refresh the display using the following:</p><pre>epd.LDirInit(); <em>// initialize epaper</em><br>epd.Clear(); <em>// clear old text/imagery</em><br>epd.DisplayPartBaseWhiteImage(); <em>// lay a base white layer down first</em></pre><p>Finally, we are able to set the text to display using the following representations:</p><pre>paint.Clear(UNCOLORED); <em>// clear background</em><br>paint.DrawStringAt(0, 4, str_to_print.c_str(), &amp;Font20, COLORED); <em>// light background</em><br>epd.SetFrameMemory(paint.GetImage(), 0, initial_space+   (3*row_height), paint.GetWidth(), paint.GetHeight());<br>epd.DisplayPartFrame(); <em>// display new text</em></pre><p>This series of commands prints values to the e-Paper display, particularly in the light background and dark foreground format. The function ‘DrawStringAt()’ defines the relative location, fontsize, and color (Black [colored] vs white [uncolored]). Next, the ‘SetFrameMemory()’ designates the location of the text within the entire e-Paper display, which is why we are using offset values based on the header and row height. There are many customizations that are possible with these variables and we are only showing a very brief example. In the next section we will explore a bit more on customizing the text display. The simple example given above should output text similar to that shown in the image below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7hyahkrYGiCHQs5wCiBc0A.jpeg" /></figure><p>We can expect the simple example to iterate continually. This type of example can be extrapolated to increment as a clock or counter of a similar fashion. One example may be with an electronic label in a department store, or counter for counting customers in a store, or something similar with long-term operation and low refresh rate applications. In the next section, we will introduce Bluetooth capabilities and near real-time updating using an Android smartphone and the BLExAR app.</p><h4>Bluetooth-Enabled e-Paper Display</h4><p>The following example requires the BLE-Nano board and BLExAR app (both the iOS and Android versions suffice). Thus, if the user does not have both of these — the following demonstration may not translate.</p><p>The Bluetooth demo for the BLE-Nano and 1.54 inch e-Paper display can be found at the GitHub page under the following example file:</p><blockquote><strong><em>simple_text_display.ino</em></strong></blockquote><p>The code is also given below for reference:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ad0d6d8176f86d4707b2707ecc935a62/href">https://medium.com/media/ad0d6d8176f86d4707b2707ecc935a62/href</a></iframe><p>Out of the box — the code above should print out the same three headers as the simple demo given in the previous section. Next, the BLE-Nano waits for the BLExAR app to send text and will print out the text as soon as it receives a newline character. The GIF below shows the user sending the text and the e-Paper updating accordingly:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*a5qxj4HfHMOW6XCpB2AvGA.gif" /><figcaption>e-Paper + Android Bluetooth Display. Android text printed out on the 1.54in e-Paper display.</figcaption></figure><p>Each time the text is sent to the Arduino board it sends the new text onto a new line. Thus, with the current setting, the display will refresh after 6 lines of new text, where the sixth line refreshes the display and prints to the first line. The refresh rate of the partial update in the Bluetooth case is roughly 1–2 seconds. Once the display gets the sixth line, it will take roughly 5–6 seconds to refresh the entire display and update with the new text. This is of course one downside to e-Paper display, but a well-established limitation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HH-N1FBBorFD58vg6ro_mQ.jpeg" /><figcaption><strong>e-Paper Zoomed-In</strong>: The resolution of the 1.54 inch e-Paper display is about 185dpi, which is about 40% of the resolution of the newest smartphone devices (Apple’s iPhone 12 has a resolution of ≈460 dpi [technically ppi], and the Samsung Galaxy S21 has a resolution of ≈421 dpi). This results in a fairly decent resolution for the display at close range.</figcaption></figure><p>A video demonstration of the Bluetooth-enabled e-Paper display is given below, showing the speed and update routine of the Arduino and Android communication:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FC0-7_8QE8kc%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DC0-7_8QE8kc&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FC0-7_8QE8kc%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/24c9a96aaa86c89e03373fa80d3b0ef4/href">https://medium.com/media/24c9a96aaa86c89e03373fa80d3b0ef4/href</a></iframe><h4>Conclusion</h4><p>e-Paper displays are great alternatives to LCDs and OLEDs due to their low power requirements between refreshes and their ability to maintain high contrast during sunlight — a common issue for backlit devices such as tablets and smartphones. In this tutorial, we introduced a 1.54 inch e-Paper module and wired it to a BLE-Nano Arduino board for SPI communication. The goal of the project was to send text from a <a href="https://www.amazon.com/gp/product/B08N2FRMPN/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08N2FRMPN&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=209bebbca2078012057695215f639e58&amp;tag=engineersport-20">smartphone device</a> and display it in real time on the e-Paper display. We were able to achieve this by using a BLE-Nano board and the BLExAR smartphone app communicating via Bluetooth Low Energy (BLE). Two examples were given: the first displayed a simple iterator on the e-Paper module without Bluetooth; while the second example updated its display with the text sent by the smartphone. The possibilities of this e-Paper project are endless and have the potential for applications in electronic labeling in department stores, long-term status indicators, high-contrast electronic displays, and of course, electronic readers.</p><p>Find more tutorials at: <a href="https://makersportal.com/">https://makersportal.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42b38abe4310" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Radio Frequency Identification (RFID) Using Arduino]]></title>
            <link>https://medium.com/@joshhrisko/understanding-radio-frequency-identification-rfid-using-arduino-68eacb2f8c2f?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/68eacb2f8c2f</guid>
            <category><![CDATA[rfid]]></category>
            <category><![CDATA[electronics]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[arduino]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Sun, 22 Aug 2021 18:57:25 GMT</pubDate>
            <atom:updated>2021-08-22T18:58:45.066Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*esvQPt78Q7Xrzzj6WsemHg.jpeg" /></figure><p>Radio Frequency Identification, or RFID, is a widely used technology developed for storing and retrieving information in radio frequency-enabled devices. Most often, RFID systems consist of one or multiple RF tags, an RF reader, and a database. The RFID tags have unique identifiers (UIDs) that allow for identification by the reader via the database. RFID tags can be active or passive, meaning they either require external power (active) or are powered by the reader upon scanning (passive). Passive RFID tags are most commonly used for building and security access, shipment tracking, and inventory monitoring; while active tags are used for road tolls and asset tracking in larger spaces across longer distances. The radio frequencies used in RFID can range from low frequency (124 kHz+) to ultra high frequency (900 MHz — 2.4 GHz), depending on the application [read more about the specifics of RFID <a href="https://arxiv.org/abs/1002.1179">here</a> and <a href="https://www.emerald.com/insight/content/doi/10.1108/01409170610665022/full/html">here</a> and <a href="https://ieeexplore.ieee.org/abstract/document/1589116">here</a>]. In this tutorial series, passive, high frequency (13.56 MHz) RFID tags are the focus, as they are very compact, inexpensive, and require no external battery power. Using an Arduino board, a common RFID reader (MFRC522), and a few RFID tags/cards, we will be exploring methods for reading and writing RFID information in an attempt to understand how RFID communication works and identify the limits of the technology with Arduino.</p><h4>Parts List and Wiring</h4><p>We will be using an Arduino Uno board and an <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC52213.56</a> MHz RFID reader in this tutorial, along with several RFID tags and cards. The MFRC522 communicates with the <a href="https://makersportal.com/shop/arduino-uno-r3-maker-portal">Arduino board</a> via SPI, so we will need quite a few jumper wires to connect the two devices. We’re also interfacing with a <a href="https://www.amazon.com/gp/product/B07TC2BK1X/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TC2BK1X&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=c901d38290b6e3aa093ba57240409918&amp;tag=engineersport-20">Raspberry Pi 4</a> computer. The full parts list is given below:</p><ul><li>Arduino Uno Board — $13.00 [<a href="https://makersportal.com/shop/arduino-uno-r3-maker-portal">Our Store</a>]</li><li>MFRC522 RFID Kit (6-Tags + Fixture) — $18.00 [<a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">Our Store</a>]</li><li>RFID Tags/Cards — $7.88 (10 fobs) [<a href="https://www.amazon.com/gp/product/B074C3RDMV/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B074C3RDMV&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=0fe69413165d2f178d2a7ef9491a5c4a&amp;tag=engineersport-20">Amazon</a>], $6.99 (10 cards) [<a href="https://www.amazon.com/gp/product/B01FR66KWI/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B01FR66KWI&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=b2eca7b9263899a785794f4bd4fd973f&amp;tag=engineersport-20">Amazon</a>]</li><li>9x Male-to-Female Jumper Wires — $1.35 [<a href="https://makersportal.com/shop/jumper-wires">Our Store</a>]</li><li>Raspberry Pi 4 Computer — $69.99 (4GB) [<a href="https://www.amazon.com/gp/product/B07TC2BK1X/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TC2BK1X&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=c901d38290b6e3aa093ba57240409918&amp;tag=engineersport-20">Amazon</a>], $119.99 (8GB Kit) [<a href="https://www.amazon.com/gp/product/B08956GVXN/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08956GVXN&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=8bdd7ce463d01b19ad6634d804b4e7ee&amp;tag=engineersport-20">Amazon</a>]</li></ul><p>The wiring between the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a> and <a href="https://makersportal.com/shop/arduino-uno-r3-maker-portal">Arduino Uno board</a> is given below for SPI connection:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mk0zupIlhlg4aOLp_lbsUw.png" /></figure><p>We are using the Arduino Uno board, but any SPI board should work given that the wiring is correct and supplies enough power to the MFRC522. In the next section, the native RFID library shipped with the Arduino IDE will be used to test the MFRC522.</p><h4>Testing the Arduino RFID Library</h4><p>The Arduino IDE’s Library Manager has a widely used RFID library that is compatible with the MFRC522 chip. The library, conveniently titled <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a>, can be downloaded directly from the library manager and the user can get started right away with the many example scripts available to the Arduino platform. Below is a short sequence that outlines the procedure for downloading the MFRC522 library:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*KNzAxOfqtzgyxiw6dIBnHQ.png" /><figcaption>Navigate to the Library Manager. In the toolbar: Sketch -&gt; Include Library -&gt; Manage Libraries…</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*etQ9NP7srFU-3I56HByH-g.png" /><figcaption>Search for the MFRC522 Library. Install the MFRC522 library developed by the Github Community</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*NFmTKmBNR2SYl2AUjijrEQ.png" /></figure><p>Observe the Examples Available to the Selected Arduino Board (Uno in this case)</p><p>Navigate to File -&gt; Examples -&gt; MFRC522</p><p>We will be using these examples to read and write various information onto and from RFID cards with unique identifiers (UIDs).</p><p><strong><em>Info Dump Test from RFID Tag:</em></strong></p><p>The first checks we can do for verification of wiring, the Arduino library, and the validity of the RFID tags is to upload the “<strong>DumpInfo</strong>” code from the examples list. Upon uploading, assuming the wiring is correct and there are no errors, the user should place a tag within 4 inches of the MFRC522 scan area (the wave-like drawing on the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a> board) and look for a print out on the Arduino serial port that looks similar to the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*QCxT4XHZWI6K2sAob-yNdw.png" /><figcaption>Info Dump from RFID Tag. Notice the terminology of sectors and blocks. These will be discussed below.</figcaption></figure><p>We can see from the info dumpy that the tag we are using is a <strong>MIFARE 1KB</strong> tag, which we can quantify by the multiplication of 64 blocks x 16 bytes per block = 1024 = 1KB. This is a standard classic MIFARE tag, which are used in low-security systems such as public transportation, schools and universities, and employee office access.</p><p><em>Below is a great MIFARE Classic Resource:</em></p><blockquote><em>- “</em><a href="https://www.nxp.com/docs/en/data-sheet/MF1S50YYX_V1.pdf"><em>MIFARE Classic 1K-Mainstream contactless smart card IC for fast and easy solution development.</em></a><em>” Rev. 3.2–23 May 2018, by NXP.</em></blockquote><h3>In order to identify the terms printed above, we have compiled an explanation for each term based on the MIFARE document published by NXP:</h3><ul><li>PICC — Proximity Integrated Circuit Card (Contactless Card). This is the tag/card being used as the ‘access device.’</li><li>UID — Unique Identifier. This is the 4-byte (32-bit) ID given to each PICC (tag). Over 4.2 Billion IDs are available with the 4-byte ID system. The UID is usually stored in Sector 0, block 0 in the first four bytes.</li><li>SAK — Select Acknowledge. This is used for compliance checking under international standards.</li><li>Sector — A sector is partitioned into 4-blocks. There are a total of 16 sectors in each 1K MIFARE tag.</li><li>Block — A block is comprised of 16-bytes of data.</li><li>Access Bits — These control the read/write permissions for each block.</li></ul><p>There is also a detailed chart produced by NXP that explains many of the components printed by the Arduino code:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*oz1y5nnlbxvT6g6pYK0EPg.png" /><figcaption><strong>Courtesy of NXP, from </strong><a href="https://www.nxp.com/docs/en/data-sheet/MF1S50YYX_V1.pdf"><strong>MIFARE Classic EV1 1K</strong></a></figcaption></figure><p>There are a few more pieces of information contained in the chart above that we can use to comprehend the output from the Arduino serial monitor. From our serial printout, the Key B for our tag sectors are FF FF FF FF FF FF, which is somewhat of a manufacturer default for classic MIFARE tags. Additionally, the NXP document goes into the details of the relationship between keys and access bits, however, we will not spend time on that as it can get quite complex. One final note on the info dump — we can identify crucial information about each card based on the zeroth block of the zeroth sector, known as the manufacturer data. In our card printed above, we can see that the first four bytes of block 0 contains the UID of the card.</p><p>Using the table provided by NXP and the definitions above, we can identify a few key parameters for our specific tag (from the Arduino printout above):</p><ul><li>UID — CE 5B F4 3C</li><li>SAK — 08</li><li>Key B — FF FF FF FF FF FF</li></ul><p>In the next section, we will explore a few routines for altering these default values and seeing just how far we can push the customization of these RFID tags using the MFRC522 module.</p><h4>Customizing RFID Tags in Arduino</h4><p>We are going to attempt to change the Unique Identifier (UID) of each tag being placed in front of the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a> active area. The MFRC522 example code ‘<strong>ChangeUID</strong>’ allows us to do this by giving the user the power to change the UID to a custom 4-byte address. We’re going to change the address of the tag printed out in the previous section, to a completely random address of “F3 45 1B 0C” for testing. If we place the same tag in front of the MFRC522 scan area, we get the following output, which we can compare with the previous output:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*7zkZ-rfEtg-63CbcKCLDaQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*QCxT4XHZWI6K2sAob-yNdw.png" /></figure><p>We can see that the only information that changed was the first five bytes of the zeroth block of sector 0. The first four bytes have been changed to the desired UID, while the fifth byte appears to be either random or specified by the write action (we have not identified this byte designation in the library).</p><h3>NOTE: ONLY WRITABLE TAGS CAN HAVE THEIR UIDS CHANGED. THE WHITE CARDS WE ARE USING ARE WRITABLE, AND THUS CAN HAVE THEIR UIDS CHANGED. THE BLACK TAGS ARE READ-ONLY, AND WILL NOT ALLOW UID CHANGES (ARDUINO WILL NOTIFY THE USER OF THIS).</h3><p>We tried several times to write new UIDs to our black tags, but we were unable. This was expected, due to the specification of read-only, however, we figured an attempt wouldn’t hurt!</p><p><strong><em>Writing Data to RFID Tags</em></strong></p><p>Next, we’ll attempt to write specific data to each tag to see what information we can store. Each sector (except sector 0) has three available blocks for storing data (4-blocks per sector, minus 1 for keying). Thus, we can store up to 48 bytes of data in each sector. This can leads to the storing of names, dates, location information, product information — the possibilities are expansive. We can start with the example in the Arduino MFRC522 library called ‘<strong>rfid_write_personal_data</strong>’ which will ask the user to input a first and last name for storing in the Electrically Erasable Programmable Read-Only Memory (EERPROM), also known as the 16-sectors of data.</p><p>Upon opening the serial monitor after uploading ‘<strong>rfid_write_personal_data</strong>’ the user should place their RFID tag in front of the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a> active area. The serial monitor will ask for two inputs:</p><ol><li>Type Family name, ending with #</li><li>Type First name, ending with #</li></ol><p>The user must input a name followed by the # symbol. For example:</p><ul><li>Smith#</li><li>John#</li></ul><p>The resulting inputs will be saved in memory and should output the following if successful:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*Grg5_BZEwq5VTbqCp1rlTQ.png" /><figcaption>Successful Saving of First and Last Name to RFID Tag. In our case, we inputted Smith# and John#, which should output John Smith as the first and last name.</figcaption></figure><p>If we now upload the ‘<strong>rfid_read_personal_data</strong>’ we can see how the personal data is returned to us based on our inputs above:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*nJKQB4NG00yG-ThBT95w5Q.png" /></figure><p>And this verifies that our data is saved to the RFID tag. We can see how the data is saved by again returning to the “<strong>DumpInfo</strong>” example and looking at the output:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*-GMbEw991g4yMeEIx3ugnA.png" /><figcaption>Output of all 16 Sectors after saving first and last name. We can see that blocks 1,2 and 4,5 have changed, which is where the example code saved the personal data.</figcaption></figure><p>If we were to copy sector 1 and convert it from hex to UTF-8 characters, we get the following output:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*w-EKzA8Qvju4fmPmTFYJ6Q.png" /></figure><p>The same can be done for the first name as well (contained in sectors 4), though sector four contains carriage return and newline characters as the first two bytes. These two characters are due to the setting on our serial monitor (Both NL &amp; CR). If we change the line setting to “No line ending” this disappears and we just get “John” and “Smith” as outputs for sectors 1 and 4. Users can also verify the hex to UTF-8 values by inserting the hex output to a hex conversion website (such as: <a href="https://www.rapidtables.com/convert/number/hex-to-ascii.html">https://www.rapidtables.com/convert/number/hex-to-ascii.html</a>).</p><p><strong><em>RFID Resources:</em></strong></p><blockquote><em>- Want, Roy. “</em><a href="https://ieeexplore.ieee.org/abstract/document/1593568"><em>An introduction to RFID technology.</em></a><em>” </em>IEEE pervasive computing<em> 5.1 (2006): 25–33.</em></blockquote><h4>Conclusion and Continuation</h4><p>In this first entry of the RFID tutorial series with Arduino, the wiring, testing, and simple customization of RFID tags was introduced with the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522 RFID module</a>. The <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522</a> is read and controlled via SPI using an <a href="https://makersportal.com/shop/arduino-uno-r3-maker-portal">Arduino Uno board</a>, which has a dedicated Arduino library downloadable from the library manager. Several of the available examples were used to introduce and explore the basics of RFID with Arduino and understand some of the inner workings of the library and radio frequency identification as a technology. RFID terms such as sectors, blocks, and unique identifiers were discussed and used to understand some of the examples provided by the Arduino RFID library. Four different examples were used to test the various capabilities of the <a href="https://makersportal.com/shop/mfrc522-rfid-kit-for-arduino">MFRC522 module</a>, which involve changing the UID of writable RFID tags, dumping the information contained on all sectors of a tag, and writing/reading custom data from an RFID tag. This tutorial will be continued in upcoming tutorials, which further delve into customization of the data contained in an RFID tag.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68eacb2f8c2f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tiny OLED Display with the Raspberry Pi Pico]]></title>
            <link>https://medium.com/@joshhrisko/tiny-oled-display-with-the-raspberry-pi-pico-9f557baa7084?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f557baa7084</guid>
            <category><![CDATA[audio]]></category>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[makers]]></category>
            <category><![CDATA[raspberry-pi-pico]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Wed, 18 Aug 2021 18:10:13 GMT</pubDate>
            <atom:updated>2021-08-18T18:10:13.135Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8PoH51HM8-5_et_1sTiiDQ.jpeg" /></figure><p>In this tutorial, an SSD1306 organic light emitting diode (OLED) display will be controlled using the Pico microcontroller. A MicroPython library will be used as the base class for interfacing with the SSD1306, while custom algorithms are introduced to create data displays. Additionally, a custom Python3 algorithm will be given that allows users to show a custom image on the display. Lastly, a real-time plot will be created that shows an audio signal outputted by a MEMS microphone, emulating a real-time graph display. The SSD1306 is a useful tool for smaller scale projects that require real-time data displays, control feedback, and IoT testing. The power of the Pico microcontroller makes interfacing with the SSD1306 fast and easy, which will be evident when working with the Pico and SSD1306.</p><p>See introductory tutorials on the Raspberry Pi Pico, see the following:</p><ul><li><a href="https://makersportal.com/blog/raspberry-pi-pico-tests-with-micropython">An Introduction to the Raspberry Pi Pico with MicroPython</a></li><li><a href="https://makersportal.com/blog/ws2812-ring-light-with-raspberry-pi-pico">WS2812 LED Ring Light with Raspberry Pi Pico</a></li></ul><h4>Parts List and Wiring</h4><p>The <a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">Raspberry Pi Pico</a> microcontroller and <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306 OLED display</a> are the central components used in this tutorial, while a Raspberry Pi 4 computer is recommended for interfacing and programming on the Pico. A breadboard and some jumper wires will be helpful as well, and any sensor or motor that may be used in parallel with the SSD1306. The full parts list used to follow along with this tutorial is given below, with links:</p><ul><li>Raspberry Pi Pico Starter Kit — $15.00 [<a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">Our Store</a>]</li><li>SSD1306 OLED Display Kit — $12.00 [<a href="https://makersportal.com/shop/ssd1306-oled-display-kit">Our Store</a>]</li><li>Raspberry Pi 4 Computer — $58.99 (<a href="https://www.amazon.com/gp/product/B07TD42S27/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TD42S27&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=436c50b42ab3f24aecc78b51e5945cd2&amp;tag=engineersport-20">2GB</a>), $61.50 (<a href="https://www.amazon.com/gp/product/B07TC2BK1X/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TC2BK1X&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=f76aca80df8e78817da8f37eca8c453d&amp;tag=engineersport-20">4GB</a>), $88.50 (<a href="https://www.amazon.com/gp/product/B08R87H4RR/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08R87H4RR&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=4c0cce2b2eae1863b1112500b01079fa&amp;tag=engineersport-20">8GB</a>) [Amazon], $55.00 [2GB from <a href="https://makersportal.com/shop/raspberry-pi-4-computer">Our Store</a>]</li></ul><p>The wiring diagram between the Pico (see the <a href="https://makersportal.com/s/RPi_pico_pinout_white.jpg">Pico pinout</a> for reference) and SSD1306 display is given below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RWH2NwHESEoTn7KL16bKWw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DHTSrEx2dOj_RdgI8DY3oQ.png" /></figure><p>The SSD1306 is wired to one of the Raspberry Pi Pico’s I2C port. On the Pico, there are two different I2C ports: I2C0, I2C1. We are wiring to the I2C1 port via GPIO pins 26/27 (physical pins 31/32). Any of the I2C-compatible pins can be used with the SSD1306. We are using GPIO26/27 due to their proximity to the power and ground pins being used. In the next section, the SSD1306 MicroPython library will be introduced and used to create a simple Raspberry Pi logo and text, based on the Pico’s MicroPython SDK document.</p><h4>MicroPython SSD1306 I2C Library</h4><p>All of the codes used in this tutorial can be found at the project’s GitHub page:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*lwoRopFixKx1jrF7zBwTTA.png" /><figcaption><a href="https://github.com/makerportal/rpi-pico-ssd1306">https://github.com/makerportal/rpi-pico-ssd1306</a></figcaption></figure><p>Under the ‘micropython’ folder at the repository above there is a series of subfolders that contain examples that use the I2C MicroPython library that interfaces with the <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306</a>. The file called sssd1306.py is the actual SSD1306 library, which must be uploaded to the Pico upon running each example file. The ssd1306.py library is given below for reference:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4014b8d35822d3b7b55595262a7b0c54/href">https://medium.com/media/4014b8d35822d3b7b55595262a7b0c54/href</a></iframe><p>The library above is taken directly from the <a href="https://github.com/micropython/micropython/blob/master/drivers/display/ssd1306.py">MicroPython GitHub page</a>. The set of registers given at the top of the code above outline many of the commands used to control and interact with the SSD1306. The I2C port on the Pico carries out the commands that set the parameters relevant to the SSD1306, for example, the width, height, frequency, color mapping, etc. Going forward, the library will be used for each example but will not be referenced further. Instead, the examples will focus on applications of the library, such as displaying images, writing and coordinating text, inverting the display, among others.</p><h3>NOTE: THE SSD1306.PY AND MAIN.PY ARE BOTH REQUIRED WHEN CONTROLLING THE SSD1306 OLED DISPLAY WITH THE RPI PICO</h3><p>Minimum Requirements When Interfacing with the SSD1306 Display:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*K5eZFtOcO0dQtXFklXhqfg.png" /></figure><h4>Image Display on the SSD1306</h4><p>This section focuses on displaying an image and writing text next to the image at the same time. Two examples are given on the GitHub page, as follows:</p><ul><li><a href="https://github.com/makerportal/rpi-pico-ssd1306/tree/main/micropython/rpi_demo">Raspberry Pi Logo Display</a> — This is the Raspberry Pi Pico demonstration for the SSD1306. It displays the Raspberry Pi logo with the text ‘Raspberry Pi Pico’ displayed next to it</li><li><a href="https://github.com/makerportal/rpi-pico-ssd1306/tree/main/micropython/logo_display">Custom Logo Display</a> — This code displays a custom logo uploaded to ‘imgfile.py’ created by the custom Python3 script. Using an image, a Python3 script converts an image to a byte array. This byte array needs to be uploaded to the imgfile.py in bytearray() form. Then, the main script displays this image on the SSD1306.</li></ul><p>In this section, we focus on the custom logo display. Users can easily copy and paste and try the Raspberry Pi logo display. It is similar to the custom logo display, but uses the RPi logo.</p><p><strong>Preparing the Custom Logo for Display</strong></p><p>A custom .png image file should be placed in the ‘python3’ folder. Then, on a Raspberry Pi or other computer, the ‘png_to_bytearray.py’ script should be run. It will print out a custom bytearray():</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*Bzn7ek2z0OwK1P17bHkXug.png" /></figure><p>This is the image format that needs to be copied and pasted into the /micropython/logo_display/imgfile.py file:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*bZP514CNjhY1kHXPstY1qg.png" /></figure><p>The script also prints out the image resolution, which in our case is 64x64 pixels, which should also be updated into the main.py file. After copying the byte array above into the imgfile.py, run the main.py file and observe the newly printed logo on the <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306</a> display!</p><p>The text display has also been built out from the original Pico demonstration on the MicroPython SDK. The text display snippet is given below as an example (code can be found at the <a href="https://github.com/makerportal/rpi-pico-ssd1306/tree/main/micropython/logo_display">GitHub Page</a>):</p><pre>start_x = 75 # start point for text in x-dir<br>start_y = 12 # start point for text in y-dir<br>lineskip = 15 # space between text in y-dir<br>txt_array = [&#39;RPi&#39;,&#39;Pico&#39;,&#39;Demo&#39;]<br>for iter_ii,txt in enumerate(txt_array):<br>    oled.text(txt,start_x,start_y+(iter_ii*lineskip)) # add text at (start_x,start_y)<br><br>oled.show() # show the new text and image</pre><p>The snippet above takes a text array and places the text vertically in the display window. Depending on the starting x,y values and the skip between lines, the text will appear a certain way within the window. It’s a very simple placement of text, without any control over overflow (text past the window extents), text size, or vertical or horizontal centering.</p><p>An example output displaying one of our logos on the SSD1306 is given below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i0T7AqRywzeDH59sbyQN-g.jpeg" /></figure><h4>SSD1306 Real-Time Data Display with the Pico</h4><p>In this section, the limits of the <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306</a> were pushed by testing the display with a real-time signal. A MEMS microphone with analog output was selected as the time-varying signal to be read by the <a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">Pico microcontroller</a>. Then, the signal will be plotted on the OLED display in dot format. This emulates an audio signal and is capable of replicating the wave form of a signal in pseudo real-time. The speed of the ADC is fast enough for audio, which is read at high speed, then plotted when the OLED becomes available for refresh again. We were able to get update rates of roughly 15 Hz, or 15 refreshes per second.</p><p>For the data display in real time, we must first use the analog-to-digital converter to read a sensor. As stated above, a MEMS microphone was being used, however, any sensor that produces data in real time can be used. The data will be read using the follow snippet of code (full code <a href="https://github.com/makerportal/rpi-pico-ssd1306/blob/main/micropython/data_display/main.py">here</a>):</p><pre>adc_2 = machine.ADC(2) # ADC channel 2 for input<br>while True:<br>    oled.fill(0) # clear the display<br>    for jj in range(pix_res_x): # loop through horizontal display resolution<br>        adc_pt = adc_2.read_u16() # read adc and get 16-bit data point<br>        plot_pt = (adc_pt/((2**16)-1))*(pix_res_y-1) # convert to OLED pixels<br>        oled.text(&#39;.&#39;,jj,int(plot_pt)) # update x=jj with data point<br>    oled.show() # show the new text and image</pre><p>We are using the analog input pin #2, which correlates to physical pin #34 and GPIO28. Also, the snippet above loops through all 128 pixels on the horizontal display dimension and places a new data point from the ADC onto that point, thus, giving a real-time plot emulator. Of course, there will be a significant delay between each plot update, which is noticeable when using a high-speed input such as a microphone.</p><p>Below is a clip of the SSD1306 displaying a real-time wave of 250Hz outputted by a smartphone and being read by a MEMS microphone:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FPaSNKPYbMBc%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DPaSNKPYbMBc&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FPaSNKPYbMBc%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f5b30c292eb08292284989646db945ed/href">https://medium.com/media/f5b30c292eb08292284989646db945ed/href</a></iframe><p>The demonstration above really shows the capabilities of the <a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">Raspberry Pi Pico</a> and its ability to capture waveforms of a specific audio signal. Of course, users may want to add axes and labels to the plot for real-time analysis, however, the demonstration proves that the SSD1306 is a highly capable device and able to be integrated with the Pico microcontroller via MicroPython.</p><h4>Conclusion and Continuation</h4><p>In this third entry to the <a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">the Raspberry Pi Pico</a> microcontroller tutorial series, an <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306 OLED display</a> was interfaced via the I2C port of the Pico. A MicroPython library was introduced to control the SSD1306 display, along with a few scripts that display custom logos and real-time data plots. A separate Python3 program is given that allows users to create their own custom image to be displayed on the OLED. The real-time data display was able to refresh 128 data points at a rate of 15Hz (15 refreshes per second), which was capable of showing waveforms produced by an analog MEMS microphone. The <a href="https://makersportal.com/shop/ssd1306-oled-display-kit">SSD1306</a> is a useful tool for visualizations and printing out information related to sensors and modules — specifically when developing internet of things (IoT) nodes that wirelessly send and receive data or control motors and actuators. This tutorial was meant as a further exploration into the <a href="https://makersportal.com/shop/raspberry-pi-pico-starter-kit">Raspberry Pi Pico</a> microcontroller, with a focus on I2C communication. In the future of this series, more peripherals will be tested, such as SPI, UART, analog-to-digital conversion specifics, and even the capabilities of the dual-processor!</p><p>Find more tutorials at: <a href="https://makersportal.com/">https://makersportal.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f557baa7084" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Portable GPS Tracker with Arduino]]></title>
            <link>https://medium.com/@joshhrisko/portable-gps-tracker-with-arduino-3affead7ba12?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/3affead7ba12</guid>
            <category><![CDATA[gps]]></category>
            <category><![CDATA[arduino]]></category>
            <category><![CDATA[makers]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Sun, 15 Aug 2021 21:18:27 GMT</pubDate>
            <atom:updated>2021-08-15T21:18:27.022Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bvLYo0F1HezrW1DqUR0ltQ.jpeg" /></figure><p>At the inception of this project, I wanted to push the size limits of DIY portable GPS trackers with Arduino by selecting a mini GPS module called the ATGM336H. In the past, I’ve explored the NEO-6M GPS module with Arduino through a few Maker Portal tutorials (see: <a href="https://makersportal.com/blog/2018/5/9/comparing-iphone-gps-against-neo-6m-gy-gps6m-gps-module-with-arduino">“Comparing iPhone GPS Against NEO-6M with Arduino”</a> and <a href="https://makersportal.com/blog/2019/9/4/arduino-gps-tracker">“Arduino GPS Tracker”</a>). By opting for the ATGM336H in place of the NEO-6M, a pocket-sized GPS tracker is viable with a low-profile <a href="https://makersportal.com/shop/arduino-xiao-atsamd21-board">Arduino Xiao microcontroller</a>, <a href="https://makersportal.com/shop/arduino-compatible-micro-sd-card-module">SD Card Module</a>, and <a href="https://makersportal.com/shop/3-7v-600mah-lipo-battery-kit-for-arduino">3.7V LiPo Battery</a>. The prototype developed here will be an autonomous tracker that will record latitude/longitude at roughly 1–10 points per second (1Hz — 10Hz) and needs no external components to track geolocation. The prototype can fit in a users pocket and can track for several hours. I will also present a Python program that will plot the geolocation data points so that the user can view the route tracked by the Arduino GPS datalogger system. The Python analysis demonstrates how well the ATGM336H GPS module and antenna are able to replicate the walking path of a human with great resolution and accuracy.</p><h4>Parts List and Wiring</h4><p>The components used in this tutorial are fairly straightforward. We need a GPS module, a microcontroller that can read the GPS data, an SD module for saving data, and finally a battery to power the portable prototype. We are also using one of our component boxes that is roughly the size of a smartphone or thicker wallet. We are also using very low-profile jumper wires to ensure that the height of the prototype stays within the component box, along with a mini breadboard. We are also using a Raspberry Pi 4 computer to interface with the Arduino board. All components are listed below:</p><ul><li>Mini GPS Module + Antenna (ATGM336H) — $15.00 [<a href="https://makersportal.com/shop/mini-gps-module-atgm336h-antenna">Our Store</a>]</li><li>Arduino Xiao (ATSAMD21) Microcontroller — $15.00 [<a href="https://makersportal.com/shop/arduino-xiao-atsamd21-board">Our Store</a>]</li><li>SD Card Module — $8.00 [<a href="https://makersportal.com/shop/arduino-compatible-micro-sd-card-module">Our Store</a>]</li><li>3.7V LiPo Battery Kit — $15.00 [<a href="https://makersportal.com/shop/3-7v-600mah-lipo-battery-kit-for-arduino">Our Store</a>]</li><li>Component Box — $3.00 [<a href="https://makersportal.com/shop/electronics-component-box">Our Store</a>]</li><li>Mini Breadboard — $3.00 [<a href="https://makersportal.com/shop/mini-breadboard">Our Store</a>]</li><li>Mini Jumper Wires — $10.49 (560pcs) [<a href="https://www.amazon.com/gp/product/B07CJYSL2T/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07CJYSL2T&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=8b906ca99e01786fb9e3b9bb52da1b61&amp;tag=engineersport-20">Amazon</a>]</li><li>Raspberry Pi 4 Computer — $69.99 (4GB) [<a href="https://www.amazon.com/gp/product/B07TC2BK1X/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B07TC2BK1X&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=c901d38290b6e3aa093ba57240409918&amp;tag=engineersport-20">Amazon</a>], $119.99 (8GB Kit) [<a href="https://www.amazon.com/gp/product/B08956GVXN/ref=as_li_qf_asin_il_tl?creative=9325&amp;creativeASIN=B08956GVXN&amp;ie=UTF8&amp;linkCode=as2&amp;linkId=8bdd7ce463d01b19ad6634d804b4e7ee&amp;tag=engineersport-20">Amazon</a>]</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*syvv815-eo_JRvsohjkCmA.jpeg" /><figcaption><a href="https://makersportal.com/shop/mini-gps-module-atgm336h-antenna">Mini GPS Module for Arduino (ATGM336H + Antenna)</a></figcaption></figure><p>The pinout for the Arduino Xiao board is given below as a reference before the full wiring diagram is shown:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*45G_IpLIkEYGeW38sHFl_w.png" /><figcaption>ATSAMD21 Board Pinout Diagram</figcaption></figure><p>The SD module is wired to the Xiao via SPI (MISO, MOSI, SCK, etc.), while the ATGM336H GPS module is wired via serial (UART). The wiring diagram is given below, followed by the pinout wiring table:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R5JQSqV0wpE7pXdscOxmYA.jpeg" /><figcaption>Wiring diagram for portable Arduino GPS datalogger</figcaption></figure><p>The wiring table is given below for each component wired to the ATSAMD21 microcontroller:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1j58dZGap7wDMnf9XE0V8g.jpeg" /></figure><p>Note the connection of the 3.7V LiPo battery to the 5V input. This ensures that the power give to the other modules is regulated down to 3.3V. We have also randomly chosen the CS pin for the SD module, any other available pin could be chosen for the chip select (CS). Similarly, the GPS serial TX/RX pins can be randomly selected, as long as they correspond to the pins defined in the Arduino software serial implementation. Below, we will be using the wiring given in the table above, so be sure to keep the wiring as outlined above when testing the codes in the next section.</p><h4>Arduino GPS and Datalogger Code</h4><p>The Arduino code used to acquire GPS data from the ATGM336H module requires the TinyGPSPlus library given at the link below:</p><blockquote><a href="https://github.com/mikalhart/TinyGPSPlus"><em>https://github.com/mikalhart/TinyGPSPlus</em></a></blockquote><p>To install the TinyGPSPlus library, clone it from the GitHub link above, unzip it, rename the folder to “TinyGPSPlus” and then move it to the “libraries” folder in your Arduino directory. This will make the GPS parser library available to the Arduino IDE, visible as “TinyGPS++” to the user.</p><p>Next, the user can navigate to the GitHub directory for this project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m8o50uVVXeGTHsngQDT-sA.png" /><figcaption><a href="https://github.com/makerportal/arduino-gps-datalogger">https://github.com/makerportal/arduino-gps-datalogger</a></figcaption></figure><p>The GitHub directory contains the datalogger code used to acquire and save GPS coordinates onto the SD card. The Arduino GPS datalogger code is given below for reference:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/068fc8602cf2a0fc051d1f82a2a78158/href">https://medium.com/media/068fc8602cf2a0fc051d1f82a2a78158/href</a></iframe><p>In the above code, we are first defining pin 6 as the chip select (CS) pin, as prescribed in the wiring diagram above. Second, the data filename is given as “gpsLog.csv” — there is a limit to the length of the filename, based on the SD library. So be sure to keep the filename as minimal as possible, and avoid using certain characters (we have had trouble in the past with underscores and long filenames).</p><p>Next, we are defining GPS module parameters, with pins 1/2 as the TX/RX pins, respectively. The baudrate is set as 9600, which is the default for the ATGM336H (in contrast to other modules that start at 4800).</p><h3>NOTE: IN THE SETUP FUNCTION WE ARE DELETING THE OLD GPS LOG FILE. THIS SHOULD BE COMMENTED OUT TO APPEND TO THE FILE OR A ROUTINE SHOULD BE DEVELOPED THAT HANDLES FILE CREATION DYNAMICALLY TO AVOID DELETION AND OVERWRITING.</h3><p>The final line of the setup function creates a header that we can use to identify the data configuration once we open the file later for post processing. We expect the header and data configuration to be as described below:</p><blockquote><em>“Date [mm/dd/yyyy], Time [HH:MM:SS.ZZ], Latitude [deg], Longitude [deg]”</em></blockquote><p>This means we will have a data array saved as Date, Time, Latitude, Longitude. We are saving the data in comma-separated value (CSV) format, so we expect parsing of the data to be very simple.</p><p><strong>It may also be of importance to note that once the system is powered on for the first time, it can take 30 seconds for the GPS module to fix to the required number of satellites and return a valid geolocation point. This may also be extended if the user is starting the module indoors or in a city with tall buildings.</strong></p><p>A final note on the Arduino code: we are only using the basic components of geolocation, date, time, latitude, and longitude. The GPS library also allows users to access speed, altitude, directionality, and other parameters. So if the user wants to add those, they can do so in the main if() call in the void loop() function:</p><pre>if (gps.encode(ss.read()) &amp;&amp; gps.location.isValid() &amp;&amp; gps.date.isValid() &amp;&amp; gps.time.isValid()){<br>      String data_to_save = &quot;&quot;; <em>// data string for saving</em><br>      data_to_save += String(gps.date.month())+&quot;/&quot;+String(gps.date.day())+&quot;/&quot;+<br>                      String(gps.date.year())+&quot;,&quot;;<br>      data_to_save += String(gps.time.hour())+&quot;:&quot;+String(gps.time.minute())+&quot;:&quot;+<br>                      String(gps.time.second())+&quot;.&quot;+String(gps.time.centisecond())+&quot;,&quot;;<br>      data_to_save += String(gps.location.lat(),8)+&quot;,&quot;; <em>// latitude</em><br>      data_to_save += String(gps.location.lng(),8); <em>// longitude</em><br>      <br>      <em>// add other parameters to data_to_save here...</em><br><br>      data_saver(data_to_save); <em>// save new data points</em><br>    }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4p_6AjeQO-ckZfp8JoelMg.jpeg" /><figcaption>Photo of the portable GPS datalogger</figcaption></figure><p>For our experiment, we walked up and down roughly 5 blocks along the streets of San Francisco. In the next section, we will see how well the GPS tracker was able to follow our path along the walk by implementing a Python csv reader algorithm that maps the coordinates to an open street map (OSM).</p><h4>Visualizing the GPS Data in Python</h4><p>A popular geographic visualization toolbox called ‘<a href="https://scitools.org.uk/cartopy/docs/latest/">cartopy</a>’ will be used to plot the geographic coordinates onto the Google Open Street Map template. We previously wrote a blog post introduction to cartopy: “<a href="https://makersportal.com/blog/2020/4/24/geographic-visualizations-in-python-with-cartopy?rq=cartopy">Geographic Visualizations in Python with Cartopy</a>.” We will be jumping right into implementations with cartopy, so be sure to have the package installed and working before attempting to follow along below.</p><p>The first step is to take the GPSLOG.CSV file from the SD card and copy it into the local Python script folder. This will allow us to access it directly in the Python code. The full Python code is given below for reference, and it is also on the <a href="https://github.com/makerportal/arduino-gps-tracker">project’s GitHub page</a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2997330df639340317e170dbb5a65adb/href">https://medium.com/media/2997330df639340317e170dbb5a65adb/href</a></iframe><p>The code above will technically animate the GPS points onto a street map. The final plot should look similar to the one below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vyev0tcQfqyYplY9BKs2oA.png" /></figure><p>Running the script should result in an animation similar to the one shown below, which “walks” through the points in steps of 10 (to speed things up):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*-_FRVKSrwxQ6CPgjbssF1A.gif" /><figcaption>GPS Tracker Map Animation</figcaption></figure><p>In our case, the tracking was very accurate, to within a few feet. The specification of the ATGM336H GPS module is within 2.5m, so we are well within that limit. A few notes on the performance and expectations:</p><ul><li>The Arduino code saves data points at an unspecified rate. This means that we may get 10 points at one moment, and 1 at another moment.</li><li>In our case, we were surrounded by buildings, so there is more fluctuation than there would likely be in a more open space.</li><li>When going from outdoors to indoors, things can fluctuate quite a bit due to interference.</li><li>We are using a small antenna for the ATGM336H (to keep the geometry minimal). The antenna can also be replaced with the larger square ceramic antennas (the ones commonly shipped with NEO-6M modules). We hypothesize that this will result in better performance overall, at the trade-off of larger geometry and weight.</li><li>We noticed that when starting the system indoors, it took quite a bit of time to get a reliable signal. However, once the signal was established, even after restarting the system, it was able to re-connect to the satellites and return valid coordinates fairly quickly.</li></ul><h4>Conclusion</h4><p>The ATGM336H mini GPS module was demonstrated here as an alternative to the larger NEO-6M module and proved to be a competitive choice for a lower profile GPS tracker with Arduino. The ATGM336H worked nicely with the TinyGPS++ library and had no trouble tracking our walking path at fairly high temporal and spatial resolution. The goal of this project was to prototype a GPS tracker that can fit inside a regular pants pocket with widely available components. Using the ATGM336H, an ATSAMD21 microcontroller, SD module, and LiPo battery, we were able to achieve this. Of course, this is just the prototype phase and the system could be shrunk down to half its current size, if not smaller than that! We image that realistically, a tracker like this can fit in a form factor of a smartwatch or even smaller. We were able to prototype with the aforementioned components and plot them to verify the accuracy of the GPS tracker, all while it was placed inside our pocket. In just a few minutes, users can replicate this project and have a modular GPS tracker in the palm of their hand!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3affead7ba12" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Haptic Feedback Joystick with Arduino]]></title>
            <link>https://medium.com/@joshhrisko/haptic-feedback-joystick-with-arduino-a073a2a34c84?source=rss-10a819574515------2</link>
            <guid isPermaLink="false">https://medium.com/p/a073a2a34c84</guid>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[haptics]]></category>
            <category><![CDATA[makers]]></category>
            <category><![CDATA[arduino]]></category>
            <category><![CDATA[electronics]]></category>
            <dc:creator><![CDATA[Joshua Hrisko]]></dc:creator>
            <pubDate>Tue, 10 Aug 2021 19:04:12 GMT</pubDate>
            <atom:updated>2021-08-10T19:05:42.452Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tvyQ2gybpJFIYRpfNHUSrA.jpeg" /></figure><p>Haptics in the context of modern technology refers to the interaction between human touch and responses provided by computer interfaces in an attempt to emulate real-world stimuli. The real-world stimuli can be auditory, physical, or visual. For example, in the case of haptic vibration, a motor can provide feedback to users as they experience shaking due to driving, explosions, or physical contact while playing a video game [learn more about haptics <a href="https://ieeexplore.ieee.org/abstract/document/844146">here</a> and <a href="https://link.springer.com/article/10.1007/s10845-009-0277-7">here</a>]. In this tutorial, we design and explore haptic vibrational feedback due to movements of an analog joystick. The Arduino platform will be used to read the analog joystick and control the response of a vibration motor shaking in the user’s hand. An <a href="https://makersportal.com/shop/esp32-d1-mini-bluetoothwifi-board">ESP32 D1 Mini microcontroller</a> is selected as the microcontroller that will be programmed to control the haptic response. The ESP32 is chosen due to its fast processor, which will decrease the time delay between joystick reading and the haptic feedback response. The goal of this tutorial is to introduce users to haptic feedback and the interplay between humans and computer interfaces capable of responding to touch inputs.</p><h3>Parts List and Wiring</h3><p>The components used in this tutorial have been compiled into a <a href="https://makersportal.com/shop/haptic-vibration-joystick-kit">kit</a> for convenience, which consists of the ESP32 D1 Mini microcontroller, the analog joystick, the vibration motor, and the 3D printed handheld enclosure. We’ve also listed the components one-by-one below in the event that the user has all or most of the components already at their disposal. The component list is also followed by the wiring diagram for the tutorial.</p><ul><li>Haptic Joystick Kit — $25 [<a href="https://makersportal.com/shop/haptic-vibration-joystick-kit">Our Store</a>]</li></ul><p>Individual Component List:</p><ul><li>ESP32 D1 Mini — $14.00 [<a href="https://makersportal.com/shop/esp32-d1-mini-bluetoothwifi-board">Our Store</a>]</li><li>Vibration Motor — $3.00 [<a href="https://makersportal.com/shop/vibration-motor-module-for-arduino">Our Store</a>]</li><li>Analog Joystick — $5.00 [<a href="https://makersportal.com/shop/analog-joystick-arduinoraspberry-pi-compatible">Our Store</a>]</li><li>Male-to-Female Jumper Wires — $1.20 (8pcs) [<a href="https://makersportal.com/shop/jumper-wires">Our Store</a>]</li></ul><p>The pinout for the ESP32 D1 Mini is given below for reference, in the case that users want to change pins for the joystick or motor, or even add more sensors or motors to the project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/696/1*_7LHf97AtcD7ZMd6XWek5Q.png" /><figcaption>Image courtesy of: <a href="https://github.com/r0oland/ESP32_mini_KiCad_Library">https://github.com/r0oland/ESP32_mini_KiCad_Library</a></figcaption></figure><p>Lastly, the wiring diagram between the ESP32 D1 Mini and the vibration motor and joystick is given below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zh1kODufWKKWDM-88jWC3Q.png" /><figcaption>Wiring diagram for: ESP32 D1 Mini, vibration motor, and joystick</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*mPdMi2H4HIhmpOuW3Z_zOQ.png" /><figcaption>Component Wiring Table — ESP32 + Joystick + Vibration Motor</figcaption></figure><p>The wiring configuration given above is used in the Arduino codes provided in the next section. Thus, any changes made to the wiring diagram will need to be implemented in the subsequent Arduino codes.</p><h3>Haptic Joystick Code with Arduino</h3><p>The Arduino code used in conjunction with the wiring configuration provided above can be found at the project’s GitHub page:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s96j_SXIsFMgEN-bQdcebA.png" /><figcaption><a href="https://github.com/makerportal/haptic-joystick">https://github.com/makerportal/haptic-joystick</a></figcaption></figure><p>The code is also given below for reference:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/507ae42ffb692621aaf6260d5bbd9fb3/href">https://medium.com/media/507ae42ffb692621aaf6260d5bbd9fb3/href</a></iframe><p>The Arduino code carries out the following:</p><ol><li>Sets the analog joystick pins as inputs (analog inputs on pins 34/35, and digital input on pin 14)</li><li>Sets digital pin 2 as a digital output for the vibration motor</li><li>Reads offset values from the joystick (for centering response from -0.5 to +0.5, rather than 0–1)</li><li>Reads joystick inputs (Rx, Ry, SW)</li><li>Excites the vibration motor based on the Rx, Ry, SW values</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RSh-rQ8hy-uXHo_z7ZZs_Q.jpeg" /></figure><h3><strong>Haptic Vibration Responses from the Joystick</strong></h3><p>Now we can test the haptic responses of the vibration motor based on the joystick movements. First, moving the joystick to the left results in a constant vibration, which we have prescribed in the function ‘buzz_now()’ — which contains the specific response of the vibration motor controlled by the ESP32 microcontroller. The following breaks down the if() statement in the loop() above, telling us what happens when the joystick is moved to given positions:</p><pre>(Rx&lt;-0.1)<br>    buzz_now(1,100,0,0); // (joystick left) buzz without delays</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3xOkf4938tXkJ38z3ydE6Q.png" /><figcaption><em>Joystick Left </em>←<em>: Constant Motor Vibration</em></figcaption></figure><pre>(Ry&lt;-0.1)<br>    buzz_now(2,100,100,0); // (joystick down) buzz on/off equally for 100ms</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ouMvqcVUc3SQ8kPQJ1ffw.png" /><figcaption><em>Joystick Down </em>↓<em>: 200ms delay between vibrations (~300BPM)</em></figcaption></figure><pre>(Rx&gt;0.1){<br>    buzz_now(1,600,200,0); // (joystick right) long buzz 600ms on, 200 off</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e4BXKOBwGXAr5Rfdw9G96g.png" /><figcaption><em>Joystick Right </em>→<em>: Heavy vibration with a short off delay</em></figcaption></figure><pre>(Ry&gt;0.1){<br>    buzz_now(3,80,80,150); // (joystick up) buzz with &#39;train&#39; style rhythm</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vJQvN78YdjOBup3535Ma3Q.png" /><figcaption><em>Joystick Up </em>↑<em>: Three pulses with a train-like momentum</em></figcaption></figure><pre>(SW==0){<br>    buzz_now(2,150,150,300); // (joystick press) heartbeat rhythm (dual buzz, with delay)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zDm8HYZvENvHDL184m081w.png" /><figcaption><em>Joystick Press: Dual pulse similar to heart beat</em></figcaption></figure><p>These different haptic vibration feedback profiles can be customized to fit the user’s desired application, whether it relates to buzz length or buzz number or delay between buzzes — it’s completely customizable down to the resolution of the vibration motor. For the motor used here, we’re able to buzz on/off within about 50–80ms, which is likely the limit of the hardware. Delays smaller than 50ms tend to blend together as one buzz. The user may want to change the number of buzzes to relate to cardinal directions, or even change the delay between buzzes based on navigational accuracy (longer delay for further away, shorter delay for closer). There are many opportunities available to the user based on customization and desired outcome!</p><p>Below is a video demonstration of our haptic joystick for the different joystick movements. Make sure to turn on audio to hear the buzzes created by the vibration motor:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FJ54N7E41rwE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DJ54N7E41rwE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FJ54N7E41rwE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/589b76e9fdeed34fbcc8d4fc7c406a5a/href">https://medium.com/media/589b76e9fdeed34fbcc8d4fc7c406a5a/href</a></iframe><h3>Conclusion</h3><p>A vibration motor and joystick were used to create a haptic feedback device using the Arduino platform (get the kit <a href="https://makersportal.com/shop/haptic-vibration-joystick-kit">here</a>). As a response to specific changes in joystick position, we prescribed vibration motor actions corresponding to the movement of the joystick. This allowed us to create haptic vibration feedback similar to those used in video games and virtual reality systems. The goal of this tutorial was to introduce users to haptic technology that can immerse users into the digital world using physical feedback mechanisms, such as vibration. Different tunings of the vibration motor can provide users with instructions based on their input, which makes this type of application useful for enhancing digital media, as referenced above, or situations such as visually impaired navigation, feedback in auditory-restricted environments, and delivering quiet notifications to users. Haptics can be incredibly useful in emulating the real world and immersing users into scenarios that may otherwise be dangerous or difficult to experience. Vibrational haptic feedback is just one of a series of haptic mechanisms, and this tutorial was just a simple entry into a wide ranging and evolving field of human computer interaction.</p><p><em>See more tutorials at: </em><a href="https://makersportal.com/"><em>https://makersportal.com</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a073a2a34c84" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>