stm32_camera.h

Go to the documentation of this file.

/************************************************************************//**
 * \file heivs/stm32_camera.h
 *
 * \brief Camera interface for stm32 processors
 * \author marc dot pignat at hevs dot ch
 *
 * Camera driver for a camera with an i2c control interface, and
 * parallel data out.
 *
 * The camera is connected to the DCMI and to an i2c bus.
 * \defgroup camera Camera
 * \ingroup onboard
 * @{
 ***************************************************************************/
#ifndef HEIVS_STM32_CAMERA_H
#define HEIVS_STM32_CAMERA_H

#ifdef __cplusplus
    extern "C" {
#endif

#include <stdint.h>
#include <stddef.h>
#include "heivs/error.h"
#include "heivs/stm32_gpio.h"
#include "heivs/bus.h"

enum camera_image_mode_e
{
    IMAGE_MODE_NORMAL   = 0,
    IMAGE_MODE_MONO     = 1,
    IMAGE_MODE_SEPIA    = 2,
    IMAGE_MODE_NEGATIVE = 3,
    IMAGE_MODE_SOLAR    = 4,
    IMAGE_MODE_SOLARUV  = 5,
};

enum camera_auto_exposure
{
    EXP_AUTO        = 1,
    EXP_FIXED       = 0,
};


enum camera_data_format_e
{
    IMAGE_FORMAT_RGB565,
};

struct camera_image_options_t
{
    uint32_t                    xres;
    uint32_t                    yres;
    uint32_t                    frame_rate;
    enum camera_data_format_e   format;

    enum camera_image_mode_e    mode;
    enum camera_auto_exposure   exposure;
};

struct camera_t;

struct camera_funcs_t
{
    /**
     * Initialize the camera (from reset or suspended)
     */
    status_e (*init)(const struct camera_t *cam);

    /**
     * Suspend the camera (to a low power state).
     * Wake up by init (COULD be long).
     */
    status_e (*suspend)(const struct camera_t *cam);

    /**
     * Start the camera for at least nr images, infinite when nr = 0
     *
     * Optional function, can be NULL if the camera is always running
     */
    status_e (*start)(const struct camera_t *cam, uint32_t nr);

    /**
     * Setup the camera with new options
     *
     * The camera must be already initialized
     */
    status_e (*setup)(const struct camera_t *cam);

    /**
     * Pause the camera (if possible).
     * Wake up by start (SHOULD be fast).
     *
     * Optional function, can be NULL
     */
    status_e (*pause)(const struct camera_t *cam);
};

/**
 * Camera structure
 */
struct camera_t
{
    const struct gpio_t                 *data_pins;
    uint32_t                            data_pins_count;
    const struct gpio_t                 *control_pins;
    uint32_t                            control_pins_count;
    uint32_t                            mco_frequency;
    struct gpio_t                       mco_pin;

    struct camera_image_options_t       *image_options;

    const struct camera_funcs_t         *funcs;
    const void                          *priv;
};

/**
 * \brief Initialize camera
 *
 * \param cam the camera
 * \return #NO_ERROR for no problem
 */
status_e camera_init(const struct camera_t *cam);

/**
 * \brief Camera setup
 * \param cam the camera
 * \param new_options the new options
 * \return #NO_ERROR for no problem
 */
status_e camera_setup(const struct camera_t *cam, const struct camera_image_options_t *new_options);

/**
 * \brief Camera take one shot
 * \param cam the camera
 * \param done_handler the handler when image is taken, can be NULL
 * \param dst where to put the data
 * \param size the size of the data
 * \return #NO_ERROR for no problem
 */
status_e camera_one_shot_start(const struct camera_t *cam, void (*done_handler)(status_e, const struct camera_t *), void *dst, size_t size);

/**
 * \brief Camera wait one shot finished
 * \param cam the camera
 * \return #NO_ERROR for no problem
 */
status_e camera_one_shot_wait(const struct camera_t *cam);

/**
 * \brief Camera wait one shot status
 * \return ::ERROR_AGAIN when not finished, #NO_ERROR for no problem
 */
status_e camera_one_shot_status(const struct camera_t *cam);

/**
 * \brief Start continuous capture of camera images
 * \param *cam the camera
 * \param *next_handler
 * \param *done_handler
 * \param size
 * \return #NO_ERROR for no problem
 */
status_e camera_continuous_start(const struct camera_t *cam, void *(*next_handler)(const struct camera_t *), void (*done_handler)(status_e status, const struct camera_t *), size_t size);

/**
 * \brief Camera stop continous capture
 * \return #NO_ERROR for no problem
 */
status_e camera_continuous_stop(const struct camera_t *cam);

/**
 * \brief Compute image byte size using current parameters
 * \return byte size of the image
 */
uint32_t camera_get_image_size(const struct camera_t *cam);

#ifdef __cplusplus
    }
#endif

/**
 * @}
 */
#endif /* HEIVS_STM32_CAMERA_H */