Tugas 1 Farel Aveldo Mikroprosessor dan Mikrokontroller



LAMPU LORONG OTOMATIS BERBASIS TOUCH DAN INFRARED SENSOR

a.Rangkaian Simulasi dan Prinsip Kerja [kembali]

  • Touch Sensor

  Prinsip kerjanya adalah ketika Touch Sensor menerima sentuhan mekanis dari manusia,maka Touch Sensor ( TTP223B ) akan mengirim sinyal ke modul STM NUCLEO dengan mengirimkan tegangan 5v sebagai sinyal input, kemudian modul akan mengirimkan sinyal ke relay sehingga relaynya akan switch Normally Open ( NO ) dan akan mengirimkan sinnyal ke sumber listrik rumah tangga 220V sehingga lampu lorong akan hidup selama ada sentuhan atau gerakan mekanis pada manusia. 


Gambar 1.1 Rangkaian Simulasi Touch Sensor

  • Infrared Sensor

Prinsip kerjanya adalah ketika Infrared Sensor mendeteksi adanya gerakan manusia, sensor akan berlogika 1dan akan mengirim sinyal 5V kepada STM NUCLEO sehingga modul akan mengirim sinyal ke relay Normally Open ( NO ) dan relay akan switch sehingga listrik rumah tangga 220V akan menghidupkan lampu lorong selama ada aktivitas manusia.



Gambar 1.2 Rangkaian Simulasi Infrared Sensor

b. Listing Program [kembali]

  • main c
#include "main.h"

// HANDLE
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim3;

// VARIABLE
volatile uint8_t emergency_mode = 0;
uint32_t last_motion_time = 0;
// fallback tombol
uint8_t last_button_state = 1;

// PARAMETER
#define LDR_DARK_THRESHOLD 2000    // Threshold untuk GELAP (nilai ADC tinggi)
#define MOTION_TIMEOUT 5000        // 5 detik timeout setelah gerakan
#define LED_OFF 0
#define LED_BRIGHT 1000            // Terang penuh
#define LED_DIM 0                  // Dim = OFF sesuai requirement

// ================= CLOCK =================
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}

// ================= GPIO =================
void MX_GPIO_Init(void)
{
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // PIR → PA1 (INPUT)
    GPIO_InitStruct.Pin = GPIO_PIN_1;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // BUTTON → PB1 (PULL-UP + INTERRUPT)
    GPIO_InitStruct.Pin = GPIO_PIN_1;
    GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    // LED PWM → PA6
    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF1_TIM3;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // IRQ untuk PB1 (EXTI0_1)
    HAL_NVIC_SetPriority(EXTI0_1_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(EXTI0_1_IRQn);
}

// ================= ADC =================
void MX_ADC1_Init(void)
{
    __HAL_RCC_ADC_CLK_ENABLE();
    hadc1.Instance = ADC1;
    hadc1.Init.Resolution = ADC_RESOLUTION_12B;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
    hadc1.Init.ContinuousConvMode = DISABLE;
    HAL_ADC_Init(&hadc1);

    ADC_ChannelConfTypeDef sConfig = {0};
    sConfig.Channel = ADC_CHANNEL_0;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

// ================= PWM =================
void MX_TIM3_Init(void)
{
    __HAL_RCC_TIM3_CLK_ENABLE();
    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 64;
    htim3.Init.Period = 1000;
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    HAL_TIM_PWM_Init(&htim3);

    TIM_OC_InitTypeDef sConfigOC = {0};
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = 0;
    HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
}

// ================= INTERRUPT =================
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == GPIO_PIN_1)
    {
        emergency_mode = !emergency_mode;
    }
}

// ================= HELPER =================
uint16_t read_LDR(void)
{
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
    return HAL_ADC_GetValue(&hadc1);
}

void set_LED(uint16_t value)
{
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, value);
}

