The Wemos D1 Mini is a compact, Wi-Fi-enabled development board based on the ESP8266 chip, making it a popular choice for IoT projects. This guide demonstrates how to use the Wemos D1 Mini to both publish and subscribe to data using the MQTT protocol. By following this guide, you will learn how to set up the Wemos D1 Mini to collect data from sensors, publish that data to an MQTT broker, and subscribe to a topic to receive and act upon incoming messages.

Overview of Wemos D1 Mini

The Wemos D1 Mini is a small development board that offers built-in Wi-Fi capabilities, making it ideal for Internet of Things (IoT) projects. It is based on the ESP8266 chip, which provides the power and versatility needed for various applications, including data acquisition, remote monitoring, and control systems.

Key features include:

• Wi-Fi Connectivity: Connect to wireless networks for remote data transmission and control.

• Compact Size: Ideal for projects with space constraints.

• Arduino IDE Compatibility: Program the Wemos D1 Mini using the popular Arduino IDE, which is beginner-friendly and widely supported.

• Breadboard-Friendly: Easy integration with breadboards for prototyping.

Explanation of MQTT Protocol

MQTT (Message Queuing Telemetry Transport) is a lightweight messaging protocol designed for small sensors and mobile devices in low-bandwidth, high-latency, or unreliable networks. MQTT follows a publish/subscribe model, where clients publish messages to topics, and other clients subscribe to those topics to receive the messages.

Key concepts include:

• Broker: The server that manages all the communication between clients.

• Topics: Named channels through which messages are sent.

• Quality of Service (QoS): Levels that define the guarantee of message delivery.

Importance of Data Publishing and Subscribing

In MQTT, data is exchanged between devices using the publish/subscribe model. A device can publish data to a specific topic, and any device subscribed to that topic will receive the data. This method allows for real-time communication and decouples the data producers from consumers, enhancing scalability and efficiency in IoT systems.

Hardware and Software Requirements

Necessary Components

• Wemos D1 Mini: The main microcontroller board used for both publishing and subscribing to data.

• Sensors and Actuators: Sensors (e.g., temperature, humidity) for data collection and actuators (e.g., LEDs, relays) for responding to received data.

Software Tools

• Arduino IDE: The primary development environment for programming the Wemos D1 Mini.

• MQTT Broker (e.g., Mosquitto): The server that handles the routing of messages between MQTT clients.

• MQTT Client Tools: Tools like MQTT.fx or MQTT Explorer for testing and monitoring the MQTT communication.

Setting Up the Development Environment

Installing Arduino IDE

1. Download and Install: Obtain the Arduino IDE from the official Arduino website.

2. Configure for ESP8266: Add support for the ESP8266 by including the appropriate board manager URL and installing the ESP8266 package via the Boards Manager.

Adding Required Libraries

• ESP8266WiFi: This library allows the Wemos D1 Mini to connect to Wi-Fi networks.

• PubSubClient: A library for MQTT communication, enabling the Wemos D1 Mini to publish and subscribe to MQTT topics.

Install these libraries using the Arduino IDE’s Library Manager.

Configuring the MQTT Broker

To enable MQTT communication, set up an MQTT broker like Mosquitto:

1. Install Mosquitto: Follow installation instructions for your operating system.

2. Configure Broker: Customize the broker configuration as needed, including security settings, topic management, and user authentication.

3. Start the Broker: Ensure that the Mosquitto service is running and accessible.

Basic Concepts of MQTT Protocol

MQTT Architecture

In MQTT, communication is managed by a central broker that connects multiple clients. Clients can publish messages to topics, and the broker ensures that these messages are delivered to all clients subscribed to the corresponding topics.

Clients

In this project, the Wemos D1 Mini acts as an MQTT client that can both publish data to and subscribe to topics managed by the MQTT broker.

Broker

The MQTT broker is the intermediary that handles all message routing between clients. It ensures that messages published to a topic are delivered to all subscribed clients.

Topics and Messages

Messages in MQTT are organized into topics. Devices publish messages to topics, and other devices can subscribe to these topics to receive the messages. Topics are hierarchical and can be structured to organize data efficiently.

Quality of Service (QoS) Levels

MQTT provides three QoS levels:

• QoS 0: At most once delivery, where the message is delivered once with no confirmation.

• QoS 1: At least once delivery, where the message is guaranteed to be delivered at least once but may be delivered multiple times.

• QoS 2: Exactly once delivery, ensuring the message is delivered only once and with confirmation from the receiver.

Programming the Wemos D1 for Data Publishing and Subscribing

Connecting Sensors and Actuators to Wemos D1

First, connect your sensors and actuators to the Wemos D1 Mini:

• Sensors: Connect sensors to the appropriate GPIO pins. For instance, a temperature sensor could be connected to a digital pin like D1.

• Actuators: Connect actuators (e.g., an LED) to other GPIO pins to allow the Wemos D1 Mini to act on received data.

Writing Sketch for Data Collection

Create an Arduino sketch that reads data from the connected sensor:

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";
const char* mqtt_server = "your_MQTT_SERVER";

WiFiClient espClient;
PubSubClient client(espClient);

const int sensorPin = A0; // Analog sensor connected to pin A0
const int actuatorPin = D1; // Actuator connected to pin D1

void setup() {
  pinMode(actuatorPin, OUTPUT);
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  reconnect();
}

void setup_wifi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("WemosClient")) {
      client.subscribe("topic/sub");  // Subscribe to the topic for receiving data
    } else {
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  int sensorValue = analogRead(sensorPin);
  String payload = "Sensor value: " + String(sensorValue);
  client.publish("topic/pub", payload.c_str());  // Publish sensor data to the topic

  delay(5000); // Delay between readings and publishing
}

This sketch reads data from a sensor connected to A0, publishes the data to an MQTT topic, and subscribes to another topic to receive commands.

Implementing MQTT Callback for Subscribing

The callback function processes incoming messages from the subscribed topic and can trigger an actuator:

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("]: ");

  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }

  Serial.println(message);

  // Example: Act on incoming data (e.g., turn on/off an LED)
  if (message == "ON") {
    digitalWrite(actuatorPin, HIGH);  // Turn on actuator
  } else if (message == "OFF") {
    digitalWrite(actuatorPin, LOW);   // Turn off actuator
  }
}

This callback function listens for messages on the subscribed topic, and if it receives "ON," it turns on an actuator (e.g., an LED), and if it receives "OFF," it turns the actuator off.

Testing and Debugging

Initial Tests for Connectivity

Verify that the Wemos D1 Mini can connect to your Wi-Fi network and the MQTT broker. Use the Serial Monitor to check for successful connections.

Verifying Data Publishing and Subscribing

Use an MQTT client tool like MQTT.fx or MQTT Explorer to:

• Monitor the Published Data: Subscribe to the topic where the Wemos D1 Mini publishes sensor data and verify the messages.

• Test Subscribing: Send commands (e.g., "ON" or "OFF") to the topic the Wemos D1 Mini is subscribed to and observe the behavior of the connected actuator.

Common Issues and Troubleshooting

• Wi-Fi Connection Issues: Ensure the correct SSID and password are used, and that the Wi-Fi signal is strong.

• MQTT Connection Issues: Verify the broker's address, port, and ensure that the broker is running and accessible.

• Data Not Published/Subscribed: Check the topic names and ensure that both publishing and subscribing are configured correctly in the code.

Conclusion

Summary of Steps

This guide covered how to use the Wemos D1 Mini to both publish and subscribe to data using the MQTT protocol. We started by setting up the development environment, connecting sensors and actuators, programming the Wemos D1 Mini, and then testing the entire setup.

Benefits of Using MQTT with Wemos D1 Mini

• Real-Time Data Exchange: Immediate and reliable communication between devices.

• Scalability: Easily add more devices without significant changes to the system.

• Efficiency: Lightweight and efficient communication, making it ideal for IoT projects.

Future Enhancements and Projects

Possible extensions of this project include:

• Security Enhancements: Implement SSL/TLS for secure communication over MQTT.

• Advanced Automation: Use more complex logic to automate actions based on incoming data.

• Cloud Integration: Send data to cloud platforms for analysis, storage, or integration with other services.

These improvements can help you create more advanced, secure, and feature-rich IoT solutions.

This article will guide you through the process of integrating MQTT into a Laravel application, allowing it to communicate with IoT devices seamlessly.

Why MQTT for IoT?

MQTT is specifically designed for constrained devices and unreliable networks. Its publish/subscribe model allows for efficient, real-time communication between multiple devices and applications, making it a preferred protocol for IoT projects.

Key features of MQTT include:

• Lightweight and Efficient: MQTT minimizes network bandwidth and device resource requirements.

• Scalable: Suitable for large-scale IoT deployments with millions of devices.

• Low Power Usage: Ideal for devices with limited battery life.

Prerequisites

