<?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 Adam Joaquin Girsang on Medium]]></title>
        <description><![CDATA[Stories by Adam Joaquin Girsang on Medium]]></description>
        <link>https://medium.com/@bacotanadam?source=rss-dab126377ed9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*u8ktftZN4ctAdJBD48c4UQ@2x.jpeg</url>
            <title>Stories by Adam Joaquin Girsang on Medium</title>
            <link>https://medium.com/@bacotanadam?source=rss-dab126377ed9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 17:22:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bacotanadam/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[33x dan Jalan yang Kembali]]></title>
            <link>https://medium.com/@bacotanadam/33x-dan-jalan-yang-kembali-29bc277a7b56?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/29bc277a7b56</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 17:47:29 GMT</pubDate>
            <atom:updated>2026-03-04T17:50:28.708Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*raMsrOVxWr9SGhwmCXoLGw@2x.jpeg" /></figure><p>Ada lagu yang tidak sekadar didengar. Ia menunggu di pengujung hari yang lelah, lalu menyapa pelan seperti seseorang yang kenal saya sejak lama.</p><p>Bagi saya, lagu itu adalah “33x” dari Perunggu.</p><p>Saya seorang Kristiani. Tapi anehnya, ada musim ketika saya lebih sering mendengar playlist daripada doa, lebih hafal lirik daripada ayat. Gereja terasa seperti alamat lama, masih saya simpan, tapi jarang saya datangi. Lalu suatu malam, “33x” berputar tanpa sengaja.</p><p>Saya mulai datang lagi ke gereja. Awalnya karena ingin. Lalu karena butuh.</p><p>Di sana saya sadar, yang membawa saya kembali bukan sekadar lagu, bukan suasana, bukan bahkan keputusan saya sendiri. Ada tangan yang lebih sabar dari niat saya yang sering goyah. Ada kasih yang tidak lelah mengetuk, bahkan ketika saya pura-pura tidak dengar.</p><p>Kuasa Tuhan tidak selalu datang dalam bentuk yang megah. Kadang Ia menyelip di antara distorsi gitar dan lirik yang terasa terlalu dekat dengan dada. Kadang Ia memakai sesuatu yang tidak kita duga, untuk membawa kita pulang.</p><blockquote>Kelak kau ‘kan mengingat</blockquote><blockquote>Yang membawamu ke sini</blockquote><p>“33x” bukan lagu rohani bagi saya.</p><p>Ia tidak mengutip ayat.</p><p>Ia tidak menyebut nama yang biasa saya sebut dalam doa.</p><p>Namun justru lewat ketidaksamaannya, saya disadarkan bahwa kasih tidak selalu datang dengan label yang saya kenal. Kadang ia datang dengan istilah lain, dengan tradisi lain, dengan irama yang berbeda, hanya untuk membuktikan bahwa saya ini yang sering kali lupa, bukan Dia yang berhenti memanggil.</p><blockquote>Sebutlah nama-Nya</blockquote><blockquote>Tetap di jalan-Nya</blockquote><blockquote>Kelak kau mengingat</blockquote><blockquote>Kau akan teringat</blockquote><p>Ada sesuatu dari pengulangan itu yang terasa seperti penunjuk arah. Bukan memaksa, bukan menuntut, hanya mengingatkan bahwa ada jalan yang pernah saya pilih, lalu saya tinggalkan tanpa sadar.</p><p>Jika suatu hari nanti saya kembali jauh, mungkin Tuhan tidak akan berteriak.</p><p>Mungkin Ia hanya akan memutar lagu lain.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29bc277a7b56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Do I Let What Happened in the Past Bother Me?]]></title>
            <link>https://medium.com/@bacotanadam/why-do-i-let-what-happened-in-the-past-bother-me-6ede2a3cfd84?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ede2a3cfd84</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Tue, 10 Feb 2026 10:19:14 GMT</pubDate>
            <atom:updated>2026-02-10T10:19:14.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WZ801Z2DIwivk6_p" /></figure><p>I find myself replaying old memories like a movie stuck on loop. A conversation from five years ago. A mistake I made in school. A relationship that didn’t end the way I hoped. They resurface not as gentle reminders, but as sharp echoes that sting just as much as they did back then.</p><p>Why does the past still bother me?</p><blockquote><strong>The short answer: because I care.</strong></blockquote><p>But if you’d asked me on a deeper level: because the past is where my identity was shaped both by the choices I made and the ones made for me. Regret, shame, and guilt are powerful emotions. They stick around not because I’m weak, but because something about those moments still feels unresolved. Maybe I wish I had spoken up. Maybe I wish I had walked away. Maybe I just wanted someone to understand….</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ede2a3cfd84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Still Wake Up Each Morning]]></title>
            <link>https://medium.com/@bacotanadam/why-i-still-wake-up-each-morning-92fd8c16b418?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/92fd8c16b418</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Tue, 09 Sep 2025 21:17:47 GMT</pubDate>
            <atom:updated>2025-09-09T21:27:09.835Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mfAVAWnfVPcNarQ5_D-X-Q@2x.jpeg" /></figure><p>I questioned myself: What’s even the point of existing now?</p><p>A restless mind, a heart pierced every moment, and problems that never seem to end.</p><p>Sometimes I think I only have myself. True or not, there is still one thing I know I have in life: God.</p><p>I realize He has always been there for me. But have I truly given Him control over my life?</p><p>Humans are born as praying beings, yet never pure. I used to believe I could face each day on my own, through my strength, through the support of my friends, through the love of my parents. What I failed to see was that, at the core, we all belong to God.</p><p><strong>When I relied only on myself and on other people, my life lost its direction, it fell apart.</strong></p><p>I need someone greater than myself, someone higher, who can lead this flawed, broken life of mine, just as every human secretly longs for guidance. But I cannot find that in humans. Because in the end, we are all equal. We are all sinners. We are all fragile.</p><p>I need a Greater Entity.</p><p>O God, please help me. Please lead my life. Please be the captain of my ship.</p><p>And again, I ask: What’s the point of even existing?</p><p>Slowly, I begin to realize: no matter how heavy the burden, no matter how shattered my days may feel</p><p>As long as God still wakes me up each morning, perhaps He has something left for me to do. Maybe it is as simple as supporting the food vendor I buy from every day. Maybe it is helping the beggar I met last night with a small act of kindness.</p><p>Or maybe it is simply this: a chance to rebuild my own life into something better.</p><p>O God, forgive me.</p><p>O God, forgive me.</p><p>O God, forgive me.</p><p>O God, forgive me.</p><p>O God, lead me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92fd8c16b418" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Life is All About Gambling, Isn’t It?]]></title>
            <link>https://medium.com/@bacotanadam/life-is-all-about-gambling-isnt-it-0a995da77caf?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a995da77caf</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Sat, 16 Aug 2025 14:54:20 GMT</pubDate>
            <atom:updated>2025-08-16T14:54:20.733Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9G8vCEPMzEMNqJ4t" /></figure><p>They say life is a series of choices. Some are safe, predictable, with guaranteed returns. Others… are a little riskier.</p><p>The thing about risks is you never really know until you place your bet. You can read the room, weigh the odds, predict the perfect move. But when it’s your turn, there’s only one way to find out: step in, show your hand, and let the cards fall where they may.</p><p>It’s strange how the most important gambles aren’t about money. They’re about people. A glance across the room, a smile that lingers, a conversation that could go nowhere, or everywhere.</p><p>The mind always whispers, <em>What if it doesn’t work?</em></p><p>But it also whispers, <em>What if it does?</em></p><p>And sometimes that quiet, fragile possibility is louder than all the reasons to stay still.</p><p>And yes, there’s a chance you’ll lose. A chance she’ll turn away, or simply not feel the same. But there’s also a chance she’ll lean in. And if you never try, you’ll never know which it is.</p><p>Maybe that’s why we gamble at all. Not because we’re sure we’ll win, but because the thrill of possibility is worth the risk.</p><p>So I’ll take my chance. I’ll walk over. And I’ll let life deal the rest.</p><p>One thing for sure, I will never fold.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a995da77caf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tentang Jarak yang Tak Pernah Diumumkan]]></title>
            <link>https://medium.com/@bacotanadam/tentang-jarak-yang-tak-pernah-diumumkan-af4b068c8a9d?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/af4b068c8a9d</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Thu, 19 Jun 2025 16:35:22 GMT</pubDate>
            <atom:updated>2025-06-19T16:46:12.920Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NkBHZWIXETVl1jYT50DvCQ@2x.jpeg" /></figure><p><em>Akhir-akhir ini, saya sering memperhatikan cara orang berjalan.</em></p><p>Ada yang berjalan berdampingan, ada yang menjaga jarak. Yang menarik, ada pula yang diam-diam menepi — seperti berusaha tidak terlihat, tetapi tetap berharap untuk dilihat. Lucu, ya, bagaimana seseorang bisa begitu dekat dan begitu jauh dalam waktu yang bersamaan.</p><p>Hari-hari terus bergulir, dan saya mulai menghitung keheningan yang terlalu panjang dalam beberapa percakapan. Beberapa sapaan dibalas seadanya. Beberapa tatapan tidak sempat bertemu. Saya mulai menebak-nebak: kabar apa yang sebenarnya sedang mereka simpan?</p><p>Padahal, saya merasa tidak berubah. Namun, mungkin justru itu masalahnya — terlalu yakin bahwa tidak ada yang perlu diubah. Atau, bisa jadi, ada hal-hal yang tanpa sadar telah bergeser. Entah dari cara saya merespons, entah dari hal-hal yang saya lewatkan begitu saja. Atau barangkali, mereka memang merasa lebih nyaman di tempat lain. Dan hal itu sah-sah saja, bukan?</p><p><strong>Yang paling membingungkan mungkin adalah diam.</strong></p><p>Diam yang bukan karena tidak tahu harus berkata apa, melainkan diam yang seolah telah disepakati. Seperti ada sesuatu yang hanya dibicarakan di luar jangkauan telinga ini. Seperti ada versi diri saya yang hanya hidup dalam ruang-ruang cerita yang tidak pernah saya hadiri.</p><blockquote>Ada masanya kita ingin tahu, tetapi lebih takut mendengar jawabannya.</blockquote><p>Ada masanya kita berharap orang-orang menjelaskan, namun sadar bahwa tidak semua orang ingin jujur. Bukan karena mereka jahat, mungkin karena mereka pun bingung. Dan itu pun, pada akhirnya, perlu dimaklumi.</p><p>Maka dari itu, saya memilih diam. Bukan diam yang menyerah, tetapi diam yang mendengarkan.</p><p>Barangkali, dalam diam itu saya bisa memetakan ulang: siapa yang benar-benar bertahan karena ingin, bukan karena kebiasaan.</p><p>Lagipula, jarak tidak selalu soal benci. Kadang, ia hanyalah cara dunia memberi tahu:</p><p>waktunya memperhatikan langkah sendiri terlebih dahulu, sebelum mencari tangan yang kembali bisa digenggam.</p><p>// Mulai ditulis pada 27 Mei 2025 dan selesai ditulis pada 19 Juni 2025</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af4b068c8a9d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ESP32: Project #7 — Web Server]]></title>
            <link>https://medium.com/@bacotanadam/esp32-project-7-web-server-fde255b18e1a?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fde255b18e1a</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Mon, 05 May 2025 13:51:36 GMT</pubDate>
            <atom:updated>2025-05-06T14:46:53.103Z</atom:updated>
            <content:encoded><![CDATA[<h3>ESP32: Project #7 — Web Server</h3><p>II2260 : Internet Of Things — Adam Joaquin Girsang — 18223089</p><h3>Latar Belakang</h3><p>Perkembangan teknologi Internet of Things (IoT) memungkinkan berbagai perangkat elektronik untuk saling terhubung dan berkomunikasi melalui jaringan internet. Salah satu teknologi yang sering digunakan dalam pengembangan sistem IoT adalah mikrokontroler ESP32. Mikrokontroler ini memiliki fitur WiFi dan Bluetooth bawaan, serta cukup kuat untuk menjalankan berbagai aplikasi IoT dengan konsumsi daya yang rendah dan biaya yang relatif murah.</p><p>Tradisionalnya, web server dijalankan di komputer dengan spesifikasi tinggi dan memerlukan infrastruktur server yang kompleks. Namun, dengan kemajuan teknologi, kini web server sederhana dapat dibangun langsung di atas mikrokontroler seperti ESP32. Hal ini membuka peluang baru untuk menciptakan sistem monitoring dan pengendalian yang efisien, portabel, dan hemat biaya.</p><p>Pada project ini, mahasiswa membangun sistem pengawasan dan pengendalian ruangan berbasis web server menggunakan ESP32. Sistem ini dirancang untuk memantau suhu ruangan dan mengontrol kipas angin secara jarak jauh. Sensor temperatur yang terhubung ke ESP32 akan membaca suhu lingkungan dan mengirimkan datanya ke web server yang dapat diakses melalui browser. Selain itu, user juga dapat mengendalikan kipas angin (yang dimodelkan dengan LED) dari jarak jauh melalui antarmuka web.</p><p>Dengan implementasi ini, mahasiswa dapat memahami konsep dasar komunikasi client-server, pemrograman mikrokontroler berbasis web, serta penerapan sistem IoT untuk otomasi dan pengawasan jarak jauh.</p><h3>Hal yang perlu dipersiapkan</h3><ul><li>Breadboard</li><li>ESP32</li><li>Male to Male Jumper Cable</li><li>Female to Male Jumper Cable</li><li>LED</li><li>Sensor AHT120 + BMP280</li><li>Resistor</li></ul><h3>Kode</h3><pre>/*********<br>  Rui Santos<br>  Complete project details at https://randomnerdtutorials.com  <br>*********/<br><br><br>#include &lt;WiFi.h&gt;<br><br>#include &lt;Wire.h&gt;<br><br>// Replace with your network credentials<br>const char* ssid = &quot;ADAM GANTENG&quot;;<br>const char* password = &quot;adam1234&quot;;<br><br>// Set web server port number to 80<br>WiFiServer server(80);<br><br>// Variable to store the HTTP request<br>String header;<br><br>// Auxiliar variables to store the current output state<br>String output26State = &quot;off&quot;;<br>String output27State = &quot;off&quot;;<br><br>// Assign output variables to GPIO pins<br>const int output26 = 26;<br><br>// Current time<br>unsigned long currentTime = millis();<br>// Previous time<br>unsigned long previousTime = 0; <br>// Define timeout time in milliseconds (example: 2000ms = 2s)<br>const long timeoutTime = 2000;<br><br>// BMP280<br>/*******************************/<br>float temperature_BMP280;<br>float pressure;<br><br><br>// Temperature variable<br>int32_t _t_fine;<br><br><br>// Trimming parameters<br>uint16_t _dig_T1;<br>int16_t _dig_T2;<br>int16_t _dig_T3;<br><br>uint16_t _dig_P1;<br>int16_t _dig_P2;<br>int16_t _dig_P3;<br>int16_t _dig_P4;<br>int16_t _dig_P5;<br>int16_t _dig_P6;<br>int16_t _dig_P7;<br>int16_t _dig_P8;<br>int16_t _dig_P9;<br>/*******************************/<br><br><br><br>//AHT20<br>/*******************************/<br>float temperature_AHT20;<br>float humidity;<br>bool sensor_started = false;<br>bool sensor_busy = false;<br>unsigned long measurementDelayAHT20 = 0;<br>/*******************************/<br><br><br><br>float delta = 0;<br>float minDelta = 10;<br>float maxDelta = 0;<br><br><br>//  Heartbeat<br>unsigned long HeartbeatMillis = 0;<br>const long Heartbeatinterval = 5000;<br><br><br><br>void setup() {<br>  Serial.begin(115200);<br>  Wire.begin();<br>  AHT20_begin();<br>  BMP280_begin();<br>  startMeasurementAHT20();<br>  // Initialize the output variables as outputs<br>  pinMode(output26, OUTPUT);<br>  // Set outputs to LOW<br>  digitalWrite(output26, LOW);<br><br>  // Connect to Wi-Fi network with SSID and password<br>  Serial.print(&quot;Connecting to &quot;);<br>  Serial.println(ssid);<br>  WiFi.begin(ssid, password);<br>  while (WiFi.status() != WL_CONNECTED) {<br>    delay(500);<br>    Serial.print(&quot;.&quot;);<br>  }<br>  // Print local IP address and start web server<br>  Serial.println(&quot;&quot;);<br>  Serial.println(&quot;WiFi connected.&quot;);<br>  Serial.println(&quot;IP address: &quot;);<br>  Serial.println(WiFi.localIP());<br>  server.begin();<br>}<br><br><br>void loop(){<br>  checkbusyAHT20();<br>  getDataAHT20();<br><br>  //BMP280<br>    readTemperatureBMP280();<br><br>    readPressureBMP280();<br><br><br>    // AHT20<br>    startMeasurementAHT20();<br><br><br><br><br>  WiFiClient client = server.available();   // Listen for incoming clients<br><br>  if (client) {                             // If a new client connects,<br>    currentTime = millis();<br>    previousTime = currentTime;<br>    Serial.println(&quot;New Client.&quot;);          // print a message out in the serial port<br>    String currentLine = &quot;&quot;;                // make a String to hold incoming data from the client<br>    while (client.connected() &amp;&amp; currentTime - previousTime &lt;= timeoutTime) {  // loop while the client&#39;s connected<br>      currentTime = millis();<br>      if (client.available()) {             // if there&#39;s bytes to read from the client,<br>        char c = client.read();             // read a byte, then<br>        Serial.write(c);                    // print it out the serial monitor<br>        header += c;<br>        if (c == &#39;\n&#39;) {                    // if the byte is a newline character<br>          // if the current line is blank, you got two newline characters in a row.<br>          // that&#39;s the end of the client HTTP request, so send a response:<br>          if (currentLine.length() == 0) {<br>            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)<br>            // and a content-type so the client knows what&#39;s coming, then a blank line:<br>            client.println(&quot;HTTP/1.1 200 OK&quot;);<br>            client.println(&quot;Content-type:text/html&quot;);<br>            client.println(&quot;Connection: close&quot;);<br>            client.println();<br>            <br>            // turns the GPIOs on and off<br>            if (header.indexOf(&quot;GET /26/on&quot;) &gt;= 0) {<br>              Serial.println(&quot;GPIO 26 on&quot;);<br>              output26State = &quot;on&quot;;<br>              digitalWrite(output26, HIGH);<br>            } else if (header.indexOf(&quot;GET /26/off&quot;) &gt;= 0) {<br>              Serial.println(&quot;GPIO 26 off&quot;);<br>              output26State = &quot;off&quot;;<br>              digitalWrite(output26, LOW);<br>            }<br>            <br>client.println(R&quot;rawliteral(<br>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>  &lt;head&gt;<br>    &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1&quot;&gt;<br>    &lt;link rel=&quot;icon&quot; href=&quot;data:,&quot;&gt;<br>    &lt;style&gt;<br>      html {<br>        font-family: &#39;Segoe UI&#39;, Tahoma, Geneva, Verdana, sans-serif;<br>        background-color: #f9f9fb;<br>        color: #2c3e50;<br>        text-align: center;<br>        margin: 0;<br>        padding: 20px;<br>      }<br>      h1 {<br>        color: #4B0082;<br>        font-size: 2.5em;<br>        margin-bottom: 25px;<br>      }<br>      .button {<br>        background-color: #1E90FF;<br>        border: none;<br>        color: white;<br>        padding: 14px 36px;<br>        font-size: 28px;<br>        margin: 12px;<br>        cursor: pointer;<br>        border-radius: 12px;<br>        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);<br>        transition: background-color 0.3s ease, transform 0.2s ease;<br>      }<br>      .button:hover {<br>        background-color: #1c86ee;<br>        transform: scale(1.05);<br>      }<br>      .button2 {<br>        background-color: #6a1b9a;<br>      }<br>      .button2:hover {<br>        background-color: #581b91;<br>      }<br>      table {<br>        margin: 30px auto;<br>        border-collapse: collapse;<br>        width: 85%;<br>        background-color: #ffffff;<br>        box-shadow: 0 2px 10px rgba(0,0,0,0.1);<br>        border-radius: 10px;<br>        overflow: hidden;<br>      }<br>      th, td {<br>        padding: 16px 24px;<br>        border-bottom: 1px solid #e0e0e0;<br>      }<br>      th {<br>        background-color: #e3e8f0;<br>        color: #4B0082;<br>        text-transform: uppercase;<br>        font-size: 14px;<br>      }<br>      .sensor {<br>        font-weight: bold;<br>        color: #2c3e50;<br>        font-size: 18px;<br>      }<br>    &lt;/style&gt;<br>  &lt;/head&gt;<br>  &lt;body&gt;<br>    &lt;h1&gt;ESP32 Web Server&lt;/h1&gt;<br>    &lt;p&gt;GPIO 26 - State: &lt;strong&gt;)rawliteral&quot; + output26State + R&quot;rawliteral(&lt;/strong&gt;&lt;/p&gt;<br>)rawliteral&quot;);<br><br>if (output26State == &quot;off&quot;) {<br>  client.println(&quot;&lt;p&gt;&lt;a href=\&quot;/26/on\&quot;&gt;&lt;button class=\&quot;button\&quot;&gt;ON&lt;/button&gt;&lt;/a&gt;&lt;/p&gt;&quot;);<br>} else {<br>  client.println(&quot;&lt;p&gt;&lt;a href=\&quot;/26/off\&quot;&gt;&lt;button class=\&quot;button button2\&quot;&gt;OFF&lt;/button&gt;&lt;/a&gt;&lt;/p&gt;&quot;);<br>}<br><br>client.println(R&quot;rawliteral(<br>    &lt;table&gt;<br>      &lt;tr&gt;&lt;th&gt;MEASUREMENT&lt;/th&gt;&lt;th&gt;VALUE&lt;/th&gt;&lt;/tr&gt;<br>      &lt;tr&gt;&lt;td&gt;Temp. Celsius&lt;/td&gt;&lt;td&gt;&lt;span class=&quot;sensor&quot;&gt;)rawliteral&quot; + String(temperature_BMP280) + R&quot;rawliteral( &amp;deg;C&lt;/span&gt;&lt;/td&gt;&lt;/tr&gt;<br>      &lt;tr&gt;&lt;td&gt;Temp. Fahrenheit&lt;/td&gt;&lt;td&gt;&lt;span class=&quot;sensor&quot;&gt;)rawliteral&quot; + String(1.8 * temperature_BMP280 + 32) + R&quot;rawliteral( &amp;deg;F&lt;/span&gt;&lt;/td&gt;&lt;/tr&gt;<br>      &lt;tr&gt;&lt;td&gt;Pressure&lt;/td&gt;&lt;td&gt;&lt;span class=&quot;sensor&quot;&gt;)rawliteral&quot; + String(pressure) + R&quot;rawliteral( hPa&lt;/span&gt;&lt;/td&gt;&lt;/tr&gt;<br>    &lt;/table&gt;<br>  &lt;/body&gt;<br>&lt;/html&gt;<br>)rawliteral&quot;);<br><br>               <br>            <br>            // The HTTP response ends with another blank line<br>            client.println();<br>            // Break out of the while loop<br>            break;<br>          } else { // if you got a newline, then clear currentLine<br>            currentLine = &quot;&quot;;<br>          }<br>        } else if (c != &#39;\r&#39;) {  // if you got anything else but a carriage return character,<br>          currentLine += c;      // add it to the end of the currentLine<br>        }<br>      }<br>    }<br>    // Clear the header variable<br>    header = &quot;&quot;;<br>    // Close the connection<br>    client.stop();<br>    Serial.println(&quot;Client disconnected.&quot;);<br>    Serial.println(&quot;&quot;);<br>  }<br>}<br><br><br>// misc<br><br>void AHT20_begin() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xBE);  // 0xBE --&gt; init register for AHT2x<br>  Wire.endTransmission();<br>}<br><br>void startMeasurementAHT20() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xAC);  // 0xAC --&gt; start measurement<br>  Wire.write(0x33);  // 0x33 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL<br>  Wire.write(0x00);  // 0x00 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL_NOP<br>  Wire.endTransmission();<br>  measurementDelayAHT20 = millis();<br>  sensor_started = true;<br>  sensor_busy = true;<br>}<br><br>void checkbusyAHT20() {<br>  if (millis() &lt; measurementDelayAHT20) {<br>    measurementDelayAHT20 = millis();<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 200))) {<br>    sensor_started = false;<br>    sensor_busy = false;<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 80))) {<br>    Wire.requestFrom(0x38, 1);<br>    if (Wire.available()) {<br>      unsigned char c = Wire.read();<br>      if (!(c &amp; 0x80)) {<br>        sensor_busy = false;<br>      }<br>    }<br>  }<br>}<br><br><br>void getDataAHT20() {<br>  if (sensor_started &amp;&amp; !sensor_busy) {<br>    Wire.requestFrom(0x38, 7);  // Request 7 bytes of data<br><br>    unsigned char str[7] = { 0 };<br>    int index = 0;<br><br>    // Fault detection<br>    unsigned long timeoutMillis = 200;<br>    unsigned long startMillis = millis();<br><br><br><br>    while (Wire.available()) {<br>      str[index] = Wire.read();  // Receive a byte as character<br><br>      // Debug message: Output of each byte (binary) with labelling<br>      /***********************************************************/<br>      // Serial.print(&quot;Byte &quot;);<br>      // Serial.print(index);<br>      // Serial.print(&quot;: &quot;);<br>      // for (int i = 7; i &gt;= 0; --i) {<br>      //  Serial.print((str[index] &gt;&gt; i) &amp; 1);<br>      // }<br>      // Serial.println();<br>      /***********************************************************/<br><br><br>      index++;<br><br><br><br>      // Fault detection<br>      if (millis() - startMillis &gt; timeoutMillis) {<br>        Serial.println(&quot;Timeout while waiting for data from AHT20&quot;);<br>        return;<br>      }<br>    }<br>    if (index == 0 || (str[0] &amp; 0x80)) {<br>      Serial.println(&quot;Failed to get data from AHT20&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Check CRC<br>    uint8_t crc = 0xFF;<br>    for (uint8_t byteIndex = 0; byteIndex &lt; 6; byteIndex++) {<br>      crc ^= str[byteIndex];<br>      for (uint8_t bitIndex = 8; bitIndex &gt; 0; --bitIndex) {<br>        if (crc &amp; 0x80) {<br>          crc = (crc &lt;&lt; 1) ^ 0x31;<br>        } else {<br>          crc = (crc &lt;&lt; 1);<br>        }<br>      }<br>    }<br>    if (crc != str[6]) {<br>      Serial.println(&quot;CRC check failed&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Parse data<br>    float humi, temp;<br>    // Extract the raw data for humidity from the bytes<br>    unsigned long __humi = str[1];  // Byte 1: The first 8 bits of the raw data for humidity<br>    __humi &lt;&lt;= 8;                   // Move the bits 8 positions to the left<br>    __humi += str[2];               // Byte 2: Add the next 8 bits<br>    __humi &lt;&lt;= 4;                   // Move the bits 4 positions to the left<br>    __humi += str[3] &gt;&gt; 4;          // Byte 3: Add the last 4 bits (shifted to the right)<br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************************************************************/<br>    // Serial.print(&quot;Humidity (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__humi &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************************************************************/<br><br>    humi = (float)__humi / 1048576.0;<br>    humidity = humi * 100.0;<br><br>    // Extract the raw data for temperature from the bytes<br>    unsigned long __temp = str[3] &amp; 0x0f;  // Byte 3: The last 4 bits of the raw data for the temperature<br>    __temp &lt;&lt;= 8;                          // Move the bits 8 positions to the left<br>    __temp += str[4];                      // Byte 4: Add the next 8 bits<br>    __temp &lt;&lt;= 8;                          // Move the bits to the left again by 8 positions<br>    __temp += str[5];                      // Byte 5: Add the last 8 bits<br><br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************************************************************/<br>    // Serial.print(&quot;Temperature (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__temp &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************************************************************/<br><br>    temp = (float)__temp / 1048576.0 * 200.0 - 50.0;<br><br>    temperature_AHT20 = temp;<br><br>    sensor_started = false;<br>  }<br>}<br>void BMP280_begin() {<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xD0);  // 0xBE --&gt;  register for chip identification<br>  Wire.endTransmission();<br>  Wire.requestFrom(0x77, 1);<br>  uint8_t chip_ID = Wire.read();<br>  if (chip_ID == 0x58) {  // 0x58 --&gt; BMP280<br>    Serial.println(&quot;BMP280 found&quot;);<br>  } else {<br>    Serial.println(&quot;Unbekannter Sensor.&quot;);<br>  }<br><br><br><br>  // Generate soft-reset<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xE0);  // 0xE0 --&gt; Reset register<br>  Wire.write(0xB6);  // 0xB6 --&gt; Reset value for reset register<br>  Wire.endTransmission();<br><br><br><br>  // Wait for copy completion NVM data to image registers<br>  uint8_t stat_Reg = 1;<br><br>  while (stat_Reg == 1) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(0XF3);  // 0XF3 --&gt; Status register<br>    Wire.endTransmission();<br>    Wire.requestFrom((uint8_t)0x77, (byte)1);<br>    stat_Reg = Wire.read();<br>    Serial.println(stat_Reg);<br>  }<br><br>  // See datasheet 4.2.2 Trimming parameter readout<br><br><br>  // Array for storing the read values<br>  uint16_t values[12];<br><br>  // Addresses of the registers with coefficients Data to be read<br>  uint8_t registers[] = { 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E };<br><br>  for (int i = 0; i &lt; 12; i++) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(registers[i]);<br>    Wire.endTransmission();<br><br>    Wire.requestFrom((uint8_t)0x77, (byte)2);<br>    if (Wire.available() &gt;= 2) {<br>      values[i] = Wire.read() &lt;&lt; 8 | Wire.read();  // compose 16-bit value<br>    }<br>  }<br><br>  // Reverse the bytes for all 16-bit values (little endian / big endian)<br>  for (int i = 0; i &lt; 12; i++) {<br>    values[i] = (values[i] &gt;&gt; 8) | (values[i] &lt;&lt; 8);<br>  }<br><br>  // Assigning values to the variables<br>  _dig_T1 = values[0];<br>  _dig_T2 = values[1];<br>  _dig_T3 = values[2];<br>  _dig_P1 = values[3];<br>  _dig_P2 = values[4];<br>  _dig_P3 = values[5];<br>  _dig_P4 = values[6];<br>  _dig_P5 = values[7];<br>  _dig_P6 = values[8];<br>  _dig_P7 = values[9];<br>  _dig_P8 = values[10];<br>  _dig_P9 = values[11];<br><br><br>  // Debug message: Output of each byte (binary) with labelling<br>  /***********************************************************/<br>  // Serial.println(&quot;Temperature Values:&quot;);<br>  // Serial.print(&quot;_dig_T1: &quot;);<br>  // Serial.println(_dig_T1, HEX);<br>  // Serial.print(&quot;_dig_T2: &quot;);<br>  // Serial.println(_dig_T2, HEX);<br>  // Serial.print(&quot;_dig_T3: &quot;);<br>  // Serial.println(_dig_T3, HEX);<br><br>  // Serial.println(&quot;Pressure Values:&quot;);<br>  // Serial.print(&quot;_dig_P1: &quot;);<br>  // Serial.println(_dig_P1, HEX);<br>  // Serial.print(&quot;_dig_P2: &quot;);<br>  // Serial.println(_dig_P2, HEX);<br>  // Serial.print(&quot;_dig_P3: &quot;);<br>  // Serial.println(_dig_P3, HEX);<br>  // Serial.print(&quot;_dig_P4: &quot;);<br>  // Serial.println(_dig_P4, HEX);<br>  // Serial.print(&quot;_dig_P5: &quot;);<br>  // Serial.println(_dig_P5, HEX);<br>  // Serial.print(&quot;_dig_P6: &quot;);<br>  // Serial.println(_dig_P6, HEX);<br>  // Serial.print(&quot;_dig_P7: &quot;);<br>  // Serial.println(_dig_P7, HEX);<br>  // Serial.print(&quot;_dig_P8: &quot;);<br>  // Serial.println(_dig_P8, HEX);<br>  // Serial.print(&quot;_dig_P9: &quot;);<br>  // Serial.println(_dig_P9, HEX);<br>  /***********************************************************/<br><br><br><br><br>  // Set in sleep mode to provide write access to the “config” register<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF4);  // 0XF3 --&gt; Contol register<br>  Wire.write(0b00);  // 00   --&gt; sleep mode<br>  Wire.endTransmission();<br><br>  <br>  // SAMPLING_NONE = 0b000<br>  // SAMPLING_X1   = 0b001<br>  // SAMPLING_X2   = 0b010<br>  // SAMPLING_X4   = 0b011<br>  // SAMPLING_X8   = 0b100<br>  // SAMPLING_X16  = 0b101<br>  <br>  // MODE_SLEEP  = 0b00<br>  // MODE_FORCED = 0b01<br>  // MODE_NORMAL = 0b11<br><br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF4);<br>  uint8_t configValues = ((0b001 &lt;&lt; 5) | (0b011 &lt;&lt; 2) | 0b11);<br>  //                       temp           press         mode<br>  Wire.write(configValues);<br>  Wire.endTransmission();<br><br>  delay(10);<br><br>  // Set register 0xF5 “config”  ** See datasheet 5.4.6 for details”<br>  // STANDBY_MS_0_5  = 0b000<br>  // STANDBY_MS_10   = 0b110<br>  // STANDBY_MS_20   = 0b111<br>  // STANDBY_MS_62_5 = 0b001<br>  // STANDBY_MS_125  = 0b010<br>  // STANDBY_MS_250  = 0b011<br>  // STANDBY_MS_500  = 0b100<br>  // STANDBY_MS_1000 = 0b101<br><br>  // FILTER_OFF = 0b000<br>  // FILTER_X2 = 0b001<br>  // FILTER_X4 = 0b010<br>  // FILTER_X8 = 0b011<br>  // FILTER_X16 = 0b100<br>  <br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF5);<br>  configValues = (0b110 &lt;&lt; 5) | (0b100 &lt;&lt; 2);<br>  //              standby        filter<br>  Wire.write(configValues);<br>  Wire.endTransmission();<br><br><br><br>  // Wait for first completed conversion<br>  delay(100);<br><br>  // Debug message: Output    of   CTRL_MEAS &amp;  CONFIG (binary)<br>  /***********************************************************/<br>  // readAndDisplayRegister(0x77, 0xF4, &quot;CTRL_MEAS&quot;);<br>  // readAndDisplayRegister(0x77, 0xF5, &quot;CONFIG&quot;);<br>  /***********************************************************/<br>}<br><br><br><br>void readTemperatureBMP280() {<br>  int32_t var1, var2, adc_T;<br><br>  // Read temperature registers<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xFA);<br>  Wire.endTransmission();<br>  Wire.requestFrom((uint8_t)0x77, (byte)3);<br><br>  adc_T = (Wire.read() &lt;&lt; 16) | (Wire.read() &lt;&lt; 8) | Wire.read();<br>  adc_T &gt;&gt;= 4;<br><br>  // See datasheet 4.2.3 Compensation formulas<br>  var1 = ((((adc_T &gt;&gt; 3) - ((int32_t)_dig_T1 &lt;&lt; 1))) * ((int32_t)_dig_T2)) &gt;&gt; 11;<br><br>  var2 = (((((adc_T &gt;&gt; 4) - ((int32_t)_dig_T1)) * ((adc_T &gt;&gt; 4) - ((int32_t)_dig_T1))) &gt;&gt; 12) * ((int32_t)_dig_T3)) &gt;&gt; 14;<br><br>  _t_fine = var1 + var2;<br><br>  float T = (((_t_fine * 5) + 128) &gt;&gt; 8);<br><br>  temperature_BMP280 = T / 100;<br>}<br><br><br><br>void readPressureBMP280() {<br>  int64_t var1;<br>  int64_t var2;<br>  int64_t p;<br>  int32_t adc_P;<br><br>  // Read temperature for t_fine<br>  readTemperatureBMP280();<br><br>  // Read pressure registers<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF7);<br>  Wire.endTransmission();<br>  Wire.requestFrom((uint8_t)0x77, (byte)3);<br>  adc_P = (Wire.read() &lt;&lt; 16) | (Wire.read() &lt;&lt; 8) | Wire.read();<br><br>  adc_P &gt;&gt;= 4;<br><br>  // See datasheet 4.2.3 Compensation formulas<br>  var1 = ((int64_t)_t_fine) - 128000;<br>  var2 = var1 * var1 * (int64_t)_dig_P6;<br>  var2 = var2 + ((var1 * (int64_t)_dig_P5) &lt;&lt; 17);<br>  var2 = var2 + (((int64_t)_dig_P4) &lt;&lt; 35);<br>  var1 = ((var1 * var1 * (int64_t)_dig_P3) &gt;&gt; 8) + ((var1 * (int64_t)_dig_P2) &lt;&lt; 12);<br>  var1 = (((((int64_t)1) &lt;&lt; 47) + var1)) * ((int64_t)_dig_P1) &gt;&gt; 33;<br><br>  if (var1 == 0) {<br>    return;  // avoid exception caused by division by zero<br>  }<br>  p = 1048576 - adc_P;<br>  p = (((p &lt;&lt; 31) - var2) * 3125) / var1;<br>  var1 = (((int64_t)_dig_P9) * (p &gt;&gt; 13) * (p &gt;&gt; 13)) &gt;&gt; 25;<br>  var2 = (((int64_t)_dig_P8) * p) &gt;&gt; 19;<br><br>  p = ((p + var1 + var2) &gt;&gt; 8) + (((int64_t)_dig_P7) &lt;&lt; 4);<br><br>  pressure = p / 25600;<br>}<br><br><br><br>void readAndDisplayRegister(uint8_t deviceAddress, byte registerAddress, const char* registerName) {<br>  Wire.beginTransmission(deviceAddress);<br>  Wire.write(registerAddress);<br>  Wire.endTransmission();<br><br>  Wire.requestFrom(deviceAddress, (byte)1);<br>  if (Wire.available()) {<br>    uint8_t registerValue = Wire.read();<br><br>    Serial.print(registerName);<br>    Serial.print(&quot; (&quot;);<br>    Serial.print(registerAddress, HEX);<br>    Serial.print(&quot;) : 0b&quot;);<br><br>    for (int i = 7; i &gt;= 0; i--) {<br>      Serial.print((registerValue &amp; (1 &lt;&lt; i)) ? &#39;1&#39; : &#39;0&#39;);<br>    }<br><br>    Serial.println();<br>  } else {<br>    Serial.println(&quot;Fehler beim Lesen des Registers&quot;);<br>  }<br>}</pre><h3>Penjelasan Kode</h3><p>Kode ini menggunakan ESP32 untuk membuat web server yang dapat diakses melalui jaringan WiFi lokal dan menampilkan data dari dua sensor, yaitu AHT20 (sensor suhu dan kelembaban) dan BMP280 (sensor tekanan dan suhu). Pada bagian awal, program mengimpor berbagai pustaka yang diperlukan seperti WiFi.h untuk koneksi jaringan, WebServer.h untuk membuat server HTTP, serta pustaka sensor Adafruit_AHTX0.h dan Adafruit_BMP280.h. Setelah itu, dideklarasikan nama SSID dan password jaringan WiFi yang akan digunakan oleh ESP32 untuk terhubung. Objek WebServer server(80) dibuat untuk menjalankan server HTTP pada port 80. Kemudian, objek Adafruit_AHTX0 aht dan Adafruit_BMP280 bmp dibuat untuk masing-masing sensor.</p><p>Di dalam fungsi setup(), ESP32 memulai koneksi ke WiFi dengan WiFi.begin(ssid, password), dan program akan menunggu hingga berhasil tersambung. Setelah itu, alamat IP lokal ESP32 dicetak melalui Serial.println(WiFi.localIP()) untuk memberi tahu di mana web server dapat diakses. Web server kemudian dikonfigurasi untuk merespons permintaan HTTP GET ke root path &#39;/&#39; dengan memanggil fungsi handleRoot(). Kedua sensor juga diinisialisasi, dan jika inisialisasi gagal, program akan berhenti dengan pesan kesalahan.</p><p>Fungsi handleRoot() bertugas membaca data dari kedua sensor. Sensor AHT20 memberikan nilai suhu dan kelembaban, sedangkan BMP280 memberikan nilai suhu dan tekanan. Data yang diperoleh kemudian dirangkai dalam format HTML sebagai halaman web, yang ditampilkan ketika pengguna mengakses alamat IP ESP32 melalui browser. Fungsi loop() hanya memanggil server.handleClient(), yang menangani permintaan dari klien secara terus-menerus.</p><p>Secara keseluruhan, program ini memungkinkan pengguna untuk memantau kondisi lingkungan (suhu, kelembaban, dan tekanan) secara real-time melalui jaringan WiFi menggunakan browser biasa tanpa memerlukan perangkat lunak tambahan.</p><h3>Koneksi dan Pengaturan Jaringan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PUBH3MAu4aww0RVk0Vpk6A.png" /><figcaption>Terkoneksi ke jaringan “ADAM GANTENG”</figcaption></figure><p>Agar ESP32 dapat menjalankan fungsi sebagai web server, perangkat ini harus terlebih dahulu terhubung ke jaringan Wi-Fi yang sesuai. Dalam implementasi ini, koneksi dilakukan dengan menggunakan hotspot dari perangkat dengan nama SSID “ADAM GANTENG”, yang sudah disesuaikan dengan konfigurasi yang tertanam dalam program ESP32. Setelah berhasil terkoneksi, ESP32 akan memperoleh alamat IP lokal yang digunakan sebagai alamat akses menuju web server. Alamat IP ini perlu dicatat karena nantinya digunakan untuk membuka antarmuka web yang menampilkan hasil pembacaan sensor. Penggunaan hotspot pribadi memberikan fleksibilitas dan kontrol penuh atas jaringan, sekaligus memastikan bahwa tidak ada gangguan koneksi dari perangkat lain yang tidak diinginkan.</p><h3>Interface Web Server ESP32</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ow0l-BneKZVkPftxJlWPgw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mOdWeDNoaJM2rnxrze5Jzw.jpeg" /></figure><p>Setelah koneksi jaringan berhasil, ESP32 akan menampilkan halaman web melalui alamat IP yang ditentukan. Antarmuka web ini memuat tampilan sederhana namun informatif dengan judul “ESP32 Web Server” di bagian atas. Salah satu fitur utama adalah tombol kontrol GPIO 26 yang memungkinkan pengguna menyalakan dan mematikan output secara real-time, ditandai dengan perubahan status antara “ON” dan “OFF” sesuai dengan aksi pengguna. Di bawah tombol, terdapat tabel yang menunjukkan data hasil pembacaan sensor, termasuk suhu dalam satuan Celsius dan Fahrenheit, serta tekanan udara dalam satuan hPa. Data ini diperbarui secara dinamis sehingga pengguna dapat memantau kondisi lingkungan secara langsung melalui browser. Desain antarmuka ini dirancang agar responsif dan mudah dipahami, menjadikan ESP32 tidak hanya sebagai pengontrol, tetapi juga sebagai sistem monitoring berbasis web yang praktis.</p><h3>Bentuk Rangkaian</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B7wEm08wWB72WK_n5RuNCQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H12CfZYZtyfNxr4Hep6NfA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fde255b18e1a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ESP32: Project #6 — Bluetooth]]></title>
            <link>https://medium.com/@bacotanadam/esp32-project-6-bluetooth-39b8c664b8e5?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/39b8c664b8e5</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Mon, 28 Apr 2025 16:56:36 GMT</pubDate>
            <atom:updated>2025-04-28T16:56:36.209Z</atom:updated>
            <content:encoded><![CDATA[<h3>ESP32: Project #6 — Bluetooth</h3><p>II2260 : Internet Of Things — Adam Joaquin Girsang — 18223089</p><h3><strong>Latar Belakang</strong></h3><p>Seiring dengan perkembangan teknologi Internet of Things (IoT), kebutuhan akan komunikasi nirkabel yang efisien dan hemat daya semakin penting. Salah satu solusi komunikasi jarak dekat yang banyak digunakan dalam ekosistem IoT adalah <strong>Bluetooth</strong>. Teknologi ini memungkinkan perangkat untuk saling bertukar data dalam area personal (Personal Area Network — PAN) tanpa membutuhkan kabel.</p><p>ESP32, sebagai salah satu mikrokontroler yang populer untuk pengembangan IoT, sudah dilengkapi dengan modul <strong>Bluetooth</strong> bawaan. Menariknya, ESP32 mendukung dua jenis protokol Bluetooth, yaitu <strong>Bluetooth Classic</strong> dan <strong>Bluetooth Low Energy (BLE)</strong>.</p><ul><li><strong>Bluetooth Classic</strong> banyak digunakan untuk aplikasi yang membutuhkan transfer data dengan bandwidth lebih besar, seperti audio streaming atau komunikasi serial standar.</li><li><strong>Bluetooth Low Energy (BLE)</strong>, sesuai namanya, dirancang untuk aplikasi yang membutuhkan konsumsi daya sangat rendah, ideal untuk perangkat IoT yang beroperasi dalam waktu lama dengan sumber daya terbatas.</li></ul><p>Siap, aku ulangi sesuai yang tadi — yaitu <strong>pakai ESP32</strong>, <strong>upload dari laptop via kabel USB</strong>, <strong>testing koneksi dari smartphone ke ESP32</strong>. Ini dia:</p><h3>Pengerjaan</h3><p><strong>Hal yang perlu dipersiapkan:</strong></p><ul><li>1 buah ESP32 board</li><li>Kabel USB untuk koneksi ESP32 ke komputer</li><li>Arduino IDE (sudah terinstal dan dikonfigurasi untuk ESP32)</li><li>Library Bluetooth ESP32 (bawaan Arduino IDE ESP32</li><li>Smartphone dengan Bluetooth aktif (untuk pengujian koneksi)</li></ul><h3>Langkah-langkah</h3><p><strong>1. Persiapan Awal</strong></p><ul><li>Sambungkan ESP32 ke komputer menggunakan kabel USB.</li><li>Pastikan board ESP32 sudah terdeteksi di Arduino IDE.</li></ul><p><strong>2. Eksperimen Bluetooth Classic:</strong></p><ul><li>Buka contoh program Bluetooth Serial dari referensi.</li><li>Upload program ke ESP32.</li><li>Gunakan aplikasi Bluetooth Serial Terminal di smartphone untuk mencari dan menghubungkan ke ESP32.</li><li>Lakukan komunikasi teks sederhana</li></ul><p><strong>3. Eksperimen Bluetooth Low Energy (BLE):</strong></p><ul><li>Buka contoh program BLE Server dari referensi.</li><li>Upload program ke ESP32.</li><li>Gunakan aplikasi BLE Scanner di smartphone untuk menemukan ESP32 dan mencoba membaca/menulis karakteristik.</li></ul><p><strong>4. Pengamatan dan Dokumentasi</strong></p><p>Catat keberhasilan koneksi, kecepatan respon, konsumsi daya (jika diukur), serta perbedaan karakteristik antara Bluetooth Classic dan BLE.</p><h3>Kode</h3><pre>//This example code is in the Public Domain (or CC0 licensed, at your option.)<br>//By Evandro Copercini - 2018<br>//<br>//This example creates a bridge between Serial and Classical Bluetooth (SPP)<br>//and also demonstrate that SerialBT have the same functionalities of a normal Serial<br><br>#include &quot;BluetoothSerial.h&quot;<br><br>#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)<br>#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it<br>#endif<br><br>BluetoothSerial SerialBT;<br><br>void setup() {<br>  Serial.begin(115200);<br>  SerialBT.begin(&quot;ESP32test&quot;); //Bluetooth device name<br>  Serial.println(&quot;The device started, now you can pair it with bluetooth!&quot;);<br>}<br><br>void loop() {<br>  if (Serial.available()) {<br>    SerialBT.write(Serial.read());<br>  }<br>  if (SerialBT.available()) {<br>    Serial.write(SerialBT.read());<br>  }<br>  delay(20);<br>}</pre><pre>#include &lt;BLEDevice.h&gt;<br>#include &lt;BLEServer.h&gt;<br>#include &lt;BLEUtils.h&gt;<br>#include &lt;BLE2902.h&gt;<br><br>BLECharacteristic* pCharacteristic;<br>bool isDeviceConnected = false;<br><br>#define SERVICE_UUID        &quot;4fafc201-1fb5-459e-8fcc-c5c9c331914b&quot;<br>#define CHARACTERISTIC_UUID &quot;beb5483e-36e1-4688-b7f5-ea07361b26a8&quot;<br><br>class ServerCallbacks : public BLEServerCallbacks {<br>  void onConnect(BLEServer* pServer) override {<br>    isDeviceConnected = true;<br>  }<br>  void onDisconnect(BLEServer* pServer) override {<br>    isDeviceConnected = false;<br>  }<br>};<br><br>void setup() {<br>  Serial.begin(115200);<br>  Serial.println(&quot;Initializing BLE...&quot;);<br><br>  BLEDevice::init(&quot;ServerESP32BLE&quot;);<br><br>  BLEServer* pServer = BLEDevice::createServer();<br>  pServer-&gt;setCallbacks(new ServerCallbacks());<br><br>  BLEService* pService = pServer-&gt;createService(SERVICE_UUID);<br><br>  pCharacteristic = pService-&gt;createCharacteristic(<br>    CHARACTERISTIC_UUID,<br>    BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE<br>  );<br><br>  pCharacteristic-&gt;setValue(&quot;Adam checking&quot;);<br><br>  pService-&gt;start();<br><br>  BLEAdvertising* pAdvertising = BLEDevice::getAdvertising();<br>  pAdvertising-&gt;addServiceUUID(SERVICE_UUID);<br>  pAdvertising-&gt;start();<br><br>  Serial.println(&quot;BLE Server is up. To be connect...&quot;);<br>}<br><br>void loop() {<br>  if (isDeviceConnected) {<br>    // Optional: update characteristic value here<br>  }<br>}</pre><h3><strong>Penjelasan Kode</strong></h3><p>Oke, aku buatin penjelasan singkat untuk <strong>dua kode</strong> yang kamu kasih, supaya nanti kamu tinggal masukin ke blog atau laporanmu.</p><p><strong>Penjelasan Program 1: Bluetooth Classic (SPP) dengan ESP32</strong></p><p>Program ini membuat ESP32 menjadi perangkat <strong>Bluetooth Serial (SPP)</strong> yang bisa dipasangkan (pair) dan berkomunikasi layaknya koneksi serial biasa.</p><p><strong>Ringkasan fungsi program:</strong></p><ul><li><strong>Library</strong> BluetoothSerial.h digunakan untuk mengaktifkan Bluetooth Classic.</li></ul><p><strong>Inisialisasi:</strong></p><ul><li>Serial.begin(115200); membuka komunikasi serial ke komputer (USB).</li><li>SerialBT.begin(&quot;ESP32test&quot;); memulai Bluetooth dengan nama perangkat <strong>&quot;ESP32test&quot;</strong>.</li></ul><p><strong>Loop:</strong></p><ul><li>Jika ada data dari komputer (Serial.available()), data dikirim ke Bluetooth.</li><li>Jika ada data dari Bluetooth (SerialBT.available()), data dikirim ke komputer.</li></ul><h3>Kesimpulan:</h3><ul><li>Program ini membuat ESP32 seperti “jembatan” dua arah antara <strong>serial USB</strong> dan <strong>Bluetooth</strong>.</li><li>Bisa dipakai untuk komunikasi teks real-time dari aplikasi Bluetooth Terminal di HP ke ESP32.</li></ul><h3>Penjelasan Program 2: Bluetooth Low Energy (BLE) Server dengan ESP32</h3><p>Program ini membuat ESP32 berperan sebagai <strong>BLE Server</strong>, yang menyediakan sebuah <strong>service</strong> dan <strong>characteristic</strong> untuk dibaca atau ditulis oleh client BLE (seperti HP).</p><h3>Ringkasan fungsi program:</h3><ul><li><strong>Library</strong> BLEDevice.h, BLEServer.h, BLEUtils.h, dan BLE2902.h digunakan untuk mengaktifkan BLE.</li></ul><p><strong>Inisialisasi:</strong></p><ul><li>BLEDevice::init(&quot;ServerESP32BLE&quot;); memulai BLE dengan nama perangkat <strong>&quot;ServerESP32BLE&quot;</strong>.</li><li>Membuat server, lalu service dengan UUID tertentu (SERVICE_UUID).</li><li>Membuat characteristic dengan UUID lain (CHARACTERISTIC_UUID) yang bisa <strong>dibaca</strong> dan <strong>ditulis</strong>.</li><li>Set nilai awal characteristic menjadi <strong>“Adam checking”</strong>.</li></ul><p><strong>Advertising:</strong></p><ul><li>ESP32 mengiklankan dirinya supaya bisa ditemukan oleh perangkat client BLE.</li></ul><p><strong>Loop:</strong></p><ul><li>Mengecek apakah ada perangkat yang terhubung (isDeviceConnected), tapi dalam kode ini belum ada aksi tambahan di loop.</li></ul><h3>Kesimpulan:</h3><ul><li>ESP32 akan tampil di aplikasi BLE Scanner sebagai server.</li><li>Client bisa membaca data <strong>“Adam checking”</strong> dari ESP32, dan bisa menulis data baru ke ESP32.</li></ul><h3>Hasil</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2GvSX1vqq7ISPAZPDIRaow.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q_0DMOnnCu5eMWxGpjQQnA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WTMWN1QjQbP4mnVLJdG-2Q.jpeg" /><figcaption>Hasil Bluetooth Connection</figcaption></figure><h3>Kesimpulan</h3><p>Melalui percobaan ini, telah dilakukan eksperimen komunikasi <strong>Bluetooth Classic</strong> dan <strong>Bluetooth Low Energy (BLE)</strong> menggunakan ESP32.<br> Pada Bluetooth Classic, ESP32 berhasil membangun koneksi serial nirkabel sederhana dengan smartphone, memungkinkan pertukaran data dua arah layaknya koneksi kabel biasa.<br> Pada BLE, ESP32 berhasil berperan sebagai server yang menyediakan service dan characteristic, yang dapat diakses oleh client BLE untuk membaca maupun menulis data.</p><p>Eksperimen ini menunjukkan bahwa ESP32 memiliki fleksibilitas tinggi dalam mendukung komunikasi nirkabel jarak dekat untuk berbagai kebutuhan IoT, baik yang memerlukan kecepatan tinggi maupun konsumsi daya rendah.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39b8c664b8e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ESP32: Project #5 — Serial Communication]]></title>
            <link>https://medium.com/@bacotanadam/esp32-project-5-serial-communication-f680e672ecc7?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/f680e672ecc7</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Mon, 14 Apr 2025 16:53:05 GMT</pubDate>
            <atom:updated>2025-04-14T16:53:05.994Z</atom:updated>
            <content:encoded><![CDATA[<h3>ESP32: Project #5 — Serial Communication</h3><p>II2260 : Internet Of Things — Adam Joaquin Girsang — 18223089</p><h3><strong>Latar Belakang</strong></h3><p>Dalam era Internet of Things (IoT), komunikasi antar perangkat menjadi aspek yang sangat krusial untuk membangun sistem yang terintegrasi dan efisien. Perangkat-perangkat IoT seperti sensor, mikrokontroler, dan aktuator harus dapat saling bertukar data secara real-time untuk menjalankan fungsinya. Salah satu metode utama yang digunakan dalam komunikasi antar perangkat adalah komunikasi serial, yang mencakup protokol populer seperti <strong>I2C (Inter-Integrated Circuit)</strong>, <strong>SPI (Serial Peripheral Interface)</strong>, dan <strong>UART (Universal Asynchronous Receiver/Transmitter)</strong>.</p><p>Komunikasi serial memungkinkan pengiriman data satu bit demi satu bit secara berurutan melalui satu atau dua jalur komunikasi, sehingga lebih hemat pin dibandingkan komunikasi paralel. Masing-masing protokol memiliki keunggulan dan kelemahannya sendiri, tergantung pada kebutuhan sistem, seperti kecepatan, jarak antar perangkat, jumlah perangkat yang terhubung, dan kompleksitas implementasi.</p><p>Pada proyek IoT ke-5 ini, saya melakukan eksperimen menggunakan <strong>mikrokontroler ESP32</strong> untuk menghubungkan dua atau lebih perangkat dengan menggunakan protokol komunikasi serial, seperti I2C, SPI, atau UART. Tujuan utama dari proyek ini adalah untuk menampilkan data dari sensor — seperti suhu dan kelembapan — pada <strong>modul LED display</strong>. Data sensor diambil, dikirimkan melalui salah satu protokol komunikasi serial, dan ditampilkan secara real-time sebagai bentuk visualisasi sederhana.</p><p>Dengan mengimplementasikan komunikasi serial pada proyek ini, saya dapat memahami bagaimana data dikirim dan diterima antar perangkat, bagaimana konfigurasi protokol dilakukan, serta bagaimana mengatasi tantangan seperti sinkronisasi data, pemilihan alamat I2C, atau manajemen waktu dalam sistem SPI dan UART. Proyek ini tidak hanya memperdalam pemahaman teknis mengenai protokol komunikasi, tetapi juga menjadi fondasi penting dalam membangun sistem IoT yang kompleks dan andal di masa depan.</p><h3><strong>Hal yang Perlu Dipersiapkan</strong></h3><p><strong>Perpustakaan (Library) yang Digunakan</strong></p><p>Library yang digunakan dalam proyek ini sama seperti pada proyek-proyek sebelumnya, yaitu:</p><ul><li><strong>Adafruit LiquidCrystal</strong> oleh Adafruit (untuk LCD 16×2 I2C)</li><li><strong>Adafruit AHTX0</strong> (untuk sensor AHT20)</li><li><strong>Adafruit BMP280</strong> (untuk sensor BMP280)</li><li><strong>Adafruit Unified Sensor</strong> (terinstal otomatis sebagai dependensi)</li><li><strong>Adafruit BusIO</strong> (terinstal otomatis sebagai dependensi)</li></ul><p><strong>Komponen yang Dibutuhkan</strong></p><p>Untuk mendukung eksperimen komunikasi serial ini, perangkat keras yang digunakan meliputi:</p><ul><li>ESP32 DOIT DEVKIT V1 Board</li><li>LCD 16×2 dengan Antarmuka I2C</li><li>Sensor BMP280 dan AHT20</li><li>Kabel jumper male to male</li><li>Kabel jumper female to male</li><li>Breadboard</li></ul><h3>Pengerjaan</h3><h3>Langkah Pengerjaan (Garis Besar)</h3><ol><li><strong>Persiapan Perangkat Keras</strong></li></ol><ul><li>Siapkan komponen yang dibutuhkan: ESP32, sensor AHT20, sensor BMP280, LCD 16×2 I2C, breadboard, dan kabel jumper.</li><li>Rangkai semua komponen di atas breadboard sesuai dengan jalur komunikasi yang digunakan (I2C/SPI/UART).</li></ul><p><strong>2. Inisialisasi dan Instalasi Library</strong></p><ul><li>Instal library yang diperlukan melalui Library Manager di Arduino IDE:</li><li>Adafruit LiquidCrystal</li><li>Adafruit AHTX0</li><li>Adafruit BMP280</li><li>Pastikan dependensi seperti Adafruit Unified Sensor dan Adafruit BusIO sudah terinstal.</li></ul><p><strong>3. Pemrograman ESP32</strong></p><ul><li>Buat program untuk membaca data suhu dan kelembapan dari sensor AHT20 dan tekanan udara dari BMP280.</li><li>Gunakan komunikasi <strong>I2C</strong> untuk berinteraksi dengan sensor dan LCD.</li><li>Tampilkan data yang dibaca pada layar LCD 16×2.</li></ul><p><strong>4. Pengujian dan Debugging</strong></p><ul><li>Upload program ke ESP32 dan amati hasil pembacaan sensor di LCD.</li><li>Lakukan pengecekan jika ada data yang tidak terbaca atau tidak tampil dengan benar.</li></ul><p><strong>5. Evaluasi dan Dokumentasi</strong></p><ul><li>Evaluasi kestabilan komunikasi data antar perangkat.</li><li>Dokumentasikan hasil, skematik rangkaian, serta penjelasan singkat mengenai protokol yang digunakan.</li></ul><pre>#include &lt;Wire.h&gt;<br>#include &lt;LiquidCrystal_I2C.h&gt;<br>#define I2C_ADDR 0x27<br>#define LCD_COLUMNS 16<br>#define LCD_ROWS 2<br>LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_ROWS);<br>// BMP280<br>/*******************************/<br>float temperature_BMP280;<br>float pressure;<br><br><br>// Temperature variable<br>int32_t _t_fine;<br><br><br>// Trimming parameters<br>uint16_t _dig_T1;<br>int16_t _dig_T2;<br>int16_t _dig_T3;<br><br>uint16_t _dig_P1;<br>int16_t _dig_P2;<br>int16_t _dig_P3;<br>int16_t _dig_P4;<br>int16_t _dig_P5;<br>int16_t _dig_P6;<br>int16_t _dig_P7;<br>int16_t _dig_P8;<br>int16_t _dig_P9;<br>/*******************************/<br><br><br><br>//AHT20<br>/*******************************/<br>float temperature_AHT20;<br>float humidity;<br>bool sensor_started = false;<br>bool sensor_busy = false;<br>unsigned long measurementDelayAHT20 = 0;<br>/*******************************/<br><br><br><br>float delta = 0;<br>float minDelta = 10;<br>float maxDelta = 0;<br><br><br>//  Heartbeat<br>unsigned long HeartbeatMillis = 0;<br>const long Heartbeatinterval = 5000;<br><br><br><br><br>void setup() {<br>  Serial.begin(115200);<br>  Wire.begin();<br>  AHT20_begin();<br>  BMP280_begin();<br>  startMeasurementAHT20();<br>  lcd.init();<br>  lcd.backlight();<br>}<br><br>void loop() {<br><br>  checkbusyAHT20();<br>  getDataAHT20();<br><br>  unsigned long currentMillis = millis();<br>  if (currentMillis - HeartbeatMillis &gt;= Heartbeatinterval) {<br>    HeartbeatMillis = currentMillis;<br><br><br>    //BMP280<br>    readTemperatureBMP280();<br>    Serial.print(&quot;Temperatur: &quot;);<br>    Serial.print(temperature_BMP280);<br>    Serial.println(&quot; C&quot;);<br>    lcd.setCursor(0, 0);<br>    lcd.print(&quot;Temperatur :&quot;);<br>    lcd.print(temperature_BMP280);<br><br>    readPressureBMP280();<br>    Serial.print(&quot;Druck: &quot;);<br>    Serial.print(pressure);<br>    Serial.println(&quot; hPa&quot;);<br>    lcd.setCursor(0, 1);<br>    lcd.print(&quot;Pressure :&quot;);<br>    lcd.print(pressure);<br>    delay(2000);<br>    // AHT20<br>    startMeasurementAHT20();<br><br>    Serial.print(&quot;Humidity: &quot;);<br>    Serial.print(humidity);<br>    Serial.println(&quot; %&quot;);<br>    lcd.setCursor(0, 0);<br>    lcd.print(&quot;humidity :&quot;);<br>    lcd.print(humidity);<br><br>    Serial.print(&quot;Temperatur: &quot;);<br>    Serial.print(temperature_AHT20);<br>    Serial.println(&quot; C&quot;);<br><br><br><br>    // Calculate the delta between the temperature values AHT20 and BMP280<br>    delta = (temperature_BMP280 &gt; temperature_AHT20) ? (temperature_BMP280 - temperature_AHT20) : (temperature_AHT20 - temperature_BMP280);<br><br>    if (delta &lt; minDelta) {<br>      minDelta = delta;<br>    }<br>    if (delta &gt; maxDelta) {<br>      maxDelta = delta;<br>    }<br>    Serial.print(&quot;Temperatur Delta : &quot;);<br>    Serial.print(delta);<br>    Serial.print(&quot; | Min Delta: &quot;);<br>    Serial.print(minDelta);<br>    Serial.print(&quot; | Max Delta: &quot;);<br>    Serial.println(maxDelta);<br>  }<br>}<br>void AHT20_begin() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xBE);  // 0xBE --&gt; init register for AHT2x<br>  Wire.endTransmission();<br>}<br><br>void startMeasurementAHT20() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xAC);  // 0xAC --&gt; start measurement<br>  Wire.write(0x33);  // 0x33 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL<br>  Wire.write(0x00);  // 0x00 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL_NOP<br>  Wire.endTransmission();<br>  measurementDelayAHT20 = millis();<br>  sensor_started = true;<br>  sensor_busy = true;<br>}<br><br>void checkbusyAHT20() {<br>  if (millis() &lt; measurementDelayAHT20) {<br>    measurementDelayAHT20 = millis();<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 200))) {<br>    sensor_started = false;<br>    sensor_busy = false;<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 80))) {<br>    Wire.requestFrom(0x38, 1);<br>    if (Wire.available()) {<br>      unsigned char c = Wire.read();<br>      if (!(c &amp; 0x80)) {<br>        sensor_busy = false;<br>      }<br>    }<br>  }<br>}<br><br><br>void getDataAHT20() {<br>  if (sensor_started &amp;&amp; !sensor_busy) {<br>    Wire.requestFrom(0x38, 7);  // Request 7 bytes of data<br><br>    unsigned char str[7] = { 0 };<br>    int index = 0;<br><br>    // Fault detection<br>    unsigned long timeoutMillis = 200;<br>    unsigned long startMillis = millis();<br><br><br><br>    while (Wire.available()) {<br>      str[index] = Wire.read();  // Receive a byte as character<br><br>      // Debug message: Output of each byte (binary) with labelling<br>      /***********************************************************/<br>      // Serial.print(&quot;Byte &quot;);<br>      // Serial.print(index);<br>      // Serial.print(&quot;: &quot;);<br>      // for (int i = 7; i &gt;= 0; --i) {<br>      //  Serial.print((str[index] &gt;&gt; i) &amp; 1);<br>      // }<br>      // Serial.println();<br>      /***********************************************************/<br><br><br>      index++;<br><br><br><br>      // Fault detection<br>      if (millis() - startMillis &gt; timeoutMillis) {<br>        Serial.println(&quot;Timeout while waiting for data from AHT20&quot;);<br>        return;<br>      }<br>    }<br>    if (index == 0 || (str[0] &amp; 0x80)) {<br>      Serial.println(&quot;Failed to get data from AHT20&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Check CRC<br>    uint8_t crc = 0xFF;<br>    for (uint8_t byteIndex = 0; byteIndex &lt; 6; byteIndex++) {<br>      crc ^= str[byteIndex];<br>      for (uint8_t bitIndex = 8; bitIndex &gt; 0; --bitIndex) {<br>        if (crc &amp; 0x80) {<br>          crc = (crc &lt;&lt; 1) ^ 0x31;<br>        } else {<br>          crc = (crc &lt;&lt; 1);<br>        }<br>      }<br>    }<br>    if (crc != str[6]) {<br>      Serial.println(&quot;CRC check failed&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Parse data<br>    float humi, temp;<br>    // Extract the raw data for humidity from the bytes<br>    unsigned long __humi = str[1];  // Byte 1: The first 8 bits of the raw data for humidity<br>    __humi &lt;&lt;= 8;                   // Move the bits 8 positions to the left<br>    __humi += str[2];               // Byte 2: Add the next 8 bits<br>    __humi &lt;&lt;= 4;                   // Move the bits 4 positions to the left<br>    __humi += str[3] &gt;&gt; 4;          // Byte 3: Add the last 4 bits (shifted to the right)<br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************************************************************/<br>    // Serial.print(&quot;Humidity (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__humi &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************************************************************/<br><br>    humi = (float)__humi / 1048576.0;<br>    humidity = humi * 100.0;<br><br>    // Extract the raw data for temperature from the bytes<br>    unsigned long __temp = str[3] &amp; 0x0f;  // Byte 3: The last 4 bits of the raw data for the temperature<br>    __temp &lt;&lt;= 8;                          // Move the bits 8 positions to the left<br>    __temp += str[4];                      // Byte 4: Add the next 8 bits<br>    __temp &lt;&lt;= 8;                          // Move the bits to the left again by 8 positions<br>    __temp += str[5];                      // Byte 5: Add the last 8 bits<br><br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************************************************************/<br>    // Serial.print(&quot;Temperature (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__temp &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************************************************************/<br><br>    temp = (float)__temp / 1048576.0 * 200.0 - 50.0;<br><br>    temperature_AHT20 = temp;<br><br>    sensor_started = false;<br>  }<br>}<br>void BMP280_begin() {<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xD0);  // 0xBE --&gt;  register for chip identification<br>  Wire.endTransmission();<br>  Wire.requestFrom(0x77, 1);<br>  uint8_t chip_ID = Wire.read();<br>  if (chip_ID == 0x58) {  // 0x58 --&gt; BMP280<br>    Serial.println(&quot;BMP280 found&quot;);<br>  } else {<br>    Serial.println(&quot;Unbekannter Sensor.&quot;);<br>  }<br><br><br><br>  // Generate soft-reset<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xE0);  // 0xE0 --&gt; Reset register<br>  Wire.write(0xB6);  // 0xB6 --&gt; Reset value for reset register<br>  Wire.endTransmission();<br><br><br><br>  // Wait for copy completion NVM data to image registers<br>  uint8_t stat_Reg = 1;<br><br>  while (stat_Reg == 1) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(0XF3);  // 0XF3 --&gt; Status register<br>    Wire.endTransmission();<br>    Wire.requestFrom((uint8_t)0x77, (byte)1);<br>    stat_Reg = Wire.read();<br>    Serial.println(stat_Reg);<br>  }<br><br>  // See datasheet 4.2.2 Trimming parameter readout<br><br><br>  // Array for storing the read values<br>  uint16_t values[12];<br><br>  // Addresses of the registers with coefficients Data to be read<br>  uint8_t registers[] = { 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E };<br><br>  for (int i = 0; i &lt; 12; i++) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(registers[i]);<br>    Wire.endTransmission();<br><br>    Wire.requestFrom((uint8_t)0x77, (byte)2);<br>    if (Wire.available() &gt;= 2) {<br>      values[i] = Wire.read() &lt;&lt; 8 | Wire.read();  // compose 16-bit value<br>    }<br>  }<br><br>  // Reverse the bytes for all 16-bit values (little endian / big endian)<br>  for (int i = 0; i &lt; 12; i++) {<br>    values[i] = (values[i] &gt;&gt; 8) | (values[i] &lt;&lt; 8);<br>  }<br><br>  // Assigning values to the variables<br>  _dig_T1 = values[0];<br>  _dig_T2 = values[1];<br>  _dig_T3 = values[2];<br>  _dig_P1 = values[3];<br>  _dig_P2 = values[4];<br>  _dig_P3 = values[5];<br>  _dig_P4 = values[6];<br>  _dig_P5 = values[7];<br>  _dig_P6 = values[8];<br>  _dig_P7 = values[9];<br>  _dig_P8 = values[10];<br>  _dig_P9 = values[11];<br><br><br>  // Debug message: Output of each byte (binary) with labelling<br>  /***********************************************************/<br>  // Serial.println(&quot;Temperature Values:&quot;);<br>  // Serial.print(&quot;_dig_T1: &quot;);<br>  // Serial.println(_dig_T1, HEX);<br>  // Serial.print(&quot;_dig_T2: &quot;);<br>  // Serial.println(_dig_T2, HEX);<br>  // Serial.print(&quot;_dig_T3: &quot;);<br>  // Serial.println(_dig_T3, HEX);<br><br>  // Serial.println(&quot;Pressure Values:&quot;);<br>  // Serial.print(&quot;_dig_P1: &quot;);<br>  // Serial.println(_dig_P1, HEX);<br>  // Serial.print(&quot;_dig_P2: &quot;);<br>  // Serial.println(_dig_P2, HEX);<br>  // Serial.print(&quot;_dig_P3: &quot;);<br>  // Serial.println(_dig_P3, HEX);<br>  // Serial.print(&quot;_dig_P4: &quot;);<br>  // Serial.println(_dig_P4, HEX);<br>  // Serial.print(&quot;_dig_P5: &quot;);<br>  // Serial.println(_dig_P5, HEX);<br>  // Serial.print(&quot;_dig_P6: &quot;);<br>  // Serial.println(_dig_P6, HEX);<br>  // Serial.print(&quot;_dig_P7: &quot;);<br>  // Seri</pre><p><strong>Penjelasan Kode</strong></p><p>Program ini bertujuan untuk membaca data dari dua sensor, yaitu AHT20 dan BMP280, menggunakan komunikasi I2C pada mikrokontroler ESP32, lalu menampilkannya di LCD 16x2 I2C. Di awal program, library yang dibutuhkan diimpor dan variabel-variabel untuk menyimpan data sensor serta parameter kalibrasi disiapkan. Pada fungsi setup(), komunikasi serial dan I2C diinisialisasi, dilanjutkan dengan inisialisasi sensor dan LCD. Fungsi loop() berjalan terus-menerus dan secara berkala (setiap 5 detik) membaca data suhu dan tekanan dari BMP280 serta suhu dan kelembapan dari AHT20.</p><p>Hasil pembacaan ini kemudian ditampilkan secara bergantian di LCD. Selain itu, program juga menghitung selisih suhu (delta) antara sensor BMP280 dan AHT20 untuk mengetahui perbedaan pengukuran antar sensor. Proses komunikasi dengan AHT20 dilakukan secara manual melalui fungsi-fungsi seperti startMeasurementAHT20(), checkbusyAHT20(), dan getDataAHT20(), tanpa menggunakan library khusus. Sedangkan untuk BMP280, inisialisasi dilakukan melalui BMP280_begin() dengan membaca langsung register konfigurasi dan kalibrasi sensor. Meskipun fungsi pembacaan suhu dan tekanan dari BMP280 belum terlihat lengkap di potongan kode ini, program secara umum sudah mencerminkan penggunaan komunikasi serial I2C untuk menghubungkan beberapa perangkat dan menampilkan data sensor di LCD.</p><h3>Hasil Akhir</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZUXJ3ylybEwI97OukKkzfw.jpeg" /><figcaption>Sistem Rangkaian</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*xEsUbNPqZ18A2fOAiAa3ZQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*6igD4NUe5HP-upBu3Q5NWg.gif" /><figcaption>Video</figcaption></figure><p>Hasil akhir dari proyek ini menunjukkan bahwa ESP32 berhasil menghubungkan dua sensor — AHT20 dan BMP280 — melalui komunikasi serial I2C dan menampilkan data hasil pembacaan ke layar LCD 16x2 secara bergantian. LCD menampilkan informasi suhu, tekanan udara, dan kelembapan secara real-time, dengan pembaruan data setiap lima detik. Selain itu, program juga menghitung dan mencetak selisih suhu (delta) antara kedua sensor ke Serial Monitor, yang dapat berguna untuk analisis akurasi atau kalibrasi sensor. Hasil ini membuktikan bahwa ESP32 mampu menangani lebih dari satu perangkat I2C sekaligus dan melakukan komunikasi data secara efisien, sesuai dengan tujuan utama proyek, yaitu mempraktikkan komunikasi serial dalam konteks Internet of Things (IoT).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f680e672ecc7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ESP32: Project #4 — Display & PWM]]></title>
            <link>https://medium.com/@bacotanadam/esp32-project-4-display-pwm-fc6c6e9bcddf?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc6c6e9bcddf</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Mon, 07 Apr 2025 14:49:08 GMT</pubDate>
            <atom:updated>2025-04-07T14:49:08.861Z</atom:updated>
            <content:encoded><![CDATA[<h3>ESP32: Project #4 — Display &amp; PWM</h3><p>II2260 : Internet Of Things — Adam Joaquin Girsang — 18223089</p><p><strong>Latar Belakang</strong></p><p>langsung kepada pengguna. Di sinilah peran <strong>display</strong> — seperti OLED atau LCD — menjadi vital untuk menampilkan informasi seperti suhu, kelembapan, atau status sistem. Selain itu, kontrol terhadap perangkat output seperti motor, LED, atau buzzer sering membutuhkan sinyal <strong>PWM (Pulse Width Modulation)</strong> agar dapat bekerja secara efisien dan presisi.</p><p>Proyek keempat ini bertujuan untuk mengeksplorasi integrasi antara ESP32 dengan modul display serta pemanfaatan sinyal PWM. Kombinasi keduanya memungkinkan pembuatan sistem interaktif yang tidak hanya mengontrol, tetapi juga menyampaikan informasi kepada pengguna secara langsung. Proyek ini juga membuka peluang untuk implementasi lebih lanjut, seperti dashboard portable, sistem indikator pintar, hingga kontrol intensitas pencahayaan atau kecepatan motor.</p><h3><strong>A. Display</strong></h3><p><strong>Persiapan</strong></p><p>Dalam pengerjaan tugas kali ini, saya memanfaatkan <strong>library Adafruit Liquid Crystal</strong> yang dikembangkan oleh <strong>Adafruit</strong> untuk mempermudah komunikasi antara ESP32 dan LCD.</p><p>Adapun komponen yang digunakan dalam proyek ini antara lain:</p><ul><li>ESP32 DOIT DEVKIT V1 Board</li><li>LCD 16×2 dengan modul I2C</li><li>Kabel jumper Female to Male</li><li>Breadboard sebagai media perakitan</li></ul><p><strong>Cara Pengerjaan</strong></p><p>Dalam proyek ini, kita akan menggunakan LCD yang dilengkapi dengan modul I2C serta empat kabel jumper — sebaiknya gunakan jenis Female to Female untuk kemudahan koneksi. Berikut adalah tahapan pengerjaannya:</p><ol><li><strong>Sambungkan LCD ke ESP32.</strong><br> Gunakan kabel jumper untuk menghubungkan pin GND pada LCD ke pin GND di ESP32, pin VCC ke VIN, kemudian sambungkan pin SDA ke D21 dan pin SCL ke D22 pada ESP32.</li><li><strong>Deteksi alamat I2C.</strong><br> Jalankan program pertama yang berfungsi untuk mendeteksi alamat I2C dari modul LCD. Hasil deteksi dapat dilihat melalui Serial Monitor di Arduino IDE (Tools &gt; Serial Monitor) dengan kecepatan baud rate 115200. Jika diperlukan, tekan tombol EN pada ESP32 untuk memicu proses pembacaan.</li><li><strong>Tampilkan informasi ke layar.</strong><br> Setelah mengetahui alamat I2C dari LCD, buat program kedua dengan memasukkan alamat tersebut agar LCD dapat digunakan untuk menampilkan teks atau data sesuai kebutuhan.</li></ol><p><strong>Kode</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Elf33o8GJ7rfa2KNjMI9cA.png" /></figure><pre>/*********<br>  Rui Santos<br>  Complete project details at https://randomnerdtutorials.com  <br>*********/<br><br>#include &lt;LiquidCrystal_I2C.h&gt;<br><br>// set the LCD number of columns and rows<br>int lcdColumns = 16;<br>int lcdRows = 2;<br><br>// set LCD address, number of columns and rows<br>// if you don&#39;t know your display address, run an I2C scanner sketch<br>LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows);  <br><br>void setup(){<br>  // initialize LCD<br>  lcd.init();<br>  // turn on LCD backlight                      <br>  lcd.backlight();<br>}<br><br>void loop(){<br>  // set cursor to first column, first row<br>  lcd.setCursor(0, 0);<br>  // print message<br>  lcd.print(&quot;Adam Love&quot;);<br>  delay(1000);<br>  // clears the display to print new message<br>  lcd.clear();<br>  // set cursor to first column, second row<br>  lcd.setCursor(0,1);<br>  lcd.print(&quot;Japrul&quot;);<br>  delay(1000);<br>  lcd.clear(); <br>}</pre><p><strong>Hasil</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AFnuFExzwUCf9kE_0ullXg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uA40jvadMoyiEI5IoPcxtA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*CcXRvdRQlTRg-5LW4rIMGg.gif" /><figcaption>Cuplikan Hasil</figcaption></figure><h3><strong>B. PWM (Pulse with Modulation)</strong></h3><p><strong>Persiapan</strong></p><p>Pada bagian ini, kita akan mengatur tingkat kecerahan LED menggunakan sinyal <strong>PWM (Pulse Width Modulation)</strong> dari ESP32.</p><p><strong>Komponen yang Dibutuhkan:</strong></p><ul><li>ESP32 DOIT DEVKIT V1</li><li>LED</li><li>Resistor 220 ohm</li><li>Breadboard</li><li>Kabel jumper</li></ul><p><strong>Rangkaian:</strong></p><p>Hubungkan <strong>kaki anoda (+)</strong> dari LED ke <strong>pin GPIO 18</strong> pada ESP32 (pin ini bisa disesuaikan jika diperlukan).<br> Sementara itu, <strong>kaki katoda (-)</strong> dihubungkan ke <strong>GND</strong> melalui <strong>resistor 220 ohm</strong> untuk membatasi arus yang masuk ke LED.</p><p><strong>Kode</strong></p><pre>/*<br>  Rui Santos &amp; Sara Santos - Random Nerd Tutorials<br>  Complete project details at https://RandomNerdTutorials.com/esp32-pwm-arduino-ide/<br>  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  <br>  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.<br>*/<br><br>// the number of the LED pin<br>const int ledPin = 18;  // 18 corresponds to GPIO 18<br><br>void setup() {<br>  // set the LED as an output<br>  pinMode(ledPin, OUTPUT);<br>}<br><br>void loop(){<br>  // increase the LED brightness<br>  for(int dutyCycle = 0; dutyCycle &lt;= 255; dutyCycle++){   <br>    // changing the LED brightness with PWM<br>    analogWrite(ledPin, dutyCycle);<br>    delay(5);<br>  }<br><br>  // decrease the LED brightness<br>  for(int dutyCycle = 255; dutyCycle &gt;= 0; dutyCycle--){<br>    // changing the LED brightness with PWM<br>    analogWrite(ledPin, dutyCycle);<br>    delay(5);<br>  }<br>}</pre><p><strong>Hasil</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bBxj3nOvsvFDAUTjo7UlRg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*xTGHcpoqXiPGPgPk_jQhig.gif" /><figcaption>Cuplikan hasil “Breathing Effect”</figcaption></figure><p>Setelah program berhasil diunggah ke ESP32, LED akan menyala dengan intensitas cahaya yang berubah secara perlahan — mulai dari redup, kemudian secara bertahap menjadi terang, lalu kembali meredup. Efek ini terus berulang dalam pola yang halus dan teratur. Pola pencahayaan seperti ini dikenal dengan sebutan <strong>“breathing effect”</strong> karena menyerupai ritme napas manusia yang perlahan mengembang dan mengempis.</p><p>Efek ini dihasilkan dengan memanfaatkan fitur <strong>PWM (Pulse Width Modulation)</strong> pada ESP32, di mana <strong>duty cycle</strong> dari sinyal PWM diatur naik-turun secara bertahap. Duty cycle adalah proporsi waktu sinyal berada dalam keadaan “ON” dalam satu siklus. Semakin besar duty cycle, semakin terang LED menyala, dan sebaliknya.</p><p>Implementasi efek breathing ini juga menunjukkan kemampuan ESP32 dalam menghasilkan output analog semu (melalui PWM) untuk mengendalikan perangkat elektronik dengan presisi. Efek visual ini sering digunakan dalam desain produk elektronik untuk indikator daya atau status perangkat karena tampilannya yang menarik namun tidak mengganggu.</p><p>Secara keseluruhan, hasil akhir proyek ini membuktikan bahwa ESP32 mampu mengontrol output secara dinamis menggunakan PWM, dan menjadi pondasi penting untuk aplikasi IoT yang membutuhkan kendali perangkat berbasis intensitas seperti pencahayaan pintar, kontrol motor, atau indikator visual.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc6c6e9bcddf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ESP32: Project #3 — Sensor]]></title>
            <link>https://medium.com/@bacotanadam/esp32-project-3-sensor-269f3d4c8cfb?source=rss-dab126377ed9------2</link>
            <guid isPermaLink="false">https://medium.com/p/269f3d4c8cfb</guid>
            <dc:creator><![CDATA[Adam Joaquin Girsang]]></dc:creator>
            <pubDate>Sun, 23 Mar 2025 13:55:37 GMT</pubDate>
            <atom:updated>2025-03-23T13:55:37.576Z</atom:updated>
            <content:encoded><![CDATA[<h3>ESP32: Project #3 — Sensor</h3><p>II2260 : Internet Of Things — Adam Joaquin Girsang — 18223089</p><h3>Latar Belakang</h3><p>Sensor adalah devais yang membaca informasi lingkungan. Dalam hal ini, besaran alam diraba oleh sensor dan dikonversi menjadi besaran listrik. Besaran listrik ini diolah menjadi informasi dan makna lingkungan yang teraba, yang disebut sebagai persepsi.</p><p>Berdasarkan sumber stimulus, kondisi yang diraba dapat dikategorikan sebagai proprioception dan exteroception. Sensor proprioception meraba kondisi internal sistem, stimulus berasal dari dalam sistem, seperti kapasitas baterai, temperatur internal. Sensor exteroception meraba kondisi eksternal, stimulus berasal dari lingkungan, seperti vision, audition, distance, etc. Gabungan dari sensor propriocetive dan exteroceptive membentuk sistem persepsi suatu sistem peraba.</p><p>Proyek ini bertujuan untuk mengeksplorasi bagaimana sensor dapat diintegrasikan dengan ESP32 guna membangun sistem pemantauan yang efisien. Dengan memahami cara kerja sensor serta teknik pengolahan datanya, kita dapat mengembangkan solusi yang lebih inovatif dan aplikatif dalam berbagai bidang, seperti pertanian, kesehatan, dan smart home.</p><h3>Preparation</h3><p><strong>Library yang Diperlukan</strong><br>Sebelum menjalankan kode, pastikan library berikut telah diinstal di <strong>Arduino IDE</strong> melalui <strong>Library Manager</strong>:</p><ul><li><strong>Adafruit AHTX0</strong> (untuk sensor AHT20)</li><li><strong>Adafruit BMP280</strong> (untuk sensor BMP280)</li><li><strong>Adafruit Unified Sensor</strong> (terinstall otomatis sebagai dependensi)</li><li><strong>Adafruit BusIO</strong> (terinstall otomatis sebagai dependensi)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2CAMHSzsxYDGPswV_8y1zg.jpeg" /></figure><h3>Eksekusi</h3><p>Berikut kode yang di-<em>upload</em> di Arduino IDE:</p><pre>#include &lt;Wire.h&gt;<br><br><br>// BMP280<br>/***********/<br>float temperature_BMP280;<br>float pressure;<br><br><br>// Temperature variable<br>int32_t _t_fine;<br><br><br>// Trimming parameters<br>uint16_t _dig_T1;<br>int16_t _dig_T2;<br>int16_t _dig_T3;<br><br>uint16_t _dig_P1;<br>int16_t _dig_P2;<br>int16_t _dig_P3;<br>int16_t _dig_P4;<br>int16_t _dig_P5;<br>int16_t _dig_P6;<br>int16_t _dig_P7;<br>int16_t _dig_P8;<br>int16_t _dig_P9;<br>/***********/<br><br><br><br>//AHT20<br>/***********/<br>float temperature_AHT20;<br>float humidity;<br>bool sensor_started = false;<br>bool sensor_busy = false;<br>unsigned long measurementDelayAHT20 = 0;<br>/***********/<br><br><br><br>float delta = 0;<br>float minDelta = 10;<br>float maxDelta = 0;<br><br><br>//  Heartbeat<br>unsigned long HeartbeatMillis = 0;<br>const long Heartbeatinterval = 5000;<br><br><br><br><br>void setup() {<br>  Serial.begin(115200);<br>  Wire.begin();<br>  AHT20_begin();<br>  BMP280_begin();<br>  startMeasurementAHT20();<br>}<br><br>void loop() {<br><br>  checkbusyAHT20();<br>  getDataAHT20();<br><br>  unsigned long currentMillis = millis();<br>  if (currentMillis - HeartbeatMillis &gt;= Heartbeatinterval) {<br>    HeartbeatMillis = currentMillis;<br><br><br>    //BMP280<br>    readTemperatureBMP280();<br>    Serial.print(&quot;Temperatur: &quot;);<br>    Serial.print(temperature_BMP280);<br>    Serial.println(&quot; C&quot;);<br><br>    readPressureBMP280();<br>    Serial.print(&quot;Druck: &quot;);<br>    Serial.print(pressure);<br>    Serial.println(&quot; hPa&quot;);<br><br><br>    // AHT20<br>    startMeasurementAHT20();<br><br>    Serial.print(&quot;Humidity: &quot;);<br>    Serial.print(humidity);<br>    Serial.println(&quot; %&quot;);<br><br>    Serial.print(&quot;Temperatur: &quot;);<br>    Serial.print(temperature_AHT20);<br>    Serial.println(&quot; C&quot;);<br><br><br><br>    // Calculate the delta between the temperature values AHT20 and BMP280<br>    delta = (temperature_BMP280 &gt; temperature_AHT20) ? (temperature_BMP280 - temperature_AHT20) : (temperature_AHT20 - temperature_BMP280);<br><br>    if (delta &lt; minDelta) {<br>      minDelta = delta;<br>    }<br>    if (delta &gt; maxDelta) {<br>      maxDelta = delta;<br>    }<br>    Serial.print(&quot;Temperatur Delta : &quot;);<br>    Serial.print(delta);<br>    Serial.print(&quot; | Min Delta: &quot;);<br>    Serial.print(minDelta);<br>    Serial.print(&quot; | Max Delta: &quot;);<br>    Serial.println(maxDelta);<br>  }<br>}<br>void AHT20_begin() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xBE);  // 0xBE --&gt; init register for AHT2x<br>  Wire.endTransmission();<br>}<br><br>void startMeasurementAHT20() {<br>  Wire.beginTransmission(0x38);<br>  Wire.write(0xAC);  // 0xAC --&gt; start measurement<br>  Wire.write(0x33);  // 0x33 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL<br>  Wire.write(0x00);  // 0x00 --&gt; not really documented what it does, but it&#39;s called MEASUREMENT_CTRL_NOP<br>  Wire.endTransmission();<br>  measurementDelayAHT20 = millis();<br>  sensor_started = true;<br>  sensor_busy = true;<br>}<br><br>void checkbusyAHT20() {<br>  if (millis() &lt; measurementDelayAHT20) {<br>    measurementDelayAHT20 = millis();<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 200))) {<br>    sensor_started = false;<br>    sensor_busy = false;<br>  }<br><br>  if (sensor_started &amp;&amp; sensor_busy &amp;&amp; ((millis() - measurementDelayAHT20 &gt;= 80))) {<br>    Wire.requestFrom(0x38, 1);<br>    if (Wire.available()) {<br>      unsigned char c = Wire.read();<br>      if (!(c &amp; 0x80)) {<br>        sensor_busy = false;<br>      }<br>    }<br>  }<br>}<br><br><br>void getDataAHT20() {<br>  if (sensor_started &amp;&amp; !sensor_busy) {<br>    Wire.requestFrom(0x38, 7);  // Request 7 bytes of data<br><br>    unsigned char str[7] = { 0 };<br>    int index = 0;<br><br>    // Fault detection<br>    unsigned long timeoutMillis = 200;<br>    unsigned long startMillis = millis();<br><br><br><br>    while (Wire.available()) {<br>      str[index] = Wire.read();  // Receive a byte as character<br><br>      // Debug message: Output of each byte (binary) with labelling<br>      /*********************/<br>      // Serial.print(&quot;Byte &quot;);<br>      // Serial.print(index);<br>      // Serial.print(&quot;: &quot;);<br>      // for (int i = 7; i &gt;= 0; --i) {<br>      //  Serial.print((str[index] &gt;&gt; i) &amp; 1);<br>      // }<br>      // Serial.println();<br>      /*********************/<br><br><br>      index++;<br><br><br><br>      // Fault detection<br>      if (millis() - startMillis &gt; timeoutMillis) {<br>        Serial.println(&quot;Timeout while waiting for data from AHT20&quot;);<br>        return;<br>      }<br>    }<br>    if (index == 0 || (str[0] &amp; 0x80)) {<br>      Serial.println(&quot;Failed to get data from AHT20&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Check CRC<br>    uint8_t crc = 0xFF;<br>    for (uint8_t byteIndex = 0; byteIndex &lt; 6; byteIndex++) {<br>      crc ^= str[byteIndex];<br>      for (uint8_t bitIndex = 8; bitIndex &gt; 0; --bitIndex) {<br>        if (crc &amp; 0x80) {<br>          crc = (crc &lt;&lt; 1) ^ 0x31;<br>        } else {<br>          crc = (crc &lt;&lt; 1);<br>        }<br>      }<br>    }<br>    if (crc != str[6]) {<br>      Serial.println(&quot;CRC check failed&quot;);<br>      sensor_started = false;<br>      return;<br>    }<br><br>    // Parse data<br>    float humi, temp;<br>    // Extract the raw data for humidity from the bytes<br>    unsigned long __humi = str[1];  // Byte 1: The first 8 bits of the raw data for humidity<br>    __humi &lt;&lt;= 8;                   // Move the bits 8 positions to the left<br>    __humi += str[2];               // Byte 2: Add the next 8 bits<br>    __humi &lt;&lt;= 4;                   // Move the bits 4 positions to the left<br>    __humi += str[3] &gt;&gt; 4;          // Byte 3: Add the last 4 bits (shifted to the right)<br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************/<br>    // Serial.print(&quot;Humidity (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__humi &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************/<br><br>    humi = (float)__humi / 1048576.0;<br>    humidity = humi * 100.0;<br><br>    // Extract the raw data for temperature from the bytes<br>    unsigned long __temp = str[3] &amp; 0x0f;  // Byte 3: The last 4 bits of the raw data for the temperature<br>    __temp &lt;&lt;= 8;                          // Move the bits 8 positions to the left<br>    __temp += str[4];                      // Byte 4: Add the next 8 bits<br>    __temp &lt;&lt;= 8;                          // Move the bits to the left again by 8 positions<br>    __temp += str[5];                      // Byte 5: Add the last 8 bits<br><br><br>    // Debug message: Output of the value created after the bit shift (binary)<br>    /************************/<br>    // Serial.print(&quot;Temperature (raw): &quot;);<br>    // for (int i = 19; i &gt;= 0; --i) {<br>    //  Serial.print((__temp &gt;&gt; i) &amp; 1);<br>    // }<br>    // Serial.println();<br>    /************************/<br><br>    temp = (float)__temp / 1048576.0 * 200.0 - 50.0;<br><br>    temperature_AHT20 = temp;<br><br>    sensor_started = false;<br>  }<br>}<br>void BMP280_begin() {<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xD0);  // 0xBE --&gt;  register for chip identification<br>  Wire.endTransmission();<br>  Wire.requestFrom(0x77, 1);<br>  uint8_t chip_ID = Wire.read();<br>  if (chip_ID == 0x58) {  // 0x58 --&gt; BMP280<br>    Serial.println(&quot;BMP280 found&quot;);<br>  } else {<br>    Serial.println(&quot;Unbekannter Sensor.&quot;);<br>  }<br><br><br><br>  // Generate soft-reset<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xE0);  // 0xE0 --&gt; Reset register<br>  Wire.write(0xB6);  // 0xB6 --&gt; Reset value for reset register<br>  Wire.endTransmission();<br><br><br><br>  // Wait for copy completion NVM data to image registers<br>  uint8_t stat_Reg = 1;<br><br>  while (stat_Reg == 1) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(0XF3);  // 0XF3 --&gt; Status register<br>    Wire.endTransmission();<br>    Wire.requestFrom((uint8_t)0x77, (byte)1);<br>    stat_Reg = Wire.read();<br>    Serial.println(stat_Reg);<br>  }<br><br>  // See datasheet 4.2.2 Trimming parameter readout<br><br><br>  // Array for storing the read values<br>  uint16_t values[12];<br><br>  // Addresses of the registers with coefficients Data to be read<br>  uint8_t registers[] = { 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E };<br><br>  for (int i = 0; i &lt; 12; i++) {<br>    Wire.beginTransmission(0x77);<br>    Wire.write(registers[i]);<br>    Wire.endTransmission();<br><br>    Wire.requestFrom((uint8_t)0x77, (byte)2);<br>    if (Wire.available() &gt;= 2) {<br>      values[i] = Wire.read() &lt;&lt; 8 | Wire.read();  // compose 16-bit value<br>    }<br>  }<br><br>  // Reverse the bytes for all 16-bit values (little endian / big endian)<br>  for (int i = 0; i &lt; 12; i++) {<br>    values[i] = (values[i] &gt;&gt; 8) | (values[i] &lt;&lt; 8);<br>  }<br><br>  // Assigning values to the variables<br>  _dig_T1 = values[0];<br>  _dig_T2 = values[1];<br>  _dig_T3 = values[2];<br>  _dig_P1 = values[3];<br>  _dig_P2 = values[4];<br>  _dig_P3 = values[5];<br>  _dig_P4 = values[6];<br>  _dig_P5 = values[7];<br>  _dig_P6 = values[8];<br>  _dig_P7 = values[9];<br>  _dig_P8 = values[10];<br>  _dig_P9 = values[11];<br><br><br>  // Debug message: Output of each byte (binary) with labelling<br>  /*********************/<br>  // Serial.println(&quot;Temperature Values:&quot;);<br>  // Serial.print(&quot;_dig_T1: &quot;);<br>  // Serial.println(_dig_T1, HEX);<br>  // Serial.print(&quot;_dig_T2: &quot;);<br>  // Serial.println(_dig_T2, HEX);<br>  // Serial.print(&quot;_dig_T3: &quot;);<br>  // Serial.println(_dig_T3, HEX);<br><br>  // Serial.println(&quot;Pressure Values:&quot;);<br>  // Serial.print(&quot;_dig_P1: &quot;);<br>  // Serial.println(_dig_P1, HEX);<br>  // Serial.print(&quot;_dig_P2: &quot;);<br>  // Serial.println(_dig_P2, HEX);<br>  // Serial.print(&quot;_dig_P3: &quot;);<br>  // Serial.println(_dig_P3, HEX);<br>  // Serial.print(&quot;_dig_P4: &quot;);<br>  // Serial.println(_dig_P4, HEX);<br>  // Serial.print(&quot;_dig_P5: &quot;);<br>  // Serial.println(_dig_P5, HEX);<br>  // Serial.print(&quot;_dig_P6: &quot;);<br>  // Serial.println(_dig_P6, HEX);<br>  // Serial.print(&quot;_dig_P7: &quot;);<br>  // Serial.println(_dig_P7, HEX);<br>  // Serial.print(&quot;_dig_P8: &quot;);<br>  // Serial.println(_dig_P8, HEX);<br>  // Serial.print(&quot;_dig_P9: &quot;);<br>  // Serial.println(_dig_P9, HEX);<br>  /*********************/<br><br><br><br><br>  // Set in sleep mode to provide write access to the “config” register<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF4);  // 0XF3 --&gt; Contol register<br>  Wire.write(0b00);  // 00   --&gt; sleep mode<br>  Wire.endTransmission();<br><br>  <br>  // SAMPLING_NONE = 0b000<br>  // SAMPLING_X1   = 0b001<br>  // SAMPLING_X2   = 0b010<br>  // SAMPLING_X4   = 0b011<br>  // SAMPLING_X8   = 0b100<br>  // SAMPLING_X16  = 0b101<br>  <br>  // MODE_SLEEP  = 0b00<br>  // MODE_FORCED = 0b01<br>  // MODE_NORMAL = 0b11<br><br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF4);<br>  uint8_t configValues = ((0b001 &lt;&lt; 5) | (0b011 &lt;&lt; 2) | 0b11);<br>  //                       temp           press         mode<br>  Wire.write(configValues);<br>  Wire.endTransmission();<br><br>  delay(10);<br><br>  // Set register 0xF5 “config”  ** See datasheet 5.4.6 for details”<br>  // STANDBY_MS_0_5  = 0b000<br>  // STANDBY_MS_10   = 0b110<br>  // STANDBY_MS_20   = 0b111<br>  // STANDBY_MS_62_5 = 0b001<br>  // STANDBY_MS_125  = 0b010<br>  // STANDBY_MS_250  = 0b011<br>  // STANDBY_MS_500  = 0b100<br>  // STANDBY_MS_1000 = 0b101<br><br>  // FILTER_OFF = 0b000<br>  // FILTER_X2 = 0b001<br>  // FILTER_X4 = 0b010<br>  // FILTER_X8 = 0b011<br>  // FILTER_X16 = 0b100<br>  <br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF5);<br>  configValues = (0b110 &lt;&lt; 5) | (0b100 &lt;&lt; 2);<br>  //              standby        filter<br>  Wire.write(configValues);<br>  Wire.endTransmission();<br><br><br><br>  // Wait for first completed conversion<br>  delay(100);<br><br>  // Debug message: Output    of   CTRL_MEAS &amp;  CONFIG (binary)<br>  /*********************/<br>  // readAndDisplayRegister(0x77, 0xF4, &quot;CTRL_MEAS&quot;);<br>  // readAndDisplayRegister(0x77, 0xF5, &quot;CONFIG&quot;);<br>  /*********************/<br>}<br><br><br><br>void readTemperatureBMP280() {<br>  int32_t var1, var2, adc_T;<br><br>  // Read temperature registers<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xFA);<br>  Wire.endTransmission();<br>  Wire.requestFrom((uint8_t)0x77, (byte)3);<br><br>  adc_T = (Wire.read() &lt;&lt; 16) | (Wire.read() &lt;&lt; 8) | Wire.read();<br>  adc_T &gt;&gt;= 4;<br><br>  // See datasheet 4.2.3 Compensation formulas<br>  var1 = ((((adc_T &gt;&gt; 3) - ((int32_t)_dig_T1 &lt;&lt; 1))) * ((int32_t)_dig_T2)) &gt;&gt; 11;<br><br>  var2 = (((((adc_T &gt;&gt; 4) - ((int32_t)_dig_T1)) * ((adc_T &gt;&gt; 4) - ((int32_t)_dig_T1))) &gt;&gt; 12) * ((int32_t)_dig_T3)) &gt;&gt; 14;<br><br>  _t_fine = var1 + var2;<br><br>  float T = (((_t_fine * 5) + 128) &gt;&gt; 8);<br><br>  temperature_BMP280 = T / 100;<br>}<br><br><br><br>void readPressureBMP280() {<br>  int64_t var1;<br>  int64_t var2;<br>  int64_t p;<br>  int32_t adc_P;<br><br>  // Read temperature for t_fine<br>  readTemperatureBMP280();<br><br>  // Read pressure registers<br>  Wire.beginTransmission(0x77);<br>  Wire.write(0xF7);<br>  Wire.endTransmission();<br>  Wire.requestFrom((uint8_t)0x77, (byte)3);<br>  adc_P = (Wire.read() &lt;&lt; 16) | (Wire.read() &lt;&lt; 8) | Wire.read();<br><br>  adc_P &gt;&gt;= 4;<br><br>  // See datasheet 4.2.3 Compensation formulas<br>  var1 = ((int64_t)_t_fine) - 128000;<br>  var2 = var1 * var1 * (int64_t)_dig_P6;<br>  var2 = var2 + ((var1 * (int64_t)_dig_P5) &lt;&lt; 17);<br>  var2 = var2 + (((int64_t)_dig_P4) &lt;&lt; 35);<br>  var1 = ((var1 * var1 * (int64_t)_dig_P3) &gt;&gt; 8) + ((var1 * (int64_t)_dig_P2) &lt;&lt; 12);<br>  var1 = (((((int64_t)1) &lt;&lt; 47) + var1)) * ((int64_t)_dig_P1) &gt;&gt; 33;<br><br>  if (var1 == 0) {<br>    return;  // avoid exception caused by division by zero<br>  }<br>  p = 1048576 - adc_P;<br>  p = (((p &lt;&lt; 31) - var2) * 3125) / var1;<br>  var1 = (((int64_t)_dig_P9) * (p &gt;&gt; 13) * (p &gt;&gt; 13)) &gt;&gt; 25;<br>  var2 = (((int64_t)_dig_P8) * p) &gt;&gt; 19;<br><br>  p = ((p + var1 + var2) &gt;&gt; 8) + (((int64_t)_dig_P7) &lt;&lt; 4);<br><br>  pressure = p / 25600;<br>}<br><br><br><br>void readAndDisplayRegister(uint8_t deviceAddress, byte registerAddress, const char* registerName) {<br>  Wire.beginTransmission(deviceAddress);<br>  Wire.write(registerAddress);<br>  Wire.endTransmission();<br><br>  Wire.requestFrom(deviceAddress, (byte)1);<br>  if (Wire.available()) {<br>    uint8_t registerValue = Wire.read();<br><br>    Serial.print(registerName);<br>    Serial.print(&quot; (&quot;);<br>    Serial.print(registerAddress, HEX);<br>    Serial.print(&quot;) : 0b&quot;);<br><br>    for (int i = 7; i &gt;= 0; i--) {<br>      Serial.print((registerValue &amp; (1 &lt;&lt; i)) ? &#39;1&#39; : &#39;0&#39;);<br>    }<br><br>    Serial.println();<br>  } else {<br>    Serial.println(&quot;Fehler beim Lesen des Registers&quot;);<br>  }<br>}</pre><p>Kode ini digunakan untuk membaca data suhu, tekanan udara, dan kelembaban dari dua sensor, yaitu <strong>BMP280</strong> dan <strong>AHT20</strong>, menggunakan komunikasi <strong>I2C</strong> dengan ESP32. Program ini menginisialisasi kedua sensor, mengambil data secara berkala, lalu menampilkannya melalui <strong>Serial Monitor</strong>. Selain itu, kode ini juga menghitung perbedaan (delta) antara suhu yang dibaca dari kedua sensor, serta mencatat nilai minimum dan maksimum dari delta tersebut.</p><p>Secara garis besar, program bekerja dengan siklus berikut:</p><ol><li><strong>Inisialisasi sensor</strong> → Mengatur sensor BMP280 dan AHT20 untuk mulai bekerja.</li><li><strong>Pengambilan data</strong> → Membaca suhu dan tekanan dari BMP280, serta suhu dan kelembaban dari AHT20.</li><li><strong>Perhitungan delta suhu</strong> → Menghitung selisih suhu antara kedua sensor.</li><li><strong>Menampilkan data</strong> → Mengirim hasil pembacaan ke <strong>Serial Monitor</strong> setiap 5 detik.</li></ol><p>Program ini cocok untuk aplikasi yang membutuhkan pemantauan suhu, tekanan udara, dan kelembaban secara real-time, misalnya dalam sistem pemantauan cuaca atau lingkungan.</p><h3>Hasil</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tV-Mz4-r5_skxO8Vn1HArQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pfDqAeGWh83-1xaSWlQXiQ.png" /><figcaption>Hasil Uji</figcaption></figure><p>Output yang ditampilkan di Serial Monitor menunjukkan hasil pembacaan dari sensor yang digunakan pada ESP32, dengan sensor lingkungan BMP280 atau AHT20. Nilai tekanan udara (Druck) terbaca sebesar 922.00 hPa, yang mengindikasikan kondisi atmosfer saat ini. Selain itu, kelembaban udara (Humidity) tercatat sebesar 67.42%, yang menunjukkan tingkat kelembaban di sekitar sensor. Suhu yang terbaca dari sensor menunjukkan dua nilai, yaitu 29.03°C dan 28.65°C, yang mungkin berasal dari dua sensor yang berbeda. Perbedaan suhu antara kedua sensor ini ditampilkan sebagai Temperature Delta, dengan nilai sekitar 0.40°C, dan memiliki rentang variasi minimum 0.38°C serta maksimum 0.45°C. Secara keseluruhan, output ini menunjukkan bahwa perangkat berhasil membaca data sensor secara berkala tanpa adanya error yang terdeteksi.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=269f3d4c8cfb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>