Camera_driver: refactored version of camera driver

resources/FC_camera/Camera_driver/OV2640.cpp

@@ -0,0 +1,55 @@
+#include "OV2640.hpp"
+
+void OV2640::Init(){
+    Sensor_write_register((uint8_t) 0xff, 0x01);
+    Sensor_write_register((uint8_t) 0x12, 0x80);
+
+    Sensor_write_register_bulk(OV2640_JPEG_INIT);
+    Sensor_write_register_bulk(OV2640_YUV422);
+    Sensor_write_register_bulk(OV2640_JPEG);
+
+    Sensor_write_register((uint8_t) 0xff, 0x01);
+    Sensor_write_register((uint8_t) 0x15, 0x00);
+}
+
+void OV2640::Init(const vector<Register_blob_8> &regs){
+    Init();
+
+    Sensor_write_register_bulk(regs);
+
+    ArduChip_write(0x03, 0b01010000);
+}
+
+void OV2640::Capture(){
+    ArduChip_write(0x04, 0x01); // Clear FIFO
+    ArduChip_write(0x04, 0x01);
+
+    HAL_Delay(1);
+
+    ArduChip_write(0x04, 0x02); // Start capture
+
+    HAL_Delay(1);
+
+    // wait for capture done
+    while (1) {
+        uint8_t regValue        = ArduChip_read(0x41);
+        uint8_t captureDoneMask = 0x8;
+        if (regValue & captureDoneMask) break;
+    }
+
+    HAL_Delay(1);
+
+    uint32_t image_size = ArduChip_FIFO_length();
+
+    image_data.resize(image_size);
+
+    ArduChip_start_DMA_transfer(image_size);
+
+    // while(SPI_handle.State != HAL_SPI_STATE_READY){;}
+    HAL_Delay(300); // delay to ensure full dma transmission
+
+    // HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
+    ArduChip_CS_disable();
+
+    HAL_UART_Transmit(&UART_handle, image_data.data(), image_size, HAL_MAX_DELAY);
+} // OV2640::Capture

resources/FC_camera/Camera_driver/OV2640.hpp

@@ -0,0 +1,33 @@
+/**
+ * @file OV2640.hpp
+ * @author Petr Malaník (TheColonelYoung(at)gmail(dot)com)
+ * @brief
+ * @version 0.1
+ * @date 11.09.2022
+ */
+
+#pragma once
+
+#include "SPI_camera.hpp"
+#include "OV2640_regs.hpp"
+
+using namespace std;
+typedef unsigned int uint;
+
+class OV2640: protected SPI_camera
+{
+private:
+
+public:
+    using SPI_camera::SPI_camera;
+
+    void Init() override final;
+
+    void Init(const vector<Register_blob_8> &regs);
+
+    void Capture() override final;
+
+    //vector<uint8_t> Image_data(){ return image_data; };
+};
+
+

resources/FC_camera/Camera_driver/OV2640_regs.cpp

@@ -0,0 +1 @@
+#include "OV2640_regs.hpp"

resources/FC_camera/Camera_driver/SPI_camera.cpp