Before diving into the integration, ensure you have the following:

• A Laravel application set up on your local environment.

• An MQTT broker (such as Mosquitto) running locally or accessible via the network.

• Basic knowledge of PHP and Laravel.

Step 1: Install the MQTT Client Package

The first step is to install an MQTT client library that integrates well with Laravel. For this tutorial, we'll use the php-mqtt/laravel-client package.

Run the following command in your terminal to install the package:

composer require php-mqtt/laravel-client

Step 2: Publish the Configuration File

Once the package is installed, publish the configuration file to customize the MQTT settings according to your environment.

php artisan vendor:publish --provider="PhpMqtt\Client\MqttClientServiceProvider" --tag="config"

This command will create an mqtt-client.php configuration file in the config directory of your Laravel application.

You can also set these values in your .env file:

MQTT_HOST=mqtt.example.com
MQTT_PORT=1883
MQTT_AUTH_USERNAME=your_username
MQTT_AUTH_PASSWORD=your_password
MQTT_CLIENT_ID=your_client_id
MQTT_ENABLE_LOGGING=true

Step 3: Implement MQTT Publishing

Now, let’s create a simple controller to publish messages to an MQTT topic. This will allow your Laravel application to send messages to your IoT devices.

Create a controller using Artisan:

php artisan make:controller MqttController

In the MqttController.php file, add the following code:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use PhpMqtt\Client\Facades\MQTT;

class MqttController extends Controller
{
    public function publish(Request $request)
    {
        $topic = $request->input('topic');
        $message = $request->input('message');

        $mqtt = MQTT::connection();
        $mqtt->publish($topic, $message);
        $mqtt->disconnect();

        return response()->json(['status' => 'Message published']);
    }
}

You can now send a POST request to this controller's method to publish messages to a specific topic. for example:

Step 4: Implement MQTT Subscription

To receive messages from an IoT device, you need to subscribe to a topic. The best way to continuously receive and process messages is by creating a long-running Artisan command.

Generate a new Artisan command:

php artisan make:command MqttSubscribe

Then, update the command to subscribe to an MQTT topic:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use PhpMqtt\Client\Facades\MQTT;

class MqttSubscribe extends Command
{
    protected $signature = 'mqtt:subscribe {topic}';

    protected $description = 'Subscribe to a given MQTT topic and display messages in the terminal';

    public function __construct()
    {
        parent::__construct();
    }

    public function handle()
    {
        $topic = $this->argument('topic');

        $mqtt = MQTT::connection();

        $this->info("Subscribing to topic: {$topic}");

        $mqtt->subscribe($topic, function (string $topic, string $message) {
            $this->info(sprintf("Received message on topic [%s]: %s", $topic, $message));
        });

        $mqtt->loop(true);
    }
}

Run this command in your terminal to start listening for messages:

php artisan mqtt:subscribe lamp

Step 5: Testing the MQTT Integration

With your MQTT publisher and subscriber set up, you can now test the integration. Use tools like Postman to send POST requests to the publish endpoint of your Laravel application, and observe the messages appearing in your terminal as the MqttSubscribe command processes them. for example:

Conclusion

Integrating MQTT with Laravel opens up numerous possibilities for IoT projects, allowing real-time communication between web applications and physical devices. By following this guide, you've set up a robust framework for sending and receiving messages via MQTT, laying the groundwork for more complex IoT applications.

As IoT continues to evolve, the combination of Laravel and MQTT will empower developers to build innovative, connected solutions that bridge the gap between the digital and physical worlds.

Feel free to expand on this foundation by adding features such as message persistence, device management, and more, as your IoT ecosystem grows.

Why Use Google Sheets as a Database?

Google Sheets offers several advantages:

1. Ease of Use: Its familiar interface makes it easy for non-developers to view and edit data.

2. Collaboration: Multiple users can work on the same sheet simultaneously.

3. Cost-Effective: For small to medium-sized applications, it can be a free alternative to traditional databases.

Prerequisites

Before we start, ensure you have the following:

1. Node.js and npm: Install from Node.js official website.

2. Google Cloud Account: To access Google Sheets API.

3. Google Sheet: Create spreadsheet

Step by Step

Step1 : Create Service Account

If you have already registered for Google Cloud account, go to Google Cloud IAM and admin. Klik Service accounts in the red box shown below, under the left side bar.

then, click on CREATE SERVICE ACCOUNT

fill in the form provided

Once created, go to the service account detail as below.

you must generate a key that, after being named, will be immediately downloaded in a JSON format into your computer's storage in order to connect the API from programs

Step2 : Set Up the Spreadsheet

create a new spreedsheet, share the spreedsheet with the google account service that you have created earlier

Step3 : Create ExpressJS Project

Set Up the Project: Begin by creating a new directory for your project and initializing it with npm:

mkdir crud-spreadsheet
cd crud-spreadsheet
npm init -y

This will create a new directory called crud-spreadsheet and a package.json file, which will keep track of your project's dependencies and scripts.

Install Dependencies: You will need to install Express, Google APIs, and Body-Parser:

npm install express googleapis body-parser

• Express: A minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.

• Googleapis: A library that provides access to various Google APIs, including Google Sheets.

• Body-Parser: A middleware to parse incoming request bodies in a middleware before your handlers, available under the req.body property.

Project Structure: Your project structure should look like this:

crud-spreadsheet/
├── node_modules/
├── service-account.json
├── package.json
└── index.js

• node_modules/: Directory where npm installs the packages.

• service-account.json: The JSON key file you downloaded from Google Cloud Console for your service account.

• package.json: File created by npm init that lists your dependencies and project details.

• index.js: The main file where you will write your Express application code.

Implement CRUD Operations: In index.js, implement the CRUD operations as follows:

const express = require('express');
const { google } = require('googleapis');
const bodyParser = require('body-parser');
const fs = require('fs');
const path = require('path');

const app = express();
const port = 4000;

// Middleware
app.use(bodyParser.json());

// Load service account credentials
const SERVICE_ACCOUNT_FILE = path.join(__dirname, 'service-account.json');
const credentials = JSON.parse(fs.readFileSync(SERVICE_ACCOUNT_FILE));

// Create an authorized client
const auth = new google.auth.GoogleAuth({
  credentials,
  scopes: ['https://www.googleapis.com/auth/spreadsheets']
});
const sheets = google.sheets({ version: 'v4', auth });

// Spreadsheet ID
const spreadsheetId = 'YOUR_SPREADSHEET_ID'; // Replace with your spreadsheet ID

// CREATE
app.post('/mahasiswa', async (req, res) => {
  const { name, nim, ipk } = req.body;

  if (!name || !nim || !ipk) {
    return res.status(400).send('All fields are required');
  }

  try {
    await sheets.spreadsheets.values.append({
      spreadsheetId,
      range: 'Sheet1!A1', // Replace with the appropriate range
      valueInputOption: 'USER_ENTERED',
      resource: {
        values: [[name, nim, ipk]],
      },
    });
    res.status(200).send('Data saved successfully');
  } catch (err) {
    console.error('Error inserting data:', err);
    res.status(500).send('Error saving data');
  }
});

// READ
app.get('/mahasiswa', async (req, res) => {
  try {
    const response = await sheets.spreadsheets.values.get({
      spreadsheetId,
      range: 'Sheet1!A2:C', // Replace with the appropriate range
    });

    const rows = response.data.values;
    if (rows.length) {
      res.status(200).send(rows);
    } else {
      res.status(404).send('No data found');
    }
  } catch (err) {
    console.error('Error reading data:', err);
    res.status(500).send('Error reading data');
  }
});

// UPDATE
app.put('/mahasiswa/:row', async (req, res) => {
  const { row } = req.params;
  const { name, nim, ipk } = req.body;

  if (!name || !nim || !ipk) {
    return res.status(400).send('All fields are required');
  }

  try {
    await sheets.spreadsheets.values.update({
      spreadsheetId,
      range: `Sheet1!A${row}:C${row}`, // Replace with the appropriate range
      valueInputOption: 'USER_ENTERED',
      resource: {
        values: [[name, nim, ipk]],
      },
    });
    res.status(200).send('Data updated successfully');
  } catch (err) {
    console.error('Error updating data:', err);
    res.status(500).send('Error updating data');
  }
});