// ================= MAIN =================
int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_ADC1_Init();
    MX_TIM3_Init();
    HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);

    // Inisialisasi LED mati
    set_LED(LED_OFF);

    while (1)
    {
        // ===== FALLBACK BUTTON =====
        uint8_t current_button = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
        if (last_button_state == 1 && current_button == 0)
        {
            emergency_mode = !emergency_mode;
            HAL_Delay(50); // Debounce
        }
        last_button_state = current_button;

        // ===== MODE DARURAT =====
        if (emergency_mode)
        {
            set_LED(LED_OFF);
            HAL_Delay(100);
            continue;
        }

        // ===== LOGIKA UTAMA =====
        uint16_t ldr_value = read_LDR();
        uint8_t pir_value = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1);

        // CEK KONDISI GELAP (LDR > threshold)
        if (ldr_value > LDR_DARK_THRESHOLD)
        {
            // GELAP - Cek PIR
            if (pir_value == GPIO_PIN_SET)
            {
                // Deteksi gerakan - nyalakan terang & update timer
                last_motion_time = HAL_GetTick();
                set_LED(LED_BRIGHT);
            }
            else
            {
                // Tidak ada gerakan - cek timeout
                if (HAL_GetTick() - last_motion_time < MOTION_TIMEOUT)
                {
                    // Masih dalam timeout - tetap terang
                    set_LED(LED_BRIGHT);
                }
                else
                {
                    // Timeout habis - mati
                    set_LED(LED_OFF);
                }
            }
        }
        else
        {
            // SIANG - lampu selalu mati
            set_LED(LED_OFF);
            last_motion_time = 0; // Reset timer
        }

        HAL_Delay(100);
    }
}

  • main h 
#ifndef __MAIN_H 
 #define __MAIN_H 
#include "stm32c0xx_hal.h"

 

// ================= PIN DEFINITIONS =================

  • // LDR (ADC)

    #define LDR_PORT GPIOA

    #define LDR_PIN GPIO_PIN_0 // PA0

    // PIR SENSOR

    #define PIR_PORT GPIOA

    #define PIR_PIN GPIO_PIN_1 // PA1

    // PUSH BUTTON (INTERRUPT)

    #define BUTTON_PORT GPIOB

    #define BUTTON_PIN GPIO_PIN_1 // PB1

    // LED PWM

    #define LED_PORT GPIOA

    #define LED_PIN GPIO_PIN_6 // PA6 (TIM3_CH1)

    // ================= FUNCTION PROTOTYPES =================

    void SystemClock_Config(void);

    void MX_GPIO_Init(void);

    void MX_ADC1_Init(void);

    void MX_TIM3_Init(void);

    #endif

LAMPU LORONG PARALEL BERBASIS PIR DAN INFRARED SENSOR DENGAN STM NUCLEO 

a.Rangkaian Simulasi dan Prinsip Kerja [kembali]
#

Gambar 2.1 Rangkaian Simulasi PIR Sensor 


Gambar 2.2 Rangkaian Simulasi Infrared Sensor 
b. Listing Program [kembali]

#include "stm32c0xx_hal.h"

 

// Prototipe Fungsi

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_ADC1_Init(void);

static void MX_TIM1_Init(void);

uint16_t Baca_LDR(void);

void Jalankan_Sequence_PIR(uint16_t brightness);

 

// Handle untuk Peripheral

ADC_HandleTypeDef hadc1;

TIM_HandleTypeDef htim1;

 

int main(void) {

    HAL_Init();

    SystemClock_Config();

    MX_GPIO_Init();

    MX_ADC1_Init();

    MX_TIM1_Init();

 

    // Start PWM untuk 3 LED pada Timer 1

    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);

    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);

    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);

 

    while (1) {

        uint16_t nilai_ldr = Baca_LDR();

        

        // Logika Dimming Wokwi:

        // Cahaya Rendah (Gelap) = Terang (PWM Tinggi)

        // Nilai ADC 0-4095 dipetakan ke PWM 0-1000 secara terbalik

        int32_t calc_brightness = 1000 - (nilai_ldr * 1000 / 4095);

        if (calc_brightness < 0) calc_brightness = 0;

        uint16_t brightness = (uint16_t)calc_brightness;

 

        // Cek Sensor PIR (PB1)

        if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == GPIO_PIN_SET) {

            Jalankan_Sequence_PIR(brightness);

        } else {

            // Mode Standby LDR

            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, brightness);

            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, brightness);

            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, brightness);

        }

        HAL_Delay(50);

    }

}

 

uint16_t Baca_LDR(void) {

    HAL_ADC_Start(&hadc1);

    if (HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK) {

        uint16_t val = HAL_ADC_GetValue(&hadc1);

        HAL_ADC_Stop(&hadc1);

        return val;

    }

    HAL_ADC_Stop(&hadc1);

    return 0;

}

 

