imalanik
/
BUTCube
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Camera_driver: Update doxygen documentation of camera driver

Browse Source
Camera_driver
Petr Malanik 2 years ago
parent d99e4b27e6
commit 9ce15191d3
7 changed files with 449 additions and 332 deletions
Show Stats Download Patch File Download Diff File

27
resources/FC_camera/App/butcube_imager.hpp
Unescape View File

@ -16,17 +16,44 @@
using namespace std; using namespace std;
typedef unsigned int uint; typedef unsigned int uint;
/**
* @brief Captures image data from camera, control power to camera and transmit data on selected interfaces
* Currently is only UART interface supported
*/
class ButCube_imager class ButCube_imager
{ {
private: private:
/**
* @brief UART interfaces to which data will be exported, interfaces muse be configured in advance
*/
vector<UART_HandleTypeDef> uart_output_interfaces; vector<UART_HandleTypeDef> uart_output_interfaces;
public: public:
/**
* @brief Construct a new ButCube_imager object
*/
ButCube_imager() = default; ButCube_imager() = default;
/**
* @brief Add UART output to list on which data are exported
*
* @param uart_output UART output to which export data from camera
* @return int
*/
int Add_output(UART_HandleTypeDef uart_output); int Add_output(UART_HandleTypeDef uart_output);
/**
* @brief Transmit data from source to selected interfaces
*
* @param source Source of image data
* @return int Count of bytes exported
*/
int Transmit(vector<uint8_t> source); int Transmit(vector<uint8_t> source);
/**
* @brief Enable or power to camera, controls load switch on camera power rail
*
* @param state true = Enabled, false = Disabled
*/
void Camera_power(bool state); void Camera_power(bool state);
}; };

3
resources/FC_camera/Camera_driver/OV2640.cpp
Unescape View File

@ -17,6 +17,7 @@ void OV2640::Init(const vector<Register_blob_8> &regs){
Sensor_write_register_bulk(regs); Sensor_write_register_bulk(regs);
// Setup camera, H-sync: High, V-sync:high, Sensor_delay: no Delay, FIFO_mode:FIFO enabled, power_mode:Low_power
ArduChip_write(0x03, 0b01010000); ArduChip_write(0x03, 0b01010000);
} }
@ -48,8 +49,6 @@ void OV2640::Capture(){
// while(SPI_handle.State != HAL_SPI_STATE_READY){;} // while(SPI_handle.State != HAL_SPI_STATE_READY){;}
HAL_Delay(300); // delay to ensure full dma transmission HAL_Delay(300); // delay to ensure full dma transmission
// HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
ArduChip_CS_disable(); ArduChip_CS_disable();
HAL_UART_Transmit(&UART_handle, image_data.data(), image_size, HAL_MAX_DELAY);
} // OV2640::Capture } // OV2640::Capture

27
resources/FC_camera/Camera_driver/OV2640.hpp
Unescape View File

@ -14,20 +14,41 @@
using namespace std; using namespace std;
typedef unsigned int uint; typedef unsigned int uint;
/**
* @brief 2MP SPI based camera capable of JPEG compression, based on ArduChip
*/
class OV2640: protected SPI_camera class OV2640: protected SPI_camera
{ {
private: private:
/**
* @brief Initialize camera sensor for JPEG capture, without resolution settings
*/
void Init() override final;
public: public:
/**
* @brief Inherit constructor from parent class SPI_camera
*/
using SPI_camera::SPI_camera; using SPI_camera::SPI_camera;
void Init() override final; /**
* @brief Initialize camera sensor for JPEG capture
*
* @param regs Requested resolution of camera
*/
void Init(const vector<Register_blob_8> &regs); void Init(const vector<Register_blob_8> &regs);
/**
* @brief Initializes capture of image, waits for capture, transmit image into MCU memory
*/
void Capture() override final; void Capture() override final;
//vector<uint8_t> Image_data(){ return image_data; }; /**
* @brief Return pointer to last captured image data
*
* @return vector<uint8_t> Pointer to last captured image data
*/
vector<uint8_t> Image_data(){ return image_data; };
}; };