// DELETE
app.delete('/mahasiswa/:row', async (req, res) => {
  const { row } = req.params;

  try {
    await sheets.spreadsheets.values.update({
      spreadsheetId,
      range: `Sheet1!A${row}:C${row}`, // Replace with the appropriate range
      valueInputOption: 'USER_ENTERED',
      resource: {
        values: [['', '', '']], // Clear the data
      },
    });
    res.status(200).send('Data deleted successfully');
  } catch (err) {
    console.error('Error deleting data:', err);
    res.status(500).send('Error deleting data');
  }
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

Explanation:

1. Express Setup:

   • const express = require('express'); and const app = express(); set up an Express application.

   • app.use(bodyParser.json()); adds middleware to parse JSON request bodies.

2. Google Sheets API Setup:

   • The service account credentials are loaded from the JSON file.

   • An authorized client is created using google.auth.GoogleAuth.

   • The Sheets API is initialized with the authorized client.

3. CRUD Operations:

   • CREATE: A POST request to /mahasiswa appends a new row with the provided data.

   • READ: A GET request to /mahasiswa retrieves all rows starting from the second row.

   • UPDATE: A PUT request to /mahasiswa/:row updates a specific row with the provided data.

   • DELETE: A DELETE request to /mahasiswa/:row clears the data in a specific row.

Another important thing you should remember for connection is the id of the google sheet you want to handle. You can find the id from the url of the google sheet and It looks like:

https://docs.google.com/spreadsheets/d/[your-sheet-id]/edit#gid=0

Step4 : Run Your Application

Now that we have our application code ready, we need to start our server and test the endpoints to ensure everything is working correctly. This step involves running the Node.js server, sending requests to the server, and verifying that the Google Sheets operations are performed as expected.

Start the Server: Open a terminal in the root directory of your project and run the following command to start the server:

node index.js

CREATE: Use Postman or another tool to send a POST request to /mahasiswa with a JSON body:

{
  "name": "John Doe",
  "nim": 123456,
  "ipk": 3.5
}

READ: Send a GET request to /mahasiswa.
UPDATE: Send a PUT request to /mahasiswa/:row with a JSON body to update a specific row:

{
  "name": "Jane Doe",
  "nim": 654321,
  "ipk": 3.8
}

Replace :row with the row number you want to update.

DELETE: Send a DELETE request to /mahasiswa/:row to delete a specific row.

Conclusion

Integrating Google Sheets with ExpressJS to perform CRUD operations is a powerful way to leverage the simplicity and accessibility of Google Sheets as a database. This method is particularly useful for small projects or for quickly prototyping applications where setting up a full database might be unnecessary. By following the steps outlined in this guide, you can easily set up a CRUD application and start managing your data with ease.

Konsep utama dalam Pipeline Architecture adalah sebagai berikut:

1. Stages (Langkah): Pipa terdiri dari serangkaian langkah yang berurutan, di mana setiap langkah memiliki tanggung jawab tertentu dalam pemrosesan data atau tugas. Setiap langkah dapat berjalan secara paralel, memungkinkan pemrosesan data secara efisien.

2. Data Flow (Aliran Data): Data mengalir melalui pipa dari satu langkah ke langkah berikutnya. Setelah sebuah langkah selesai memproses data, hasilnya dikirim ke langkah berikutnya untuk diproses lebih lanjut.

3. Parallelism (Paralelisme): Pipa memungkinkan paralelisme eksekusi, di mana beberapa langkah dapat bekerja secara bersamaan, mengoptimalkan kinerja dan kecepatan pemrosesan.

4. Single Responsibility: Setiap langkah dalam pipa memiliki tanggung jawab yang terbatas, memudahkan perawatan dan pengelolaan kode.

Contoh sederhana Pipeline Architecture:

Misalkan Anda memiliki aplikasi pemrosesan data besar. Pipeline Architecture dapat diterapkan sebagai berikut:

• Pipa terdiri dari langkah-langkah pemrosesan berurutan, seperti mengambil data mentah, membersihkan data, menghitung statistik, dan menyimpan hasilnya ke database.

• Setiap langkah memproses data secara independen dan mengirimkan hasilnya ke langkah berikutnya.

• Pipa memungkinkan langkah-langkah ini berjalan secara paralel, sehingga pemrosesan data lebih cepat dan efisien.

Keuntungan Pipeline Architecture:

• Kinerja Tinggi: Paralelisme dalam pipa memungkinkan pemrosesan data secara efisien dan meningkatkan kinerja aplikasi.

• Skalabilitas: Penambahan langkah atau kapasitas pemrosesan dalam pipa dapat meningkatkan kapasitas dan skalabilitas aplikasi.

• Modularitas: Setiap langkah dalam pipa memiliki tanggung jawab terbatas, sehingga memungkinkan kode yang lebih bersih, terorganisir, dan mudah dimengerti.

• Reuse: Setiap langkah dalam pipa dapat digunakan kembali (reusable) dalam berbagai pipa lainnya, mempercepat pengembangan aplikasi.

Kelamahan Pipeline Architecture:

• Overhead Komunikasi: Pengiriman data antara langkah-langkah dalam pipa memerlukan komunikasi, yang dapat menyebabkan overhead.

• Penanganan Kesalahan: Dalam beberapa kasus, penanganan kesalahan dan kegagalan di berbagai langkah dalam pipa dapat menjadi rumit dan memerlukan manajemen yang hati-hati.

• Koordinasi: Koordinasi antara langkah-langkah dalam pipa dan sinkronisasi data memerlukan perencanaan yang cermat dan implementasi yang baik.

Pipeline Architecture sering digunakan dalam pemrosesan data besar, komputasi paralel, dan aplikasi yang memerlukan pemrosesan tugas yang berurutan. Penggunaan pola ini harus disesuaikan dengan kebutuhan aplikasi dan mempertimbangkan keuntungan dan kerugiannya terhadap kompleksitas dan kinerja aplikasi.

Pada dasarnya, Relay Arduino berfungsi sebagai penghubung antara mikrokontroler Arduino dengan perangkat listrik yang lebih besar, seperti lampu, motor, atau peralatan rumah tangga lainnya. Dengan menggunakan Relay Arduino, maka pengguna dapat mengontrol perangkat listrik tersebut secara otomatis melalui program yang dibuat di mikrokontroler Arduino.

Relay Arduino biasanya terdiri dari beberapa bagian, antara lain relay, transistor, dioda, dan beberapa komponen elektronik lainnya yang membantu dalam mengontrol aliran listrik. Relay Arduino biasanya dapat dihubungkan dengan mudah ke pin output digital pada mikrokontroler Arduino, sehingga dapat dikendalikan dengan mudah melalui program Arduino.

Modul Relay Arduino umumnya terdiri dari beberapa pin yang berfungsi sebagai input dan output. Berikut ini adalah beberapa pin yang umumnya terdapat pada modul Relay

Perlu diingat bahwa konfigurasi pin pada modul Relay Arduino dapat berbeda-beda tergantung pada jenis dan model modulnya. Sebaiknya selalu merujuk pada datasheet modul Relay Arduino yang digunakan untuk mengetahui detail pinout dari modul tersebut.

Contoh:

int relayPin = 2; // Pin output digital pada Arduino Uno yang terhubung ke pin IN pada modul Relay Arduino

void setup() {
  pinMode(relayPin, OUTPUT); // Mengatur pin relay sebagai output
}

void loop() {
  digitalWrite(relayPin, HIGH); // Mengaktifkan relay
  delay(1000); // Menunggu selama 1 detik
  digitalWrite(relayPin, LOW); // Mematikan relay
  delay(1000); // Menunggu selama 1 detik
}

Pada contoh kode di atas, pin output digital pada Arduino Uno yang terhubung ke pin IN pada modul Relay Arduino adalah pin 2. Pada blok setup(), pin 2 diatur sebagai output. Pada blok loop(), relay diaktifkan dengan menyetel pin 2 ke HIGH, kemudian menunggu selama 1 detik menggunakan fungsi delay(), lalu mematikan relay dengan menyetel pin 2 ke LOW, dan menunggu selama 1 detik lagi sebelum memulai kembali proses pengulangan.

Jadi begini ceritanya, pada tahun 1995, ada seorang pahlawan kode bernama Brendan Eich yang menciptakan bahasa pemrograman keren bernama JavaScript. Awalnya, dia punya nama LiveScript, tapi akhirnya diubah jadi JavaScript, karena saat itu bahasa Java juga lagi nge-hits.

Gak kayak bahasa Java yang ribet dan berat, JavaScript ini lebih santai, namun powerful banget! Tujuan utamanya adalah memberikan situs web kemampuan buat jadi hidup, kayak ngasih efek animasi dan halaman web yang berubah-ubah sesuai aksi pengguna. Jadi bukan cuma nampilin teks doang, tapi bisa bikin interaksi yang bikin pengunjung betah.

Gak cuma jadi raja di sisi klien (client-side), JavaScript juga jadi jagoan di sisi server (server-side) berkat munculnya sang pahlawan Node.js! Jadi sekarang, kita bisa pakai JavaScript buat bikin aplikasi web seru dari awal sampai akhir.

Gara-gara kemampuannya yang luar biasa, JavaScript jadi idola di dunia pengembangan web. Setiap situs web keren pasti ada sentuhan ajaib dari JavaScript. Bisa dibilang, dia adalah bahasa pemrograman paling populer dan cewek-cewek di dunia pengembangan web nggak bisa lepas darinya.

Fundamental Javascript

Ayoo, mari kita masuk ke dunia JavaScript yang seru dan keren! Fundamental JavaScript adalah dasar-dasar yang wajib kita kuasai untuk jadi pahlawan kode sejati

1. Variabel dan Tipe Data

   Pertama, ada variabel! Bayangin variabel kayak kotak penyimpanan yang bisa kita isi dengan berbagai macam nilai, seperti angka, teks, atau bahkan objek keren! Variabel ini bikin kita bisa main-main dengan data, makin fleksibel deh!

   Selanjutnya, kita punya tipe data. Ini kayak atribut khusus buat setiap nilai di JavaScript. Ada string buat teks, number buat angka, boolean buat "ya" atau "tidak," dan masih banyak lagi! Seru banget kan?

    //Deklarasi variabel menggunakan let dan const
    let nama = "John Doe"; //tipe data string
    const usia = 25; //tipe data number
    let isMenikah = false; //tipe data boolean
    let angka = [1, 2, 3, 4, 5]; //tipe data array
    const objek = { nama: "John Doe", usia: 25, pekerjaan: "Web Developer"} //tipe data objek
   

2. Pengkondisian dan Looping

   Terus, jangan lupa tentang struktur kendali! Ini seperti jalan tol buat mengatur alur program kita. Punya keputusan sulit? Tenang aja, pakai if-else biar program tahu harus ngapain kalau kondisinya berubah! Loop juga penting nih, bisa bikin kode kita berulang-ulang untuk pekerjaan keren!

    //pengkondisian menggunakan if-else if-else
    let nilai = 80;
   
    if (nilai >= 90) {
      console.log("Nilai Anda A.");
    } else if (nilai >= 80) {
      console.log("Nilai Anda B.");
    } else if (nilai >= 70) {
      console.log("Nilai Anda C.");
    } else if (nilai >= 60) {
      console.log("Nilai Anda D.");
    } else {
      console.log("Nilai Anda E.");
    }
   

   Contoh Penggunaan Looping (For):

    for (let i = 1; i <= 5; i++) {
      console.log(i);
    }
   

   Contoh Penggunaan Looping (While):

    let angka = 1;
   
    while (angka <= 5) {
      console.log(angka);
      angka++;
    }
   

   Contoh Penggunaan Looping (Do-While):

    let x = 1;
   
    do {
      console.log("Ini adalah iterasi ke-" + x);
      x++;
    } while (x <= 5);
   

3. Function

   Fungsi adalah teman baik kita di JavaScript. Ini kayak resep masak, tapi buat kode! Dengan fungsi, kita bisa memecah kode jadi bagian-bagian yang lebih kecil dan mudah diatur. Reusabilitas kode pun jadi makin oke!

    // Fungsi sederhana untuk menyapa pengguna
    function sapaPengguna() {
      console.log("Halo, selamat datang!");
    }
   
    // Memanggil fungsi
    sapaPengguna(); // Output: "Halo, selamat datang!"
   

4. DOM - Document Object Model

   Jangan takut, ini cuma nama keren untuk cara JavaScript bermain-main dengan elemen di halaman web! Kita bisa mengubah konten, menambah elemen baru, atau merespons aksi dari pengguna. Bikin halaman jadi makin hidup!

    <!DOCTYPE html>
    <html>
    <head>
      <title>Contoh Penggunaan DOM</title>
    </head>
    <body>
      <h1 id="judul">Selamat Datang!</h1>
      <p id="pesan">Ini adalah contoh penggunaan DOM.</p>
   
      <script>
        // Mengubah konten elemen berdasarkan ID
        document.getElementById("judul").innerHTML = "Hello, World!";
        document.getElementById("pesan").innerHTML = "Saya belajar DOM.";
      </script>
    </body>
    </html>
   

Jadi, itulah sedikit bocoran tentang kehebatan JavaScript yang akan menjadi sahabat setia kita dalam merajut web yang keren dan interaktif. Makanya, kenalilah dan kuasailah fundamental JavaScript! Dengan dasar ini, kita bakal jadi penguasa situs web yang keren dan interaktif! Siap-siap deh, dunia pengembangan web bakal makin seru dan menyenangkan.

Spesifikasi dari LCD 16×2

• Terdiri dari 16 kolom dan 2 baris

• Dilengkapi dengan back light

• Mempunyai 192 karakter tersimpan

• Dapat dialamati dengan mode 4-bit dan 8-bit

• Terdapat karakter generator terprogram

Untuk menghemat pin pin pada Arduino ada 1 modul LCD yang bisa manfaatkan untuk alternatif mengakses LCD menggunakan antarmuka atau interface I2C, sehingga hanya membutuhkan 2 pin saja yaitu SDA dan SCL.

Spesifikasi modul i2C Display

• Tegangan beroperasi antara 2-5 Vdc

• Pada saat kondisi standby konsumsi arus hanya 10 uA

• Kompatibel dengan semua jenis mikrokontroler

• Kendali 8 bit menggunakan antarmuka i2c

• Open-drain interrupt output

Penggunaan

Ok langsung praktek saja ya, LCD I2C dengan Arduino UNO. Pertama kita siapkan kebutuhan komponennya.

1. Arduino UNO

2. LCD Display 16×2

3. Backpack I2C module LCD

4. Kabel konektor

• GND : terhubung dengan GND Arduino

  VCC : terhubung dengan 5V

  SDA : terhubung dengan pin SDA (A4)

  SCL : terhubung dengan pin SCL (A5)

Sebelum kita membuat programmnya terlebih dahulu siapkan library LiquidCrystal_I2C.h

Download Library LiquidCrystal I2C 1.1.2

Masukkan library tersebut ke folder libraries diman anda menyimpan aplikasi Arduino IDE atau dari menu Sketch -> Include Library -> Add .ZIP. Sekarang kita tulis programnya di Arduino IDE

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // sesuaikan dengan address i2C kalian

void setup() {
  lcd.init();      // initialize the lcd 
  lcd.backlight();

  lcd.setCursor(0,0);
  lcd.print("TEST LCD i2C");
  lcd.setCursor(0,1);
  lcd.print("gariskode.com");
}

void loop(){
  // Running Text LCD
  lcd.scrollDisplayLeft(); 
  delay(1000);
}

1. Model:

   • Pola desain Model mewakili logika bisnis dan akses ke data. Ini berisi kode untuk mengambil data dari database, API, atau sumber data lainnya, serta mengatur pemrosesan data dan logika aplikasi.

   • Biasanya, model terdiri dari kelas-kelas POJO (Plain Old Java Objects) atau PODO (Plain Old Dart Objects) untuk mewakili data dan fungsi yang berhubungan dengan data.

2. View:

   • Pola desain View bertanggung jawab atas tampilan antarmuka pengguna (UI). Ini berisi kode yang menampilkan informasi kepada pengguna dan menangani interaksi dari pengguna.

   • View tidak seharusnya berisi logika bisnis; sebaliknya, ia hanya mengirimkan tindakan dari pengguna ke presenter dan menampilkan data dari presenter.

3. Presenter:

   • Pola desain Presenter bertindak sebagai perantara antara Model dan View. Ia berfungsi untuk menghubungkan logika bisnis dalam Model dengan tampilan dalam View.

   • Presenter mengambil perintah dari View (misalnya, ketika pengguna mengklik tombol) dan memprosesnya melalui Model. Setelah Model menyelesaikan tugasnya, Presenter mengirimkan hasilnya kembali ke View untuk ditampilkan ke pengguna.

   • Presenter juga berfungsi sebagai pemisah untuk memastikan bahwa View dan Model tetap independen satu sama lain.

4. Observer/Observable:

   • Pola desain Observer/Observable sering digunakan untuk menghubungkan Model dan View. Ketika data di Model berubah, View perlu diberi tahu sehingga tampilan dapat diperbarui sesuai.

   • Presenter bertindak sebagai subjek (Observable), yang akan memberitahu View (Observer) tentang perubahan data di Model. Ini memungkinkan tampilan untuk selalu mencerminkan kondisi data terbaru.

5. Dependency Injection:

   • Pola desain Dependency Injection digunakan untuk mengelola dependensi antara kelas-kelas dalam arsitektur MVP.

   • Dengan Dependency Injection, Anda dapat menghindari ketergantungan langsung antara View dan Model dengan menggunakan kerangka kerja atau pustaka yang tepat (misalnya, Dagger untuk Java atau Flutter's built_value untuk Dart).

   • Ini mempermudah pengujian dan membuat kode lebih modular.

Penting untuk diingat bahwa MVP adalah salah satu dari beberapa pendekatan arsitektur yang dapat digunakan dalam pengembangan perangkat lunak. Pola desain di atas membantu Anda dalam menerapkan MVP secara efektif, mengurangi ketergantungan, dan memisahkan logika bisnis dari tampilan.

Contoh Code

Berikut code sederhana yang bisa kamu pahami dan cermati untuk Pola desain MVP dalam bahasa pemograman dart (Untuk aplikasi Flutter).Kami akan menggunakan contoh aplikasi Kalkulator sederhana dengan empat operasi matematika dasar:penjumlahan,pengurangan,perkalian dan pembagian.

//Model 
class CalculatorModel {
  double calculate(String operation, double num1, double num2) {
    switch (operation) {
      case '+':
        return num1 + num2;
      case '-':
        return num1 - num2;
      case '*':
        return num1 * num2;
      case '/':
        return num1 / num2;
      default:
        throw Exception("Invalid operation");
    }
  }
}

Dibawah ini adalah view dari si model

// View.dart
import 'package:flutter/material.dart';

class CalculatorView {
  final TextEditingController number1Controller = TextEditingController();
  final TextEditingController number2Controller = TextEditingController();
  final TextEditingController resultController = TextEditingController();

  void showResult(double result) {
    resultController.text = result.toString();
  }
}

dan Selanjutnya adalah Presenternya

// Presenter.dart
import 'model.dart';
import 'view.dart';

class CalculatorPresenter {
  final CalculatorModel _model;
  final CalculatorView _view;

  CalculatorPresenter(this._view) : _model = CalculatorModel();

  void calculate(String operation) {
    double num1 = double.tryParse(_view.number1Controller.text) ?? 0.0;
    double num2 = double.tryParse(_view.number2Controller.text) ?? 0.0;

    try {
      double result = _model.calculate(operation, num1, num2);
      _view.showResult(result);
    } catch (e) {
      _view.showResult(0.0);
    }
  }
}

Selanjutnya ,dalam main.dart kita akan menggabungkan model,view, dan Presenter untuk mengatur antarmuka pengguna dan logika bisnis.

import 'package:flutter/material.dart';
import 'presenter.dart';
import 'view.dart';

void main() {
  runApp(CalculatorApp());
}

class CalculatorApp extends StatelessWidget {
  final CalculatorView _view = CalculatorView();
  final CalculatorPresenter _presenter = CalculatorPresenter(CalculatorView());

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('MVP Calculator')),
        body: Padding(
          padding: const EdgeInsets.all(16.0),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            crossAxisAlignment: CrossAxisAlignment.center,
            children: <Widget>[
              TextField(controller: _view.number1Controller, keyboardType: TextInputType.number),
              SizedBox(height: 10),
              TextField(controller: _view.number2Controller, keyboardType: TextInputType.number),
              SizedBox(height: 20),
              Row(
                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                children: <Widget>[
                  ElevatedButton(onPressed: () => _presenter.calculate('+'), child: Text('+')),
                  ElevatedButton(onPressed: () => _presenter.calculate('-'), child: Text('-')),
                  ElevatedButton(onPressed: () => _presenter.calculate('*'), child: Text('*')),
                  ElevatedButton(onPressed: () => _presenter.calculate('/'), child: Text('/')),
                ],
              ),
              SizedBox(height: 20),
              TextField(controller: _view.resultController, readOnly: true),
            ],
          ),
        ),
      ),
    );
  }
}

