Percobaan 3 Kondisi 6

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Prosedur

2. Hardware dan Diagram Blok

3. Rangkaian Simulasi dan Prinsip Kerja

4. Flowchart dan Listing Program

5. Video Demo

6. Kondisi

7. Video Simulasi

8. Download File

1. Prosedur [Kembali]

Pahami terlebih dahulu kondisi yang akan digunakan
Buka software Proteus 8.17
Persiapkan alat dan bahan
Buat rangkaian sesuai dengan kondisi dan modul
Buka software STM32Cube IDE
Setelah membuka software, pilih perangkat STM32F103C8T6
Sesuaikan konfigurasi pin sesuai dengan rangkaian proteus
Buat kode program untuk mengoperasikan rangkaian tersebut sesuai dengan kondisi
Konfigurasi kan program dengan software Proteus
Jalankan simulasi rangkaian.
Proses selesai

2. Hardware dan Diagram Blok [Kembali]

Hardware

STM32F103C8T6

Sensor Suhu Lm35

Kipas DC

Push Button

Motor Driver l298N

Breadboard

Adaptor

Resistor

Diagram Blok

3. Rangkaian Simulasi dan Prinsip Kerja [Kembali]

1. Pembacaan suhu — LM35 ke ADC
LM35 merupakan sensor suhu analog dengan karakteristik output sebesar 10 mV per °C. Pin output (VOUT) dari LM35 dihubungkan ke pin analog mikrokontroler (misalnya PA0) yang dikonfigurasi sebagai ADC channel.
Mikrokontroler membaca nilai digital dari ADC, kemudian mengubahnya menjadi tegangan dan suhu menggunakan persamaan:
voltage = (adcValue / 4095.0) × 3.3 → tegangan (Volt)
temperature = voltage × 100.0 → suhu (°C)
Nilai suhu inilah yang digunakan sebagai parameter untuk menentukan kondisi kipas.

2. Tombol ON — Input Digital
Tombol dihubungkan ke salah satu pin GPIO (misalnya PA1) dan dikonfigurasi sebagai input dengan pull-up. Ketika tombol ditekan, logika berubah dari HIGH menjadi LOW.
Program mendeteksi perubahan ini menggunakan pembacaan pin secara berkala (polling), lalu mengaktifkan kipas dengan logika:
if(button == PRESSED && last_button == RELEASED)
{
fan_status = 1;
}
Pendekatan ini memastikan bahwa:
Kipas hanya aktif sekali saat tombol ditekan
Tidak terjadi pembacaan berulang saat tombol ditahan

3. Kontrol kipas — Driver Motor (L298)
Kipas DC dikendalikan menggunakan driver motor L298. Dua pin utama digunakan:
IN1 → mengaktifkan motor
IN2 → menentukan kondisi berhenti
Kondisi dasar:
Kipas ON → IN1 = HIGH, IN2 = LOW
Kipas OFF → IN1 = LOW, IN2 = LOW
Pada kondisi normal (kipas hidup), motor berputar penuh tanpa PWM hardware.

4. Logika kontrol sistem
Sistem memiliki dua kondisi utama:
Kondisi Aksi Kipas
Tombol ditekan sekali Kipas menyala
Suhu ≤ 30°C Kipas tetap menyala
Suhu > 30°C Kipas mati perlahan (5 detik)
Logika program:
Saat tombol ditekan → kipas aktif (`fan_status = 1`)
Selama suhu masih ≤ 30°C → kipas tetap hidup
Ketika suhu melewati 30°C → sistem masuk proses slow stop

5. Proses berhenti perlahan (Soft Stop 5 detik)
Ketika suhu > 30°C, kipas tidak langsung dimatikan, melainkan diturunkan kecepatannya secara bertahap selama ±5 detik.
Metode yang digunakan adalah software PWM, dengan penurunan duty cycle:
duty: 100 → 0 (step -5)
Setiap nilai duty dipertahankan selama 250 ms:
Total waktu = 20 step × 250 ms = 5000 ms (5 detik)
PWM dibuat dengan mengatur pin ON dan OFF menggunakan delay:
ON time = duty / 5
OFF time = (100 - duty) / 5
Semakin kecil nilai duty:
Waktu ON semakin kecil
Waktu OFF semakin besar
Putaran kipas semakin lambat
Pada akhir proses:
Fan_OFF();
Kipas berhenti sepenuhnya.