void Jalankan_Sequence_PIR(uint16_t brightness) {

    // Reset LED

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 0);

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, 0);

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, 0);

 

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, brightness);

    HAL_Delay(1000); // 1 Detik

 

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, brightness);

    HAL_Delay(3000); // 3 Detik

 

    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, brightness);

    HAL_Delay(5000); // 5 Detik

}

 

static void MX_ADC1_Init(void) {

    ADC_ChannelConfTypeDef sConfig = {0};

 

    hadc1.Instance = ADC1;

    hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;

    hadc1.Init.Resolution = ADC_RESOLUTION_12B;

    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;

    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;

    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;

    hadc1.Init.LowPowerAutoWait = DISABLE;

    hadc1.Init.ContinuousConvMode = DISABLE;

    hadc1.Init.DiscontinuousConvMode = DISABLE;

    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;

    hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;

    hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_1CYCLE_5;

    HAL_ADC_Init(&hadc1);

 

    sConfig.Channel = ADC_CHANNEL_0; // PA0

    sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;

    sConfig.SamplingTime = ADC_SAMPLINGTIME_COMMON_1;

    HAL_ADC_ConfigChannel(&hadc1, &sConfig);

}

 

static void MX_TIM1_Init(void) {

    TIM_OC_InitTypeDef sConfigOC = {0};

 

    htim1.Instance = TIM1;

    htim1.Init.Prescaler = 48 - 1;

    htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

    htim1.Init.Period = 1000 - 1;

    HAL_TIM_PWM_Init(&htim1);

 

    sConfigOC.OCMode = TIM_OCMODE_PWM1;

    sConfigOC.Pulse = 0;

    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

    

    HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);

    HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2);

    HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3);

}

 

static void MX_GPIO_Init(void) {

    GPIO_InitTypeDef GPIO_InitStruct = {0};

 

    __HAL_RCC_GPIOA_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();

    __HAL_RCC_TIM1_CLK_ENABLE();

    

    /* PERBAIKAN DI SINI: Makro untuk seri C0 */

    __HAL_RCC_ADC_CLK_ENABLE();

 

    // PIR: PB1

    GPIO_InitStruct.Pin = GPIO_PIN_1;

    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

    GPIO_InitStruct.Pull = GPIO_PULLDOWN;

    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

 

    // LED PWM: PA8, PA9, PA10 (TIM1)

    GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF2_TIM1;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

}

 

// System Clock minimal untuk Wokwi

void SystemClock_Config(void) {

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;

    RCC_OscInitStruct.HSIState = RCC_HSI_ON;

    RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;

    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

    HAL_RCC_OscConfig(&RCC_OscInitStruct);

 

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);

}

  • main h
#ifndef __MAIN_H
#define __MAIN_H

#include "stm32c0xx_hal.h"

/* Definisi Pin LED (PWM - Timer 1) */
#define LED_PORT        GPIOA
#define LED1_PIN        GPIO_PIN_8   // TIM1_CH1
#define LED2_PIN        GPIO_PIN_9   // TIM1_CH2
#define LED3_PIN        GPIO_PIN_10  // TIM1_CH3

/* Definisi Pin Sensor */
#define PIR_PORT        GPIOB
#define PIR_PIN         GPIO_PIN_1
#define LDR_CHANNEL     ADC_CHANNEL_0 // PA0

/* Prototipe Fungsi */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM1_Init(void);
uint16_t Baca_LDR(void);
void Jalankan_Sequence_PIR(uint16_t brightness);

#endif




TANGKI AIR OTOMATIS BERBASIS FLAME & FLOAT SENSOR DENGAN STM NUCLEO


Gambar 3.1 Rangkaian Simulasi Flame Sensor





Gambar 3.2 Rangkaian Simulasi Float Sensor