Dalam contoh diatas,kita telah membuat aplikasi kalkulator sederhana menggunakan pola MVP.Model betnggung jawab untuk perhitungan matematika,View untuk menampilkan elemen antar pengguna dan Presenter untuk menghubungkan Model dan View.Ini Memungkinkan Aplikasi untuk mempertahankan pemisahan tugas yang baik dan memudahkan pengujian.

Modul Bluetooth Arduino tersedia dalam berbagai macam jenis dan varian yang dapat dipilih sesuai dengan kebutuhan proyek Anda. Beberapa jenis modul Bluetooth Arduino yang populer di antaranya adalah HC-05 dan HC-06. Modul Bluetooth Arduino ini biasanya dihubungkan ke board Arduino melalui pin RX dan TX, dan kemudian diatur dengan kode program Arduino untuk memastikan koneksi yang baik dan stabil.

Setelah dihubungkan dan dikonfigurasi dengan benar, modul Bluetooth Arduino dapat memungkinkan Anda untuk mengirim dan menerima data melalui koneksi Bluetooth, serta mengendalikan perangkat yang terhubung dengan board Arduino dari jarak jauh. Ini membuat modul Bluetooth Arduino menjadi pilihan yang ideal untuk proyek yang membutuhkan komunikasi nirkabel, seperti kendali jarak jauh untuk mobil atau drone, atau pengendalian robot secara jarak jauh.