10
resources/FC_camera/Camera_driver/OV2640_regs.hpp
Unescape View File

@ -1,3 +1,13 @@
/**
* @file OV2640_regs.hpp
* @author Petr Malaník (TheColonelYoung(at)gmail(dot)com)
* @brief
* @version 0.1
* @date 11.09.2022
*
* Copied from ArduCam official repository on github
* https://github.com/ArduCAM/STM32
*/
#pragma once #pragma once
#include <vector> #include <vector>

4
resources/FC_camera/Camera_driver/SPI_camera.cpp
Unescape View File

@ -1,7 +1,7 @@
#include "SPI_camera.hpp" #include "SPI_camera.hpp"
SPI_camera::SPI_camera(I2C_HandleTypeDef I2C_handle, uint8_t I2C_address, SPI_HandleTypeDef SPI_handle, Chip_select_pin SPI_CS, UART_HandleTypeDef UART_handle) : I2C_handle(I2C_handle), I2C_address( SPI_camera::SPI_camera(I2C_HandleTypeDef I2C_handle, uint8_t I2C_address, SPI_HandleTypeDef SPI_handle, Chip_select_pin SPI_CS) : I2C_handle(I2C_handle), I2C_address(
I2C_address), SPI_handle(SPI_handle), SPI_CS(SPI_CS), UART_handle(UART_handle){ } I2C_address), SPI_handle(SPI_handle), SPI_CS(SPI_CS){ }
int SPI_camera::Sensor_write_register(uint8_t address, uint8_t data){ int SPI_camera::Sensor_write_register(uint8_t address, uint8_t data){
return Sensor_write_register(Register_blob_8{ address, data }); return Sensor_write_register(Register_blob_8{ address, data });

126
resources/FC_camera/Camera_driver/SPI_camera.hpp
Unescape View File

@ -17,67 +17,185 @@
using namespace std; using namespace std;
typedef unsigned int uint; typedef unsigned int uint;
/**
* @brief Class representing SPI cameras based on Arduchip solution
* Currently is only supported OV2640
*/
class SPI_camera class SPI_camera
{ {
public: public:
/**
* @brief Describes GPIO which serves as SPI chip select pin
*/
struct Chip_select_pin { struct Chip_select_pin {
GPIO_TypeDef *port; GPIO_TypeDef *port;
uint16_t pin; uint16_t pin;
}; };
/**
* @brief Represents address and data of sensor settings, 8bit address, 8 bit data for example for OV2640 sensor
*/
struct Register_blob_8 { struct Register_blob_8 {
uint8_t address; uint8_t address;
uint8_t data; uint8_t data;
}; };
/**
* @brief Represents address and data of sensor settings, 16bit address, 8 bit data for example for OV5642 sensor
*/
struct Register_blob_16 { struct Register_blob_16 {
uint16_t address; uint16_t address;
uint8_t data; uint8_t data;
}; };
protected: protected:
/**
* @brief HAL handle of I2C which is connected to image sensor
*/
I2C_HandleTypeDef I2C_handle; I2C_HandleTypeDef I2C_handle;
/**
* @brief I2C address of sensor
* Common values: 0x60 for OV2640, 0x78 for OV5642
*/
uint8_t I2C_address = 0; uint8_t I2C_address = 0;
/**
* @brief HAL handle of SPI to which is ArduChip connected
*/
SPI_HandleTypeDef SPI_handle; SPI_HandleTypeDef SPI_handle;
Chip_select_pin SPI_CS;
UART_HandleTypeDef UART_handle; /**
* @brief GPIO description which serves as SPI Chip select
*/
Chip_select_pin SPI_CS;
/**
* @brief Raw image data transmitted from ArduChip via SPI to MCu memory
*/
vector<uint8_t> image_data; vector<uint8_t> image_data;
public: public:
SPI_camera(I2C_HandleTypeDef I2C_handle, uint8_t I2C_address, SPI_HandleTypeDef SPI_handle, Chip_select_pin SPI_CS, UART_HandleTypeDef UART_handle); /**
* @brief Construct a new SPI camera object
*
* @param I2C_handle HAL handle of I2C which is connected to image sensor
* @param I2C_address I2C address of sensor, Common values: 0x60 for OV2640, 0x78 for OV5642
* @param SPI_handle HAL handle of SPI to which is ArduChip connected
* @param SPI_CS GPIO description which serves as SPI Chip select
*/
SPI_camera(I2C_HandleTypeDef I2C_handle, uint8_t I2C_address, SPI_HandleTypeDef SPI_handle, Chip_select_pin SPI_CS);
/**
* @brief Virtual function for camera initialization, depends on camera model
*/
virtual void Init() = 0; virtual void Init() = 0;
/**
* @brief Virtual function for image capture, depends on camera model
*/
virtual void Capture() = 0; virtual void Capture() = 0;
protected: protected:
/**
* @brief Write 8-bit data to 8-bit address in image sensor via I2C, used for example in OV2640
*
* @param address Address (8-bit) to write
* @param data Data (8-bit) to write
* @return int HAL status
*/
int Sensor_write_register(uint8_t address, uint8_t data); int Sensor_write_register(uint8_t address, uint8_t data);
/**
* @brief Write 8-bit data to 16-bit address in image sensor via I2C, used for example in OV5642
*
* @param address Address (16-bit) to write
* @param data Data (8-bit) to write
* @return int HAL status
*/
int Sensor_write_register(uint16_t address, uint8_t data); int Sensor_write_register(uint16_t address, uint8_t data);
/**
* @brief Write register representation in structure (8-bit address, 8-bit data) into image sensor via I2C
* used for example in OV2640
*
* @param reg Register represented in structure (8-bit address, 8-bit data), used for example in OV2640
* @return int HAL status
*/
int Sensor_write_register(Register_blob_8 reg); int Sensor_write_register(Register_blob_8 reg);
/**
* @brief Write register representation in structure (16-bit address, 8-bit data) into image sensor via I2C
* used for example in OV5642
*
* @param reg Register represented in structure (16-bit address, 8-bit data), used for example in OV5642
* @return int HAL status
*/
int Sensor_write_register(Register_blob_16 reg); int Sensor_write_register(Register_blob_16 reg);
/**
* @brief Write vector of register settings (8-bit address, 8-bit data) into image sensor in bulk
* used for example in OV2640
*
* @param regs vector containing register settings (8-bit address, 8-bit data)
*/
void Sensor_write_register_bulk(vector<Register_blob_16> regs); void Sensor_write_register_bulk(vector<Register_blob_16> regs);
/**
* @brief Write vector of register settings (16-bit address, 8-bit data) into image sensor in bulk
* used for example in OV5642
*
* @param regs vector containing register settings (16-bit address, 8-bit data), used for example in OV5642
*/
void Sensor_write_register_bulk(vector<Register_blob_8> regs); void Sensor_write_register_bulk(vector<Register_blob_8> regs);
/**
* @brief Write data (8-bit) into register address (8-bit) of ArduChip via SPI
*
* @param addr Address (8-bit) to write
* @param data Data (8-bit) to write
* @return int HAL status
*/
int ArduChip_write(uint8_t addr, uint8_t data); int ArduChip_write(uint8_t addr, uint8_t data);
/**
* @brief Read data (8-bit) from register address (8-bit) of ArduChip via SPI
*
* @param address Address (8-bit) from which read
* @return int HAL status
*/
int ArduChip_read(uint8_t address); int ArduChip_read(uint8_t address);
/**
* @brief Calculates size of FIFO which is used for image data inside ArduChip
* Performs communication via SPI with ArduChip
*
* @return int Count of bytes in FIFO of ArduChip
*/
int ArduChip_FIFO_length(); int ArduChip_FIFO_length();
/**
* @brief Initialize Burst read of FIFO containing image data via SPI from ArduChip
* Must be followed by DMA request and read, after readout is complete CS signal must be disabled
*/
void ArduChip_start_burst_read(); void ArduChip_start_burst_read();
/**
* @brief Initialize DMA transfer of image data from ArduChip FIFO via SPI
* Burst read operation must be setup before, after readout is complete CS signal must be disabled
*
* @param size Amount of bytes to read
*/
void ArduChip_start_DMA_transfer(uint size); void ArduChip_start_DMA_transfer(uint size);
/**
* @brief Enable communication with ArduChip via SPI, CS signal is active low
*/
void ArduChip_CS_enable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_RESET); }; void ArduChip_CS_enable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_RESET); };
/**
* @brief Disables communication with ArduChip via SPI, CS signal is active low
*/
void ArduChip_CS_disable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_SET); }; void ArduChip_CS_disable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_SET); };
}; };