Kondisi	Aksi Kipas
Tombol ditekan sekali	Kipas menyala
Suhu ≤ 30°C	Kipas tetap menyala
Suhu > 30°C	Kipas mati perlahan (5 detik)

4. Flowchart dan Listing Program [Kembali]

Flowchart

#include "main.h"

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);

/* ================= USER CODE ================= */

uint32_t Read_ADC(void)
{
  uint32_t adc;

  HAL_ADC_Start(&hadc1);
  HAL_ADC_PollForConversion(&hadc1, 100);
  adc = HAL_ADC_GetValue(&hadc1);
  HAL_ADC_Stop(&hadc1);

  return adc;
}

float Read_Temperature(void)
{
  uint32_t adc = Read_ADC();

  float voltage = adc * 3.3f / 4095.0f;
  float suhu = voltage * 100.0f;   // LM35

  return suhu;
}

/* ================= FAN CONTROL ================= */

void Fan_ON(void)
{
  HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(IN2_GPIO_Port, IN2_Pin, GPIO_PIN_RESET);
}

void Fan_OFF(void)
{
  HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(IN2_GPIO_Port, IN2_Pin, GPIO_PIN_RESET);
}

/* Mati perlahan ±5 detik (software PWM) */
void Fan_Slow_Stop_5s(void)
{
  for(int duty = 100; duty >= 0; duty -= 5)
  {
    uint32_t start = HAL_GetTick();

    while(HAL_GetTick() - start < 250)
    {
      HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_SET);
      HAL_Delay(duty / 5);

      HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_RESET);
      HAL_Delay((100 - duty) / 5);
    }
  }

  Fan_OFF();
}

/* ================= MAIN ================= */

int main(void)
{
  HAL_Init();
  SystemClock_Config();

  MX_GPIO_Init();
  MX_ADC1_Init();

  uint8_t fan_status = 0;
  uint8_t last_button = GPIO_PIN_SET;

  Fan_OFF();

  while (1)
  {
    float suhu = Read_Temperature();

    uint8_t button = HAL_GPIO_ReadPin(BUTTON_GPIO_Port, BUTTON_Pin);

    /* Tombol ditekan sekali → kipas hidup */
    if(button == GPIO_PIN_RESET && last_button == GPIO_PIN_SET)
    {
      HAL_Delay(50); // debounce

      if(HAL_GPIO_ReadPin(BUTTON_GPIO_Port, BUTTON_Pin) == GPIO_PIN_RESET)
      {
        fan_status = 1;
        Fan_ON();
      }
    }

    last_button = button;

    /* Suhu > 30°C → kipas mati perlahan */
    if(fan_status == 1 && suhu > 30.0f)
    {
      fan_status = 0;
      Fan_Slow_Stop_5s();
    }

    HAL_Delay(100);
  }
}

/* ================= CONFIG ================= */

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK |
                               RCC_CLOCKTYPE_SYSCLK |
                               RCC_CLOCKTYPE_PCLK1 |
                               RCC_CLOCKTYPE_PCLK2;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);

  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;

  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
}

static void MX_ADC1_Init(void)
{
  ADC_ChannelConfTypeDef sConfig = {0};

  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;

  HAL_ADC_Init(&hadc1);

  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;

  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* Set awal output */
  HAL_GPIO_WritePin(GPIOA, IN1_Pin | IN2_Pin, GPIO_PIN_RESET);

  /* OUTPUT motor */
  GPIO_InitStruct.Pin = IN1_Pin | IN2_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);

  /* INPUT tombol */
  GPIO_InitStruct.Pin = BUTTON_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(BUTTON_GPIO_Port, &GPIO_InitStruct);
}

void Error_Handler(void)
{
  __disable_irq();
  while (1)
  {
  }
}

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif

5. Video Demo [Kembali]

6. Kondisi [Kembali]

Buatlah rangkaian seperti percobaan 3 dengan kondisi ketika sensor tombol ditekan sekali maka kipas hidup dan ketika sensor suhu >30 C maka kipas mati secara perlahan selama 5 detik.

7. Video Simulasi [Kembali]

8. Download File [Kembali]

Rangkaian dan Program Proteus [tekan disini]

Video Rangkaian [tekan disini]

Cari Blog Ini

Afwan Nasution 231009

Percobaan 3 Kondisi 6

Komentar

Posting Komentar