Modul Bluetooth Arduino biasanya dihubungkan ke board Arduino melalui pin RX dan TX. Berikut adalah fungsi dari masing-masing pin pada modul Bluetooth Arduino:

Contoh:

pada contoh dibawah ini, kita akan menghidup/matikan led menggunakan Bluetooth, led kaki anoda (anode) pada pin 13 di arduino uno dan led kaki katoda (cathode) pada pin ground arduino, lalu kita sambungkan juga kaki RX HC-05 ke TX arduino, kaki TX HC05 ke RX arduino, kaki VCC HC05 ke 5V arduino, dan kaki GND HC05 ke GND Arduino

int led=13;
int DataBluetooth;

void setup() {
  Serial.begin(9600);
  Serial.println("ON/OFF LED");
  Serial.println("1 = ON, 0 = Off");
  pinMode(led,OUTPUT);
}

void loop() {
  if (Serial.available()){
   DataBluetooth=Serial.read();
   if(DataBluetooth=='1'){  
     digitalWrite(led,HIGH);
     Serial.println("LED On");
   }
   if (DataBluetooth=='0'){
      digitalWrite(led,LOW);
      Serial.println("LED Off");
  }
}
delay(100);
}

Keuntungan Menggunakan Blade

Beberapa keuntungan menggunakan Blade dalam pengembangan aplikasi Laravel:

1. Sintaks Simpel: Blade menyediakan sintaks yang mudah dipahami dan bersih. Template Blade terlihat seperti kode HTML standar dengan tambahan beberapa ekstensi yang khas untuk Blade.

2. Inheritance Layout: Blade mendukung konsep "template inheritance" di mana Anda dapat membuat layout induk (parent) yang berisi struktur dasar halaman, dan kemudian membuat view anak (child) yang mewarisi layout induk tersebut.

3. Penggunaan Komponen: Blade memungkinkan pembuatan komponen (components) yang dapat digunakan kembali dalam berbagai view, sehingga memudahkan pengaturan tampilan secara konsisten.

4. Pengontrolan Struktur: Dengan Blade, Anda dapat dengan mudah mengatur struktur kontrol, seperti if-else, loop, dan lain-lain, langsung di dalam view.

5. Penyisipan Data: Blade memungkinkan penyisipan data dinamis dalam view menggunakan sintaks yang jelas dan mudah dimengerti.

6. Escaping Otomatis: Blade secara otomatis akan menyaring data yang ditampilkan dalam view untuk menghindari serangan XSS (Cross-Site Scripting).

Penggunaan Blade

Berikut adalah contoh penggunaan Blade dalam aplikasi Laravel:

• Layout Induk (parent) - layouts/app.blade.php:

    <!DOCTYPE html>
    <html>
    <head>
        <title>@yield('title')</title>
    </head>
    <body>
        <header>
            <!-- Bagian header -->
        </header>
  
        <main>
            @yield('content')
        </main>
  
        <footer>
            <!-- Bagian footer -->
        </footer>
    </body>
    </html>
  

• View Anak (child) - pages/home.blade.php:

    @extends('layouts.app')
  
    @section('title', 'Halaman Home')
  
    @section('content')
        <h1>Selamat Datang di {{ $data['title'] }}</h1>
        <p>{{ $data['description'] }}</p>
    @endsection
  

• Controller - /app/Http/Controller/HomeController.php:

    namespace App\Http\Controllers;
  
    class HomeController extends Controller
    {
        public function index()
        {
            $data['title'] = 'Garis Kode'; 
            $data['description'] = 'membawa para Developer untuk bekerja sama mencari pengalaman dari komunitas untuk komunitas';
            return view('pages.home', compact('data'));
        }
    }
  

• Routes - routes/web.php:

    use App\Http\Controllers\HomeController;
  
    Route::get('/', [HomeController::class, 'index'])->name('index');
  

• Maka anda akan mendapatkan output seperti ini:

  

Konsep utama dalam space based arsitektur adalah sebagai berikut:

1.Space(Ruang) space merupakan tempat penyimpanan ruang terdistribusi dan terdiri dari kumpulan entitas data yang disebut "tuples" dan "entry".Tuple dapat berisikan data atau informasi yang diperlukan dalam aplikasi.