584
resources/FC_camera/Src/main.c
Unescape View File

@ -1,4 +1,5 @@
/* USER CODE BEGIN Header */ /* USER CODE BEGIN Header */
/** /**
****************************************************************************** ******************************************************************************
* @file : main.c * @file : main.c
@ -68,27 +69,15 @@ static void MX_USART1_UART_Init(void);
/* Private user code ---------------------------------------------------------*/ /* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */ /* USER CODE BEGIN 0 */
void Image_capture(){ void Image_capture(OV2640 *camera, ButCube_imager *transmitter){
HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin); HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
ButCube_imager *transmitter = new ButCube_imager();
transmitter->Camera_power(true);
// Wait for power rail to stabilize
HAL_Delay(1000);
OV2640 *camera = new OV2640(hi2c1, 0x60, hspi1, SPI_camera::Chip_select_pin{GPIOB, GPIO_PIN_0}, huart1);
//transmitter->Add_output(huart1);
camera->Init(OV2640_320x240_JPEG); camera->Init(OV2640_320x240_JPEG);
HAL_Delay(1000); HAL_Delay(1000);
camera->Capture(); camera->Capture();
transmitter->Transmit(camera->Image_data());
delete transmitter;
delete camera;
} }
/* USER CODE END 0 */ /* USER CODE END 0 */
@ -97,220 +86,183 @@ void Image_capture(){
* @brief The application entry point. * @brief The application entry point.
* @retval int * @retval int
*/ */
int main(void) int main(void){
{ /* USER CODE BEGIN 1 */
/* USER CODE BEGIN 1 */ /* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* USER CODE END 1 */ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* MCU Configuration--------------------------------------------------------*/
/* USER CODE BEGIN Init */
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */ /* USER CODE END Init */
HAL_Init(); /* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN Init */
/* USER CODE BEGIN SysInit */
/* USER CODE END Init */ /* USER CODE END SysInit */
/* Initialize all configured peripherals */
/* Configure the system clock */ MX_GPIO_Init();
SystemClock_Config(); MX_DMA_Init();
MX_I2C1_Init();
/* USER CODE BEGIN SysInit */ MX_SPI1_Init();
MX_USART1_UART_Init();
/* USER CODE END SysInit */ /* USER CODE BEGIN 2 */
/* Initialize all configured peripherals */ // Initialize SPI clock
MX_GPIO_Init(); uint8_t empty = 0x00;
MX_DMA_Init(); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
MX_I2C1_Init(); HAL_SPI_Transmit(&hspi1, &empty, 1, HAL_MAX_DELAY);
MX_SPI1_Init(); HAL_SPI_Receive(&hspi1, (uint8_t *) &empty, 1, HAL_MAX_DELAY);
MX_USART1_UART_Init(); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
/* USER CODE BEGIN 2 */
// Initialize LEDs
//char* msg = "MCU Init"; HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);
//HAL_UART_Transmit(&huart1, (uint8_t *)msg, 8, HAL_MAX_DELAY); HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); HAL_Delay(500);
char spi_buff[64];
HAL_SPI_Transmit(&hspi1, 0x00,1, HAL_MAX_DELAY);
HAL_SPI_Receive(&hspi1, (uint8_t*)&spi_buff,1, HAL_MAX_DELAY);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET);
HAL_Delay(500);
//char* msg = "MCU Init";
//HAL_UART_Transmit(&huart1, (uint8_t *)msg, 8, HAL_MAX_DELAY);
//HAL_Delay(2000);
//camera->Capture();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */ ButCube_imager *transmitter = new ButCube_imager();
Image_capture(); transmitter->Add_output(huart1);
// Blue off, Red on transmitter->Camera_power(true);
//HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_RESET);
//HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_SET);
//HAL_Delay(5000);
// Blue on, Red off
//HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);
// Wait for power rail to stabilize
HAL_Delay(1000);
OV2640 *camera = new OV2640(hi2c1, 0x60, hspi1, SPI_camera::Chip_select_pin{ GPIOB, GPIO_PIN_0 });
//transmitter->Transmit(camera->Image_data()); /* USER CODE END 2 */
//HAL_Delay(500); /* Infinite loop */
} /* USER CODE BEGIN WHILE */
/* USER CODE END 3 */ while (1) {
} /* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
Image_capture(camera, transmitter);
}
/* USER CODE END 3 */
} // main
/** /**
* @brief System Clock Configuration * @brief System Clock Configuration
* @retval None * @retval None
*/ */
void SystemClock_Config(void) void SystemClock_Config(void){
{ RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
RCC_OscInitTypeDef RCC_OscInitStruct = {0}; RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Configure the main internal regulator output voltage
/** Configure the main internal regulator output voltage */
*/ if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK) {
if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK) Error_Handler();
{ }
Error_Handler();
} /** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
/** Initializes the RCC Oscillators according to the specified parameters */
* in the RCC_OscInitTypeDef structure. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
*/ RCC_OscInitStruct.MSIState = RCC_MSI_ON;
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI; RCC_OscInitStruct.MSICalibrationValue = 0;
RCC_OscInitStruct.MSIState = RCC_MSI_ON; RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
RCC_OscInitStruct.MSICalibrationValue = 0; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6; RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_MSI;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; RCC_OscInitStruct.PLL.PLLM = 1;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_MSI; RCC_OscInitStruct.PLL.PLLN = 40;
RCC_OscInitStruct.PLL.PLLM = 1; RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
RCC_OscInitStruct.PLL.PLLN = 40; RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7; RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2; Error_Handler();
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) }
{
Error_Handler(); /** Initializes the CPU, AHB and APB buses clocks
} */
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
/** Initializes the CPU, AHB and APB buses clocks | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
*/ RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2; RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) {
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; Error_Handler();
}
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) } // SystemClock_Config
{
Error_Handler();
}
}
/** /**
* @brief I2C1 Initialization Function * @brief I2C1 Initialization Function
* @param None * @param None
* @retval None * @retval None
*/ */
static void MX_I2C1_Init(void) static void MX_I2C1_Init(void){
{ /* USER CODE BEGIN I2C1_Init 0 */
/* USER CODE BEGIN I2C1_Init 0 */ /* USER CODE END I2C1_Init 0 */
/* USER CODE END I2C1_Init 0 */ /* USER CODE BEGIN I2C1_Init 1 */
/* USER CODE BEGIN I2C1_Init 1 */ /* USER CODE END I2C1_Init 1 */
hi2c1.Instance = I2C1;
/* USER CODE END I2C1_Init 1 */ hi2c1.Init.Timing = 0x10909CEC;
hi2c1.Instance = I2C1; hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.Timing = 0x10909CEC; hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.OwnAddress1 = 0; hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
hi2c1.Init.OwnAddress2 = 0; hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK; hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; if (HAL_I2C_Init(&hi2c1) != HAL_OK) {
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; Error_Handler();
if (HAL_I2C_Init(&hi2c1) != HAL_OK) }
{
Error_Handler(); /** Configure Analogue filter
} */
if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK) {
/** Configure Analogue filter Error_Handler();
*/ }
if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
{ /** Configure Digital filter
Error_Handler(); */
} if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK) {
Error_Handler();
/** Configure Digital filter }
*/ /* USER CODE BEGIN I2C1_Init 2 */
if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
{ /* USER CODE END I2C1_Init 2 */
Error_Handler(); } // MX_I2C1_Init
}
/* USER CODE BEGIN I2C1_Init 2 */
/* USER CODE END I2C1_Init 2 */
}
/** /**
* @brief SPI1 Initialization Function * @brief SPI1 Initialization Function
* @param None * @param None
* @retval None * @retval None
*/ */
static void MX_SPI1_Init(void) static void MX_SPI1_Init(void){
{ /* USER CODE BEGIN SPI1_Init 0 */
/* USER CODE BEGIN SPI1_Init 0 */ /* USER CODE END SPI1_Init 0 */
/* USER CODE END SPI1_Init 0 */ /* USER CODE BEGIN SPI1_Init 1 */
/* USER CODE BEGIN SPI1_Init 1 */ /* USER CODE END SPI1_Init 1 */
/* SPI1 parameter configuration*/
/* USER CODE END SPI1_Init 1 */ hspi1.Instance = SPI1;
/* SPI1 parameter configuration*/ hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Instance = SPI1; hspi1.Init.Direction = SPI_DIRECTION_2LINES;
hspi1.Init.Mode = SPI_MODE_MASTER; hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.Direction = SPI_DIRECTION_2LINES; hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
hspi1.Init.DataSize = SPI_DATASIZE_8BIT; hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW; hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE; hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
hspi1.Init.NSS = SPI_NSS_SOFT; hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB; hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi1.Init.TIMode = SPI_TIMODE_DISABLE; hspi1.Init.CRCPolynomial = 7;
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
hspi1.Init.CRCPolynomial = 7; hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE; if (HAL_SPI_Init(&hspi1) != HAL_OK) {
hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE; Error_Handler();
if (HAL_SPI_Init(&hspi1) != HAL_OK) }
{ /* USER CODE BEGIN SPI1_Init 2 */
Error_Handler();
} /* USER CODE END SPI1_Init 2 */
/* USER CODE BEGIN SPI1_Init 2 */
/* USER CODE END SPI1_Init 2 */
} }
/** /**
@ -318,53 +270,46 @@ static void MX_SPI1_Init(void)
* @param None * @param None
* @retval None * @retval None
*/ */
static void MX_USART1_UART_Init(void) static void MX_USART1_UART_Init(void){
{ /* USER CODE BEGIN USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */
/* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */
/* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
/* USER CODE END USART1_Init 1 */ huart1.Init.BaudRate = 115200;
huart1.Instance = USART1; huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.BaudRate = 115200; huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.OverSampling = UART_OVERSAMPLING_16;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16; huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; if (HAL_UART_Init(&huart1) != HAL_OK) {
huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; Error_Handler();
if (HAL_UART_Init(&huart1) != HAL_OK) }
{ /* USER CODE BEGIN USART1_Init 2 */
Error_Handler();
} /* USER CODE END USART1_Init 2 */
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
} }
/** /**
* Enable DMA controller clock * Enable DMA controller clock
*/ */
static void MX_DMA_Init(void) static void MX_DMA_Init(void){
{ /* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE(); /* DMA interrupt init */
/* DMA1_Channel2_IRQn interrupt configuration */
/* DMA interrupt init */ HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 0, 0);
/* DMA1_Channel2_IRQn interrupt configuration */ HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 0, 0); /* DMA1_Channel3_IRQn interrupt configuration */
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn); HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 0, 0);
/* DMA1_Channel3_IRQn interrupt configuration */ HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
} }
/** /**
@ -372,63 +317,61 @@ static void MX_DMA_Init(void)
* @param None * @param None
* @retval None * @retval None
*/ */
static void MX_GPIO_Init(void) static void MX_GPIO_Init(void){
{ GPIO_InitTypeDef GPIO_InitStruct = { 0 };
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
/* GPIO Ports Clock Enable */ __HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
/*Configure GPIO pin Output Level */
/*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_15, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_15, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
/*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOA, CAMERA_EN_Pin | LED2_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, CAMERA_EN_Pin|LED2_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
/*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOB, CAMERA_CS_Pin | LED1_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, CAMERA_CS_Pin|LED1_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
/*Configure GPIO pin Output Level */ HAL_GPIO_WritePin(GPIOH, GPIO_PIN_3, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOH, GPIO_PIN_3, GPIO_PIN_SET);
/*Configure GPIO pins : PA0 PA1 PA2 PA15 */
/*Configure GPIO pins : PA0 PA1 PA2 PA15 */ GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_15;
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : CAMERA_EN_Pin LED2_Pin */
/*Configure GPIO pins : CAMERA_EN_Pin LED2_Pin */ GPIO_InitStruct.Pin = CAMERA_EN_Pin | LED2_Pin;
GPIO_InitStruct.Pin = CAMERA_EN_Pin|LED2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pin : CAMERA_CS_Pin */
/*Configure GPIO pin : CAMERA_CS_Pin */ GPIO_InitStruct.Pin = CAMERA_CS_Pin;
GPIO_InitStruct.Pin = CAMERA_CS_Pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(CAMERA_CS_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_Init(CAMERA_CS_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : LED1_Pin */
/*Configure GPIO pin : LED1_Pin */ GPIO_InitStruct.Pin = LED1_Pin;
GPIO_InitStruct.Pin = LED1_Pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(LED1_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_Init(LED1_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : PH3 */
/*Configure GPIO pin : PH3 */ GPIO_InitStruct.Pin = GPIO_PIN_3;
GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
HAL_GPIO_Init(GPIOH, &GPIO_InitStruct); } // MX_GPIO_Init
}
/* USER CODE BEGIN 4 */ /* USER CODE BEGIN 4 */
@ -438,18 +381,16 @@ static void MX_GPIO_Init(void)
* @brief This function is executed in case of error occurrence. * @brief This function is executed in case of error occurrence.
* @retval None * @retval None
*/ */
void Error_Handler(void) void Error_Handler(void){
{ /* USER CODE BEGIN Error_Handler_Debug */
/* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return state */
/* User can add his own implementation to report the HAL error return state */ __disable_irq();
__disable_irq(); while (1) { }
while (1) /* USER CODE END Error_Handler_Debug */
{
}
/* USER CODE END Error_Handler_Debug */
} }
#ifdef USE_FULL_ASSERT #ifdef USE_FULL_ASSERT
/** /**
* @brief Reports the name of the source file and the source line number * @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred. * where the assert_param error has occurred.
@ -457,11 +398,12 @@ void Error_Handler(void)
* @param line: assert_param error line source number * @param line: assert_param error line source number
* @retval None * @retval None
*/ */
void assert_failed(uint8_t *file, uint32_t line) void assert_failed(uint8_t *file, uint32_t line){
{ /* USER CODE BEGIN 6 */
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number, /* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */ /* USER CODE END 6 */
} }
#endif /* USE_FULL_ASSERT */ #endif /* USE_FULL_ASSERT */

Write Preview
Loading…
Cancel
Save