@@ -0,0 +1,107 @@
+#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(
+        I2C_address), SPI_handle(SPI_handle), SPI_CS(SPI_CS), UART_handle(UART_handle){ }
+
+int SPI_camera::Sensor_write_register(uint8_t address, uint8_t data){
+    return Sensor_write_register(Register_blob_8{ address, data });
+}
+
+int SPI_camera::Sensor_write_register(uint16_t address, uint8_t data){
+    return Sensor_write_register(Register_blob_16{ address, data });
+}
+
+int SPI_camera::Sensor_write_register(Register_blob_8 reg){
+    HAL_StatusTypeDef ret;
+
+    uint8_t buf[2];
+    buf[0] = reg.address;
+    buf[1] = reg.data;
+    ret    = HAL_I2C_Master_Transmit(&I2C_handle, I2C_address, buf, 2, HAL_MAX_DELAY);
+
+    if (ret == HAL_OK) return (1);
+
+    return (0);
+}
+
+int SPI_camera::Sensor_write_register(Register_blob_16 reg){
+    HAL_StatusTypeDef ret;
+    uint8_t buf[3];
+
+    buf[0] = reg.address >> 8;
+    buf[1] = reg.address & 0x00ff;
+    buf[2] = reg.data;
+    ret    = HAL_I2C_Master_Transmit(&I2C_handle, I2C_address, buf, 3, HAL_MAX_DELAY);
+
+    if (ret == HAL_OK) return (1);
+
+    return (0);
+}
+
+void SPI_camera::Sensor_write_register_bulk(vector<Register_blob_8> regs){
+    for (unsigned int i = 0; i < regs.size(); i++) {
+        Register_blob_8 &reg = regs[i];
+        if ( (reg.address == 0xff) & (reg.data == 0xff) ) {
+            break;
+        } else {
+            Sensor_write_register(regs[i]);
+        }
+    }
+}
+
+void SPI_camera::Sensor_write_register_bulk(vector<Register_blob_16> regs){ }
+
+int SPI_camera::ArduChip_write(uint8_t addr, uint8_t data){
+    HAL_StatusTypeDef ret;
+
+    uint8_t addr_write = addr | 0x80;
+
+    ArduChip_CS_enable();
+
+    ret = HAL_SPI_Transmit(&SPI_handle, (uint8_t *) &addr_write, 1, HAL_MAX_DELAY);
+    if (ret != HAL_OK) {
+        return ret;
+    }
+
+    ret = HAL_SPI_Transmit(&SPI_handle, (uint8_t *) &data, 1, HAL_MAX_DELAY);
+    if (ret != HAL_OK) {
+        return ret;
+    }
+
+    ArduChip_CS_disable();
+    return 0;
+}
+
+int SPI_camera::ArduChip_read(uint8_t address){
+    uint8_t addrMasked = address & 0x7F;
+    uint8_t empty      = 0x00;
+    uint8_t ret;
+
+    ArduChip_CS_enable();
+    HAL_SPI_TransmitReceive(&SPI_handle, &addrMasked, &ret, 1, HAL_MAX_DELAY);
+    HAL_SPI_TransmitReceive(&SPI_handle, &empty, &ret, 1, HAL_MAX_DELAY);
+    ArduChip_CS_disable();
+
+    return ret;
+}
+
+int SPI_camera::ArduChip_FIFO_length(){
+    uint32_t len1, len2, len3, len = 0;
+    len1 = ArduChip_read(0x42);
+    len2 = ArduChip_read(0x43);
+    len3 = ArduChip_read(0x44) & 0x7f;
+    len  = ((len3 << 16) | (len2 << 8) | len1) & 0x07fffff;
+    return len;
+}
+
+void SPI_camera::ArduChip_start_burst_read(){
+    uint8_t BURST_FIFO_READ = 0x3c;
+    uint8_t empty = 0x00;
+    HAL_SPI_TransmitReceive(&SPI_handle, &BURST_FIFO_READ, &empty, 1, HAL_MAX_DELAY);
+}
+
+void SPI_camera::ArduChip_start_DMA_transfer(uint size){
+    ArduChip_CS_enable();
+    ArduChip_start_burst_read();
+    HAL_SPI_Receive_DMA(&SPI_handle, image_data.data(), size);
+}

resources/FC_camera/Camera_driver/SPI_camera.hpp

@@ -0,0 +1,83 @@
+/**
+ * @file SPI_camera.hpp
+ * @author Petr Malaník (TheColonelYoung(at)gmail(dot)com)
+ * @brief
+ * @version 0.1
+ * @date 11.09.2022
+ */
+
+#pragma once
+
+#include "stm32l4xx_hal.h"
+
+#include <vector>
+#include <array>
+#include <memory>
+
+using namespace std;
+typedef unsigned int uint;
+
+class SPI_camera
+{
+public:
+    struct Chip_select_pin {
+        GPIO_TypeDef *port;
+        uint16_t      pin;
+    };
+
+    struct Register_blob_8 {
+        uint8_t address;
+        uint8_t data;
+    };
+
+    struct Register_blob_16 {
+        uint16_t address;
+        uint8_t  data;
+    };
+
+protected:
+    I2C_HandleTypeDef I2C_handle;
+    uint8_t I2C_address = 0;
+
+    SPI_HandleTypeDef SPI_handle;
+    Chip_select_pin SPI_CS;
+
+    UART_HandleTypeDef UART_handle;
+
+    vector<uint8_t> image_data;
+
+public:
+    SPI_camera(I2C_HandleTypeDef I2C_handle, uint8_t I2C_address, SPI_HandleTypeDef SPI_handle, Chip_select_pin SPI_CS, UART_HandleTypeDef UART_handle);
+
+    virtual void Init() = 0;
+
+    virtual void Capture() = 0;
+
+protected:
+
+    int Sensor_write_register(uint8_t address, uint8_t data);
+
+    int Sensor_write_register(uint16_t address, uint8_t data);
+
+    int Sensor_write_register(Register_blob_8 reg);
+
+    int Sensor_write_register(Register_blob_16 reg);
+
+    void Sensor_write_register_bulk(vector<Register_blob_16> regs);
+
+    void Sensor_write_register_bulk(vector<Register_blob_8> regs);
+
+    int ArduChip_write(uint8_t addr, uint8_t data);
+
+    int ArduChip_read(uint8_t address);
+
+    int ArduChip_FIFO_length();
+
+    void ArduChip_start_burst_read();
+
+    void ArduChip_start_DMA_transfer(uint size);
+
+    void ArduChip_CS_enable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_RESET); };
+
+    void ArduChip_CS_disable(){ HAL_GPIO_WritePin(SPI_CS.port, SPI_CS.pin, GPIO_PIN_SET); };
+};