2.Proccessor(prossesor) Setiap komponen dalam sistem (disebut juga sebagai "procccessing unit" memiliki akses ke space. Komponen ini dapat membaca dan menulis tuples ke space,serta memproses atau memanipulasi tuples yang ada.

3.Even Drivent Arsitektur ini biasanya berbasis event driven dimana proses berjalan sebagai respons terhadap peristiwa(event) tertentu yang terjadi di sistem.

4.Distribuasi dan replikasi Space based arsitekture memungkinkan untuk mendistribusikan dan mereplikasi space di beberapa node atau lokasi, yang mendukung skalabilitas dan ketersediaan yang tinggi.

5.In-memory Data Grid(IMDG) Implementasi arsitektur ini sering menggunakan IMDG untuk menyimpan data dalam memory, yang meningkatkan akses dan kinerja.

Contoh sederhana Space-based arsitektur:

Misal anggaplah anda memiliki sebuah aplikasi e-commerce dengan banyak pelanggan yang melakukan pembelian secara bersamaan.Space-based architecture dapat diterapkan sebagai berikut.

• Setiap komponen aplikasi memiliki akses ke space,yang berfungsi sebagai "Keranjang belanja"bebagi di antara semua komponen.

• Ketika pelanggan menambahkan barang keranjang belanja,tuple yang berisi detail produk dan jumlah ditambahkan ke space.

• Setiap komponen lain yang terlibat dalam pemrosesan pesanan, seperti manajemen persediaan dan pembayaran, dapat membaca tuple dari space dan menangani tugasnya.

• Setelah pesanan selesai diproses,tuple dihapus dari space.

Keuntungan Space-Based Arsitektur

• Skalabilitas kemampuan untuk mendistribusikan dan mereplikasi space memungkinkan aplikasi untuk dengan mudah ditingkatkan secara horizontal untuk menangani beban kerja meningkat.

• Ketersediaan Tinggi Replikasi data dibeberapa node memastikan ketersediaan tinggi jika salah satu node mengalami kegagalan.

• Kinerja Penyimpanan data dalam memori(IMDG) memungkinkan akses data yang cepat dan meningkatkan kinerja aplikasi.

• Fleksibilitas Space-based arsitektur mendukung aplikasi yang dinamis dan responsif terhadap perubahan.

Kelemahan Space-Based Arsitektur

• Kompleksitas Implementasi arsitektur ini dapat lebih kompleks dibandingkan dengan pola arsitektur lainya karena melibatkan manajemen space,replika data, dan koordinasi antar komponen.

• Sinkronisasi Data sikronisasi data antar node dapat menyebabkan overhead dan memerlukan manajemen yang hati - hati untuk menghindari konflik dan ketidaksesuaian data.

• Biaya Infrastruktur Membutuhkan infrastruktur yang kuat dan besar untuk mendukung mekanisme dan replikasi.

Space-Based Arsitektur sering digunakan dalam aplikasi terdistribusi yang memerlukan ketersediaan tinggi,skalabilitas dan performa tinggi,seperti e-commerce,permainan online dan aplikasi perbankan.penerapan pola ini harus dipertimbangkan berdasarkan kebutuhan spesifik aplikasi dan kemampuan infrastruktur.

Mengapa harus Python?

Simak lanjutannya

Berikut adalah beberapa konsep penting dalam Go Modules:

1. Go.mod: Ini adalah file konfigurasi untuk modul Go. Ini berisi daftar dependensi proyek, beserta nomor versi yang diinginkan. Go.mod juga mencatat versi Go minimal yang diperlukan untuk proyek tersebut. File ini berada di root proyek Go.

2. Go.sum: File ini berisi checksum dari setiap dependensi yang digunakan dalam proyek. Ini membantu mencegah adanya manipulasi pada dependensi dan memastikan bahwa Anda mendapatkan dependensi yang tepat setiap kali Anda membangun proyek.

3. Versi Semantik: Go Modules mengikuti prinsip SemVer (Versi Semantik), yang berarti nomor versi dependensi memiliki format MAJOR.MINOR.PATCH. Ketika Anda menambahkan dependensi ke proyek, Anda dapat menentukan range versi yang diizinkan untuk digunakan, misalnya: module@v1.2.3 atau module@^1.2.3.

4. Perintah Go: Sejumlah perintah telah ditambahkan ke perangkat lunak Go untuk bekerja dengan Go Modules. Beberapa perintah ini meliputi:

   • go mod init: Digunakan untuk menginisialisasi proyek Go Modules di direktori.

   • go get: Digunakan untuk menambahkan dependensi ke proyek.

   • go build / go run: Perintah ini akan mengunduh dan mengelola dependensi proyek secara otomatis sesuai dengan file go.mod dan go.sum.

5. Vendor Directory (opsional): Sebelum Go Modules, pendekatan populer untuk manajemen dependensi adalah dengan meletakkan salinan kode dependensi di direktori "vendor". Go Modules juga mendukung pendekatan ini, yang berarti Anda dapat menyimpan dependensi di vendor Anda sendiri jika Anda memilih untuk tidak menggunakan proxy modul publik.

Dengan Go Modules, pengembang Go sekarang memiliki cara yang lebih baik untuk mengelola dependensi dan memastikan bahwa proyek mereka tetap konsisten dengan versi dependensi yang digunakan. Ini membuat kolaborasi lebih mudah dan memperkuat ekosistem Go secara keseluruhan.

Konsep utama dalam microkernel arsitektur adalah untuk menyederhanakan kernel menjadi setidaknya fungsi minimum ,seperti manajemen memori,pengelolaan proses dan komunikasi antar proses.Semua fungsi esensial,seperti sistem file,jaringan atau antarmuka pengguna, dipindahkan keluar kernel menjadi modul- modul terpisah yang berjalan diruang pengguna(user space).

Micro kernel adalah bagian inti dari sistem informasi yang menyediakan fungsi -fungsi dasar spserti manajemen memori, manajemen proses, dan komunikasi antarproses.Mikrokernel berfungsi sebagai jembatan antara perangkat keras dan modul lain yang berjalan diruang pengguna.

Server atau Modul Layanan adalah modul - modul atau server -server yang berjalan diruang pengguna (user space) dan menyediakan layanan tambahan seperti sistem file ,jaringan ,antarmuka pengguna, dll.Komunikasi antar server atau mikrokernel biasanya menggunakan komunikasi yang efisiensi,seperti interproses dan comunication(IPC) yang dapat berupa pesan atau protokol lainnya.

Keuntungan Microkernel Architecture:

• Kesederhanaan: Kernel menjadi sangat kecil dan fokus pada fungsi dasar saja, sehingga mudah diimplementasikan, dipelihara, dan diverifikasi.

• Kestabilan: Pemisahan modul dari kernel menyebabkan kesalahan atau kegagalan di modul tidak langsung mempengaruhi stabilitas kernel.

• Modularitas: Sistem dibagi menjadi modul yang terpisah, sehingga memungkinkan untuk mengganti, menambahkan, atau memperbarui modul dengan lebih mudah tanpa mengganggu kernel.

• Keamanan: Dengan fungsi-fungsi kritis terisolasi dalam microkernel, ada sedikit potensi untuk kegagalan atau eksploitasi keamanan yang dapat mempengaruhi kernel.

Kelamahan Microkernel Architecture:

• Overhead Komunikasi: Karena komunikasi antara kernel dan modul di ruang pengguna melalui IPC, ini bisa menyebabkan overhead yang lebih besar dibandingkan jika semuanya berada dalam kernel.

• Kompleksitas Manajemen Modul: Memisahkan layanan ke dalam modul tambahan juga dapat meningkatkan kompleksitas manajemen dan koordinasi di antara modul-modul tersebut.

• Performa: Penggunaan mekanisme komunikasi antara modul dapat mempengaruhi performa aplikasi jika tidak diimplementasikan dengan efisien.

• Keterbatasan Dukungan: Beberapa fungsi yang biasanya dianggap sebagai bagian dari kernel dapat terbatas karena dipindahkan ke modul di ruang pengguna.

Dengan menggunakan Arduino, bisa dapat membantu kita membuat berbagai macam sistem elektronik yang dapat dikendalikan melalui program yang telah dibuat. Misalnya, orang awam dapat membuat sistem otomatisasi rumah, robot sederhana, atau bahkan kendali taman pintar dengan menggunakan board mikrokontroler pada Arduino dan menghubungkannya dengan sensor dan aktuator yang sesuai. Dengan kemudahan pemrogramannya, Arduino juga menjadi populer sebagai platform pembelajaran bagi pemula yang ingin belajar tentang dunia elektronik dan pemrograman.

Board

Arduino Uno

Arduino Uno adalah salah satu jenis board mikrokontroler yang dikembangkan oleh perusahaan Arduino. Board ini sangat populer karena mudah digunakan oleh pemula dan mendukung banyak bahasa pemrograman, termasuk bahasa C/C++.

Arduino Uno dilengkapi dengan mikrokontroler ATmega328P, yang memiliki spesifikasi sebagai berikut:

• Kecepatan Clock: 16 MHz

• Memori Program: 32 KB

• Memori SRAM: 2 KB

• Memori EEPROM: 1 KB

• Input Voltage: 5-12V

Arduino Uno memiliki banyak pin input/output (I/O) yang dapat digunakan untuk menghubungkan berbagai komponen elektronik seperti sensor, LED, motor, dan lain sebagainya. Board ini juga dilengkapi dengan USB port yang dapat digunakan untuk menghubungkannya dengan komputer dan mengupload program ke dalam board.

Arduino Nano

Arduino Nano adalah salah satu jenis board mikrokontroler Board ini merupakan versi mini dari Arduino Uno dengan ukuran yang lebih kecil. Arduino Nano memiliki spesifikasi yang hampir sama dengan Arduino Uno, hanya saja beberapa pin pada Arduino Nano diatur dalam bentuk header pin dengan jarak 2,54 mm, sehingga lebih mudah untuk dihubungkan dengan breadboard atau prototyping board.

Berikut adalah perbandingan antara Arduino Nano dan Arduino Uno:

1. Ukuran: Arduino Nano lebih kecil dari Arduino Uno, sehingga lebih mudah untuk digunakan dalam proyek-proyek yang membutuhkan board mikrokontroler dengan ukuran yang kompak.

2. Jumlah Pin: Arduino Uno memiliki 14 pin digital dan 6 pin analog, sedangkan Arduino Nano memiliki 14 pin digital dan 8 pin analog.

3. Harga: Arduino Nano lebih murah dibandingkan dengan Arduino Uno, karena ukurannya yang lebih kecil dan jumlah pin yang sedikit lebih sedikit.

4. Ketersediaan: Arduino Uno lebih mudah ditemukan di pasaran karena lebih populer dan sudah lama digunakan, sedangkan Arduino Nano masih relatif baru.

Etc.

• arduino due

• arduino mega

• arduino leonardo

• arduino fio

• arduino lilypad

• arduino mini

• arduino micro

• arduino ethernet

• arduino esplora

• arduino robot

Software

Arduino IDE

Arduino IDE (Integrated Development Environment) adalah sebuah perangkat lunak atau software yang digunakan untuk membuat program atau kode program untuk board mikrokontroler Arduino. Dengan menggunakan Arduino IDE, kita dapat membuat program yang dapat mengontrol berbagai jenis perangkat elektronik seperti sensor, motor, lampu LED, dan lain sebagainya.

Arduino IDE menyediakan lingkungan yang mudah digunakan oleh pemula yang ingin belajar membuat program untuk board mikrokontroler Arduino. Kita dapat menulis kode program dalam bahasa C/C++ pada jendela editor yang disediakan. Setelah kode program selesai, kita dapat mengunggahnya ke board mikrokontroler Arduino melalui koneksi USB.

Dalam menggunakan Arduino IDE, terdapat banyak fitur yang sangat membantu, seperti sintaks highlighting, fitur auto-complete, dan debugger. Selain itu, Arduino IDE juga menyediakan banyak library atau pustaka perangkat lunak yang dapat digunakan untuk mengendalikan berbagai jenis perangkat elektronik.

Penjelasan Tombol pada Software Arduino IDE:

1. Verify

   

   berfungsi untuk melakukan checking kode yang kamu buat apakah sudah sesuai dengan kaidah pemrograman yang ada atau belum

2. Upload

   

   Berfungsi untuk melakukan kompilasi program atau kode yang kamu buat menjadi bahasa yang dapat dipahami oleh mesih alias si Arduino.

3. Serial Monitor

   

   Berfungsi untuk membuka serial monitor. Serial monitor disini merupakan jendela yang menampilkan data apa saja yang dikirimkan atau dipertukarkan antara arduino dengan sketch pada port serialnya. Serial Monitor ini sangat berguna sekali ketika kamu ingin membuat program atau melakukan debugging tanpa menggunakan LCD pada Arduino. Serial monitor ini dapat digunakan untuk menampilkan nilai proses, nilai pembacaan, bahkan pesan error.

4. Board Select

   

   Berfungsi untuk Memilih port serial dari board yang ingin di program, setiap board yang di koneksi kan ke Laptop/PC akan terbaca oleh arduino IDE beserta port yang dipakai

HTTP Method

Berikut adalah beberapa HTTP method yang umum digunakan dalam aplikasi web:

1. GET: HTTP method ini digunakan untuk mengambil data dari sumber daya tanpa melakukan perubahan pada server. Biasanya digunakan untuk menampilkan halaman atau data dari server.

2. POST: HTTP method ini digunakan untuk mengirimkan data ke server dan menyimpannya sebagai sumber daya baru. Biasanya digunakan untuk menyimpan data yang dikirim melalui form.

3. PUT: HTTP method ini digunakan untuk mengirimkan data ke server dan menggantikan seluruh sumber daya atau objek yang ada dengan data yang baru. Namun, dalam praktiknya, metode PUT jarang digunakan, dan sering digantikan dengan metode PATCH.

4. PATCH: HTTP method ini digunakan untuk mengirimkan data ke server dan melakukan perubahan terhadap bagian atau beberapa atribut dari sumber daya atau objek yang ada.

5. DELETE: HTTP method ini digunakan untuk menghapus sumber daya atau objek dari server.

Menggunakan HTTP Method dalam Laravel

Dalam Laravel, kita dapat menentukan jenis HTTP method yang digunakan dalam routing dengan menggunakan metode match atau metode khusus seperti get, post, put, patch, dan delete.

Untuk menangani data yang dikirim melalui form pada metode POST, PUT, dan PATCH, kita perlu menggunakan instance dari kelas Illuminate\Http\Request dalam parameter metode controller.

Contoh penggunaan Request dalam controller:

// app/Http/Controllers/ExampleController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ExampleController extends Controller
{
    public function index()
    {
        // Logika untuk menampilkan daftar data
        // ...
        return view('example.index', ['data' => $data]);
    }

    public function store(Request $request)
    {
        // Logika untuk menyimpan data baru
        // ...
        return redirect()->route('example.index')->with('success', 'Data berhasil disimpan!');
    }

    public function update(Request $request, $id)
    {
        // Logika untuk mengupdate data berdasarkan ID
        // ...
        return redirect()->route('example.index')->with('success', 'Data berhasil diupdate!');
    }

    public function destroy($id)
    {
        // Logika untuk menghapus data berdasarkan ID
        // ...
        return redirect()->route('example.index')->with('success', 'Data berhasil dihapus!');
    }
}

Setelah controller dibuat, kita perlu menghubungkannya dengan routing agar controller dapat menangani permintaan dari pengguna sesuai dengan HTTP Method yang benar.

// routes/web.php

use App\Http\Controllers\ExampleController;

Route::get('/example', [ExampleController::class, 'index'])->name('read');
Route::post('/example', [ExampleController::class, 'store'])->name('create');
Route::put('/example/{id}', [ExampleController::class, 'update'])->name('update');
Route::delete('/example/{id}', [ExampleController::class, 'destroy'])->name('delete');

Apa Itu Controller?

Controller merupakan kelas PHP yang digunakan untuk mengelola permintaan HTTP dari pengguna dan memberikan respons yang sesuai. Ketika pengguna melakukan aksi di aplikasi web, seperti mengakses halaman, mengirim form, atau memanggil API, permintaan tersebut akan diteruskan ke controller yang akan menangani logika dan kembali memberikan respons kepada pengguna, baik berupa tampilan (View) atau data JSON.

Membuat Controller

Untuk membuat controller pada Laravel, kita dapat menggunakan perintah artisan yang sudah disediakan.

php artisan make:controller ExampleController

Gantilah "NamaController" dengan nama yang sesuai untuk controller yang ingin Anda buat. Setelah perintah dijalankan, Laravel akan membuat file controller baru dalam folder app/Http/Controllers.

Struktur Controller

Sebuah controller biasanya terdiri dari beberapa metode (fungsi) yang berfungsi untuk menangani berbagai jenis permintaan yang diterima oleh aplikasi. Misalnya, dalam controller yang menangani entitas "User", kita mungkin memiliki metode untuk menampilkan daftar user, menampilkan halaman tambah user, menyimpan data user baru, mengedit user, dan lain-lain.

Contoh sederhana Controller:

// app/Http/Controllers/ExampleController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ExampleController extends Controller
{
    public function index()
    {
        // Logika untuk menampilkan daftar data
        // ...
        return view('index');
    }
}

Menghubungkan Controller dengan Routing

Setelah controller dibuat, kita perlu menghubungkannya dengan routing agar controller dapat menangani permintaan dari pengguna.

// routes/web.php

use App\Http\Controllers\ExampleController;

Route::get('/example', [ExampleController::class, 'index'])->name('index');

Dalam contoh di atas, kita telah menghubungkan setiap metode di controller ExampleController dengan routing yang sesuai menggunakan metode HTTP yang sesuai Selain itu, kita memberikan nama (name) pada masing-masing route, sehingga kita dapat dengan mudah merujuk ke route tersebut dalam kode aplikasi kita.

Routing dalam Laravel

Routing adalah mekanisme yang digunakan untuk mengarahkan permintaan HTTP ke kode yang sesuai dalam aplikasi web kita. Dengan menggunakan routing, kita dapat menentukan bagaimana URL akan diakses oleh pengguna dan bagaimana permintaan tersebut akan dihandle oleh aplikasi kita.

Membuat Routing

Untuk membuat routing dalam Laravel, kita dapat menggunakan file routes/web.php atau routes/api.php. Pada artikel ini, kita akan fokus pada file web.php, yang digunakan untuk routing aplikasi web.

Contoh sederhana membuat route:

// routes/web.php

Route::get('/', function () {
    return view('welcome');
});

Route::get('/about', function () {
    return 'Ini Adalah Halaman About';
});

Silahkan kamu ketik http://127.0.0.1:8000/about pada browser, maka akan menghasilkan output:

Dalam contoh di atas, kita telah membuat dua routing dengan menggunakan metode get. Routing pertama akan menghandle permintaan ke URL root (/), sedangkan routing kedua akan menghandle permintaan ke URL /about.

Parameter Routing

Kita juga dapat menggunakan parameter dalam routing untuk menangkap nilai yang dikirimkan melalui URL. Contoh:

// routes/web.php

Route::get('/post/{id}', function ($id) {
    return 'Menampilkan post dengan ID: ' . $id;
});

Silahkan kamu ketik http://127.0.0.1:8000/post/1 pada browser, maka Output yang dihasilkan:

Dalam contoh di atas, kita telah membuat routing dengan parameter {id}. Nilai id yang dikirimkan melalui URL akan ditangkap dan digunakan dalam fungsi untuk memberikan respon yang sesuai.

View dalam Laravel

View adalah tampilan atau antarmuka yang akan ditampilkan kepada pengguna. Dalam Laravel, kita menggunakan template engine Blade untuk mengelola tampilan aplikasi.

Membuat View

View dapat dibuat dalam folder resources/views. Misalnya, untuk membuat view dengan nama about.blade.php, kita dapat melakukan seperti ini:

<!-- resources/views/about.blade.php -->

<!DOCTYPE html>
<html>
<head>
    <title>About Us</title>
</head>
<body>
    <h1>Tentang Garis kode</h1>
</body>
</html>

Menggunakan View dalam Routing

Setelah view dibuat, kita bisa menggunakan view tersebut dalam routing untuk memberikan respon kepada pengguna.

// routes/web.php

Route::get('/about', function () {
    return view('about');
});

Maka akan menghasilkan output:

Dalam contoh di atas, kita telah mengarahkan permintaan ke URL about (/about) untuk menampilkan view about.blade.php.

Mengirim Data ke View

Ketika menggunakan view, kita juga dapat mengirimkan data dari routing ke view untuk ditampilkan.

// routes/web.php

Route::get('/hello/{name}', function ($name) {
    return view('greeting', ['name' => $name]);
});

<!-- resources/views/greeting.blade.php -->

<!DOCTYPE html>
<html>
<head>
    <title>Salam</title>
</head>
<body>
    <h1>Halo, {{ $name }}!</h1>
</body>
</html>

Maka akan menghasilkan output:

Dalam contoh di atas, kita mengirimkan data berupa variabel name ke view greeting.blade.php dan menampilkannya menggunakan sintaks Blade {{ $name }}.

See you next article...

Pengertian

Laravel adalah sebuah framework open-source (sumber terbuka) yang dikembangkan oleh Taylor Otwell dan pertama kali dirilis pada tahun 2011. Framework ini ditulis dalam bahasa pemrograman PHP dan mengikuti konsep arsitektur Model-View-Controller (MVC). MVC memisahkan logika aplikasi, tampilan, dan pemodelan data, sehingga memungkinkan para developer untuk mengembangkan aplikasi dengan lebih terstruktur dan mudah diorganisir.

Beberapa fitur unggulan dari Laravel antara lain:

1. Sintaks Elegan dan Ekspresif: Laravel menawarkan sintaks yang mudah dipahami dan ekspresif, sehingga mempercepat proses pengembangan dan mengurangi kesalahan kode.

2. Paket Komponen: Laravel dilengkapi dengan berbagai paket komponen yang siap digunakan, seperti sistem otentikasi, manajemen sesi, validasi data, dan lain-lain, yang mempercepat proses pengembangan.

3. Database Migration: Laravel menyediakan mekanisme database migration yang memungkinkan para developer untuk mengelola skema database dengan mudah dan aman.

4. Eloquent ORM: Eloquent adalah fitur ORM (Object-Relational Mapping) yang memungkinkan para developer untuk berinteraksi dengan database menggunakan sintaks PHP, sehingga mengurangi kompleksitas query database.

5. Routing yang Kuat: Laravel memiliki sistem routing yang kuat untuk mengatur URL dan mengarahkan permintaan HTTP ke controller yang sesuai.

6. Blade Templating Engine: Blade adalah mesin templating yang kuat dan intuitif yang digunakan untuk mengelola tampilan aplikasi dengan lebih efisien.

7. Keamanan: Laravel menyediakan berbagai fitur keamanan, seperti proteksi CSRF (Cross-Site Request Forgery), proteksi XSS (Cross-Site Scripting), dan lain-lain untuk mengamankan aplikasi dari ancaman keamanan.

Cara Instalasi Laravel

Untuk menginstal Laravel, pastikan komputer Anda telah memenuhi persyaratan minimum berikut:

• PHP versi 7.3.0 atau yang lebih baru

• Ekstensi PHP: BCMath, Ctype, Fileinfo, JSON, Mbstring, OpenSSL, PDO, Tokenizer, dan XML

• Composer (alat manajemen paket PHP)

Berikut adalah langkah-langkah instalasi Laravel:

Langkah 1: Instal Composer

Composer adalah alat manajemen paket PHP yang digunakan untuk menginstal Laravel dan dependensinya. Jika Anda belum memiliki Composer, Anda dapat mengunduhnya dari situs resminya di https://getcomposer.org/download/.

Langkah 2: Buka Terminal atau Command Prompt

Buka terminal (Linux/Mac) atau command prompt (Windows) pada komputer Anda.

Langkah 3: Instal Laravel Menggunakan Composer

Setelah terminal atau command prompt terbuka, masukkan perintah berikut untuk menginstal Laravel menggunakan Composer:

composer create-project laravel/laravel example-app

Atau anda dapat menginstall laravel secara global dengan perintah :

composer global require laravel/installer

laravel new example-app

Ubahlah "example-app" dengan nama yang Anda inginkan untuk proyek Laravel baru Anda.

Langkah 4: Jalankan Aplikasi

Setelah proses pembuatan proyek selesai, Anda dapat menjalankan aplikasi Laravel menggunakan server bawaan dengan perintah berikut:

cd example-app
php artisan serve

Setelah itu, buka browser dan kunjungi http://localhost:8000 untuk melihat aplikasi Laravel Anda berjalan.

Selamat... Laravel anda berhasil dijalankan.

Sebelum itu mari kita berkenalan dengan mutex ,Mutex adalah Mutual Exclusion konsep dalam Bahasa pemograman Golang menghindari akses secara bersamaan ke sumber daya yang dibagi Oleh beberapa Gorotine(Unit eksekusi konkuren dalam Go) atau thread.Dalam Go atau Golang,Anda Dapat menggunakan mekanisme mutex untuk mencapai sikronisasi dan mengamankan akses ke data bersama.

Dalam Go,anda dapat menggunakan tipe 'sync.Mutex' untuk membuat mutex.code dibawah ini akan membuat kamu lebih mengerti cara penggunaanya

package main

import ( "fmt" "sync" )

var counter int var mutex sync.Mutex

func increment() { mutex.Lock() 

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
increment()
wg.Done()
}() }
wg.Wait()
fmt.Println("Counter:", counter)
}

Pada contoh diatas kita memiliki fungsi 'increment' untuk meningkatkan nilai 'counter' secara aman dengan menggunakan mutex.saat goroutine mencoba untuk mengakses 'increment' pada satu waktu,sehingga menghindari akses bersamaan dan menghindari data race yang dapat menyebabkan masalah dalam program konkuren.

Show,"MUTEX di Golang" mengacu pada konsep mutex dan penggunaannya dalam bahasa pemograman Go (Golang) untuk sikronisasi dan mengamankan akses kedata bersama dalam program konkuren.