#include "main.h"
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
while (1)
{
GPIO_PinState flame_state;
GPIO_PinState float_state;
flame_state = HAL_GPIO_ReadPin(FLAME_PORT, FLAME_PIN);
float_state = HAL_GPIO_ReadPin(FLOAT_PORT, FLOAT_PIN);
/* ===== FLAME SENSOR ===== */
if (flame_state == GPIO_PIN_SET)
{
/* Api terdeteksi */
HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_SET);
HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, GPIO_PIN_SET);
}
else
{
HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, GPIO_PIN_RESET);
}
/* ===== RELAY / POMPA ===== */
if ((flame_state == GPIO_PIN_SET) || (float_state == GPIO_PIN_SET))
{
/* Api ATAU tangki penuh → pompa MATI */
HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_RESET);
}
else
{
/* Aman & tangki belum penuh → pompa HIDUP */
HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_SET);
}
HAL_Delay(100);
}
}
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOA_CLK_ENABLE();
/* INPUT */
GPIO_InitStruct.Pin = FLAME_PIN | FLOAT_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* OUTPUT */
GPIO_InitStruct.Pin = LED_PIN | BUZZER_PIN | RELAY_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Relay default ON */
HAL_GPIO_WritePin(RELAY_PORT, RELAY_PIN, GPIO_PIN_SET);
}
void SystemClock_Config(void)
{
/* Clock default CubeIDE */
}
void Error_Handler(void)
{
while (1) {}
}

  • main h 

#ifndef __MAIN_H


#define __MAIN_H

#ifdef __cplusplus

extern "C" {

#endif

#include "stm32c0xx_hal.h"

/* ====== INPUT ====== */

#define FLAME_PIN GPIO_PIN_0

#define FLAME_PORT GPIOA

#define FLOAT_PIN GPIO_PIN_1

#define FLOAT_PORT GPIOA

/* ====== OUTPUT ====== */

#define LED_PIN GPIO_PIN_5

#define LED_PORT GPIOA

#define BUZZER_PIN GPIO_PIN_6

#define BUZZER_PORT GPIOA

#define RELAY_PIN GPIO_PIN_7

#define RELAY_PORT GPIOA

void Error_Handler(void);

#ifdef __cplusplus

}

#endif

#endif /* __MAIN_H */

c. Kesimpulan dan Saran


d. Download File [kembali] 


Komentar

Posting Komentar

Postingan populer dari blog ini

Gambar
 BAHAN PRESENTASI UNTUK MATA KULIAH  ELEKTRONIKA  Disusun Oleh : Farel Aveldo NIM : 2310951028 Dosen Pengampu : Dr. Darwison ,MT Referensi : a. Darwison, 2010, ”TEORI, SIMULASI DAN APLIKASI ELEKTRONIKA ”, Jilid 1, ISBN: 978-602-9081-10-7, CV Ferila, Padang  b. Darwison, 2010, ”TEORI, SIMULASI DAN APLIKASI ELEKTRONIKA ”,Jilid 2,  ISBN: 978-602-9081-10-8, CV Ferila, Padang  c. Robert L. Boylestad and Louis Nashelsky, Electronic Devices and Circuit Theory, Pearson, 2013  d. Jimmie J. Cathey, Theory and Problems of Electronic Device and Circuit, McGraw Hill, 2002. e. Keith Brindley, Starting Electronics, Newness 3rd Edition, 2005 f. Ian R. Sinclair and John Dunton, Practical Electronics Handbook, Newness, 2007. g. John M. Hughes, Practical Electronics: Components and Techniques, O’Reilly Media, 2016. JURUSAN TEKNIK ELEKTRO FAKULTAS TEKNIK PADANG 2024
Baca selengkapnya

Modul 1 General Up & Uc

Gambar
  [KEMBALI KE MENU SEBELUMNYA] DAFTAR ISI 1. Pendahuluan 2. Tujuan 3. Alat dan Bahan 4. Dasar Teori 5. Percobaan Percobaan ...  A. Tugas Pendahuluan 1 dan LA B. Tugas Pendahuluan 2 dan LA   MODUL 1 GENERAL INPUT DAN OUTPUT 1 .  Pendahuluan  [Kembali] Pada percobaan pertama dirancang suatu sistem kontrol lampu lorong berbasis mikrokontroler yang memanfaatkan sensor sebagai input untuk mengatur kondisi pencahayaan secara otomatis. Sistem ini menggunakan sensor sentuh (touch) dan sensor gerak sebagai pendeteksi keberadaan aktivitas di sekitar lorong. Mikrokontroler berperan sebagai pusat pengolah data yang menentukan kapan lampu dan buzzer diaktifkan atau dinonaktifkan sesuai dengan kondisi input yang diterima. Tujuan dari percobaan ini adalah untuk memahami konsep dasar pengolahan sinyal digital, logika kontrol berbasis kondisi, serta implementasi sistem otomatis sederhana yang dapat diaplikasikan pada penerangan hemat energi di lingkungan nyata. Sedangakan pada p...
Baca selengkapnya