---
# System prepended metadata

title: MiM - Zadania

---

---
title: MiM - Zadania
---

Wszystkie zadania zostały wykonane według poleceń na ocenę 5.0 (bdb)


## Zad 7

### Konfiguracja
![](https://i.imgur.com/K2pVrKo.png)

### Kod

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

  MX_GPIO_Init();
    
  HAL_GPIO_WritePin(LD3_GPIO_Port,LD3_Pin,GPIO_PIN_RESET);
  HAL_GPIO_WritePin(LD4_GPIO_Port,LD4_Pin,GPIO_PIN_RESET);

  while (1)
  {   
    CheckIfPressed();
    
    if(HAL_GPIO_ReadPin(LD3_GPIO_Port, LD3_Pin) == 1)
    {
      HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, GPIO_PIN_RESET);
      HAL_Delay(300);
    }
    else
    {
      HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, GPIO_PIN_SET);
      HAL_Delay(300);
    }
  }
}
```

dodatkowe funkcje
```cpp
void Func()
{
  HAL_GPIO_WritePin(LD3_GPIO_Port,LD3_Pin,GPIO_PIN_RESET);
  HAL_GPIO_WritePin(LD4_GPIO_Port,LD4_Pin,GPIO_PIN_SET);
  
  while(HAL_GPIO_ReadPin(USER_GPIO_Port,USER_Pin)!=0);
  
  HAL_GPIO_WritePin(LD4_GPIO_Port, LD4_Pin, GPIO_PIN_RESET);
  
  return;
}

void CheckIfPressed()
{
  if(HAL_GPIO_ReadPin(USER_GPIO_Port,USER_Pin)!=0)
      Func();
}
```

### Przykład działania
https://youtube.com/shorts/wyVYqVUr8xA

## Zad 8

### Konfiguracja
![](https://i.imgur.com/ycgDEjE.png)

![](https://i.imgur.com/dDixhWS.png)

![](https://i.imgur.com/B7dAHFF.png)



### Kod

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

  MX_GPIO_Init();
  MX_TIM3_Init();

  HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_2);

  while (1)
  {
  }
}
```

init
```cpp
static void MX_TIM3_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 1;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 65535;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 10000;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
    
  HAL_TIM_MspPostInit(&htim3);
}
```

### Przykład działania
* pulse = 10![](https://i.imgur.com/2NDzHb1.jpg)
* pulse = 100![](https://i.imgur.com/qTBMuBP.jpg)
* pulse = 1000![](https://i.imgur.com/ystUPM5.jpg)
* pulse = 10000![](https://i.imgur.com/EFpb8MN.jpg)
* pulse = 100000![](https://i.imgur.com/74SZwA7.jpg)


## Zad 9

### Konfiguracja

![](https://i.imgur.com/FuHR3aH.png)

![](https://i.imgur.com/bB85TG5.png)

![](https://i.imgur.com/YoxFLKR.png)

### Kod

Zmienne globalne
```cpp
double wynik[100];
double sr1 = 0;
double sr2 = 0;
double k = 100;
```

main
```cpp=
int main(void)
{
  HAL_Init();
    
  SystemClock_Config();
    
  MX_GPIO_Init();
  MX_ADC_Init();
    
  while (1)
  {
    for(int i = 0; i < 100; i++)
    {
      HAL_ADC_Start(&hadc);
      HAL_ADC_PollForConversion(&hadc, 10);
      HAL_Delay(100);
      wynik[i] = HAL_ADC_GetValue(&hadc);
      if(i > 0)
      {
        if(wynik[i] - wynik[i-1] > 50 || wynik[i] - wynik[i-1] < -50)
        {
          wynik[i] = 0;
          k--;
        }
      }
      HAL_ADC_Stop(&hadc);
    }
    
    for(int j = 0; j < 100 ; j++)
      sr2 += wynik[j];
    sr2 /= k;
    if(sr1 == 0) sr1 = sr2;
    
    if(sr2 - sr1 > 5)
    {
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_SET);
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_RESET);
    }
    else if(sr2 - sr1 < -5)
    {
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_RESET);
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_SET);
    }
    else
    {
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_RESET);
      HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_RESET);
    }
    
    sr1 = sr2;
    sr2 = 0;
    k = 100;
  }
}
```

init
```cpp=
static void MX_ADC_Init(void)
{
  ADC_ChannelConfTypeDef sConfig = {0};

  hadc.Instance = ADC1;
  hadc.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc.Init.Resolution = ADC_RESOLUTION_12B;
  hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
  hadc.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  hadc.Init.LowPowerAutoWait = DISABLE;
  hadc.Init.LowPowerAutoPowerOff = DISABLE;
  hadc.Init.ContinuousConvMode = ENABLE;
  hadc.Init.DiscontinuousConvMode = DISABLE;
  hadc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc.Init.DMAContinuousRequests = DISABLE;
  hadc.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  if (HAL_ADC_Init(&hadc) != HAL_OK)
  {
    Error_Handler();
  }

  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
  sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
}

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

  __HAL_RCC_GPIOC_CLK_ENABLE();

  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7|GPIO_PIN_9, GPIO_PIN_RESET);

  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}
```

### Przykład działania
* Po ogrzaniu![](https://i.imgur.com/gBu9KbT.jpg)

* Po ochłodzeniu![](https://i.imgur.com/JgNx7bK.jpg)

* W stałej temperaturze![](https://i.imgur.com/9vTnttB.jpg)
