i am trying to convert raw grayscale data into jpec format

[Shreyashsatone]

Hello i am working on alif semiconductor with OV5647 camera to capture image and i am trying to use your encoder to convert raw grayscale data into jpec but it stuck in given below function.

static void jpec_enc_open(jpec_enc_t *e) {
assert(e);
jpec_huff_skel_init(e->hskel);
printf("huff_skel=%d\n",e->hskel);
jpec_enc_init_dqt(e);
printf("enc_init=%d\n",e);
jpec_enc_write_soi(e);
printf("jpec_enc_write_soi=%d\n",e);
jpec_enc_write_app0(e);
printf("enc_write=%d\n",e);
jpec_enc_write_dqt(e);
printf("enc_write=%d\n",e);
jpec_enc_write_sof0(e);
printf("jpec_enc_write_sof0=%d\n",e);
jpec_enc_write_dht(e);
printf("jpec_enc_write_dht=%d\n",e);
jpec_enc_write_sos(e);
printf("jpec_enc_write_sos=%d\n",e);
}

its not going into jpec_enc_write_sos(e); in this function, what is exactly issue and i tried multiple time to solve this problem but i failed to solve this issue. kindly help to solve this issue .

configuration of camera
// Select camera OV5647 frequency
// Defines camera OV5647 frequency
// Default: 158000000
#define RTE_OV5647_CAMERA_SENSOR_CSI_FREQ 158000000

// select OV5647 CSI2 Data type
// defines select CSI2 Data type
// default: 0x2B (RAW10)
#define RTE_OV5647_CAMERA_SENSOR_CSI_DATA_TYPE 0x2B

// select OV5647 number of lanes in DPHY
// defines select OV5647 number of lanes in DPHY.
// default: 2 one lane
#define RTE_OV5647_CAMERA_SENSOR_CSI_N_LANES 2

// select OV5647 virtual channel ID
// defines select OV5647 virtual channel ID.
// default: 0
#define RTE_OV5647_CAMERA_SENSOR_CSI_VC_ID 0

// select OV5647 override CPI color mode
// defines select OV5647 override CPI color mode.
// default: 1
#define RTE_OV5647_CAMERA_SENSOR_OVERRIDE_CPI_COLOR_MODE 1

// select OV5647 CPI color mode
// defines select OV5647 CPI color mode.
// default: 2 (IPI-16 RAW 8)
#define RTE_OV5647_CAMERA_SENSOR_CPI_COLOR_MODE 2

// select OV5647 frame height
// defines select OV5647 frame height.
// default: 480
#define RTE_OV5647_CAMERA_SENSOR_FRAME_HEIGHT 480

// select OV5647 frame width
// defines select OV5647 frame width.
// default: 640
#define RTE_OV5647_CAMERA_SENSOR_FRAME_WIDTH 640

Thank you

[Shreyashsatone]

In my code i am not using openCV i am capturing image using OV5647 then i am trying to covert raw into jpec using your encoder. i have provided given below code.

`#include <time.h>

#include "RTE_Components.h"
#include CMSIS_device_header

// DAVE
#include "aipl_dave2d.h"
#include "dave_cfg.h"
#include "dave_d0lib.h"

// Alif Image Processing Library
#include "aipl_color_correction.h"
#include "aipl_crop.h"
#include "aipl_image.h"
#include "aipl_lut_transform.h"
#include "aipl_resize.h"
#include "aipl_rotate.h"
#include "board.h"
#include "camera.h"
#include "disp.h"
#include "image.h"
#include "power.h"
// #include "power_management.h"
#include "se_services_port.h"
#include "alif_logo.h"
#include "ff.h" // FatFs headers
#include "string.h"
#include "pinconf.h"
#include "diskio.h"
#include"jpec.h"

#define K (1024)

/* Tasks Pool size, stack size, and pointers /
#define STACK_POOL_SIZE (40K)
#define SD_STACK_SIZE (10*K)
#define SD_BLK_SIZE 512
#define NUM_BLK_TEST 1
#define SD_TEST_ITTR_CNT 10

void clock_init(void); // Enables needed SoC clocks
extern void clk_init(); // time.h clock functionality (from retarget.c)
void generate_filename(char buffer, size_t buffer_size, int image_index);
void SD_Baremetal_fatfs_test(unsigned long int args);
uint32_t error_code = SERVICES_REQ_SUCCESS;
// DAVE heap
#define D1_HEAP_SIZE 0x00230000
unsigned char media_memory[SD_BLK_SIZENUM_BLK_TEST] attribute((section("sd_dma_buf"))) attribute((aligned(512)));
unsigned char filebuffer[SD_BLK_SIZE*NUM_BLK_TEST] attribute((section("sd_dma_buf"))) attribute((aligned(512)));
FATFS sd_card attribute((section("sd_dma_buf"))) attribute((aligned(512)));
static uint8_t d0_heap[D1_HEAP_SIZE]attribute((section(".bss.video_mem_heap")));
attribute((section(".sram0_bss"))) uint8_t grayscale[640 * 480 * 3];
void rgb565_to_grayscale(uint8_t *rgb565, uint8_t *grayscale, int width, int height);
void rgb565_to_rgb888(uint16_t *rgb565, uint8_t *rgb888, int width, int height);
// Check if UART trace is disabled
#if !defined(DISABLE_UART_TRACE)
#include <stdio.h>

#include "uart_tracelib.h"

static void uart_callback(uint32_t event) {}
#else
#define printf(fmt, ...) (0)
#endif

// Print measurements
#define PRINT_INTERVAL_SEC (1)
#define PRINT_INTERVAL_CLOCKS (PRINT_INTERVAL_SEC * CLOCKS_PER_SEC)
extern uint32_t SystemCoreClock;

int main(void) {
BOARD_Pinmux_Init();

/* Initialize the SE services */
se_services_port_init();

/* Enable MIPI power. TODO: To be changed to aiPM call */
enable_mipi_dphy_power();
disable_mipi_dphy_isolation();
// bool pm_ok = init_power_management();

clock_init();
SD_Baremetal_fatfs_test(NULL);

#if !defined(DISABLE_UART_TRACE)
tracelib_init(NULL, uart_callback);
#endif

#if (D1_MEM_ALLOC == D1_MALLOC_D0LIB)
/-------------------------
* Initialize D/AVE D0 heap
* -----------------------/
if (!d0_initheapmanager(d0_heap, sizeof(d0_heap), d0_mm_fixed_range, NULL, 0, 0, 0, d0_ma_unified)) {
printf("\r\nError: Heap manager initialization failed\n");
}
#endif

// Initialize D/AVE2D
if (aipl_dave2d_init() != D2_OK) {
    printf("\r\nError: D/AVE2D initialization falied\n");
    __BKPT(0);
}

clk_init();  // for time.h clock()

// if (!pm_ok) {
//     printf("\r\nError: power management init failed.\r\n");
//     __BKPT(0);
// }

// Init camera
int ret = camera_init();
if (ret != ARM_DRIVER_OK) {
    __BKPT(0);
} else {
    // Camera init OK --> init display
    ret = display_init();

    if (ret != ARM_DRIVER_OK) {
        __BKPT(0);
    }
}

// Set Logo CLUT
aipl_dave2d_set_clut(get_alif_lut(), AIPL_COLOR_RGB888);

// Enable PMU cycle counter for measurements
DCB->DEMCR |= DCB_DEMCR_TRCENA_Msk;
ARM_PMU_Enable();
ARM_PMU_CNTR_Enable(PMU_CNTENSET_CCNTR_ENABLE_Msk);
FATFS fs;
FIL file;
FRESULT res;

// Mount (optional if already mounted)
res = f_mount(&fs, "0:", 0);
printf("%d%%\n",res);
if (res != FR_OK) {
printf("Mount failed: %d\n", res);
}
// Capture frames in loop
printf("\r\n Let's Start Capturing Camera Frame...\r\n");
clock_t print_ts = clock();
while (ret == ARM_DRIVER_OK) {
// Blink green LED
BOARD_LED2_Control(BOARD_LED_STATE_TOGGLE);
// Reset cycle counter
ARM_PMU_CYCCNT_Reset();

    uint32_t capture_time = ARM_PMU_Get_CCNTR();
    ret = camera_capture();
    if (ret == ARM_DRIVER_OK) {
        capture_time = ARM_PMU_Get_CCNTR() - capture_time;

        // Do Bayer conversion
        uint32_t bayer_time = ARM_PMU_Get_CCNTR();
        // The buffer for cam_image is static, so it should not be destroyed
        aipl_image_t cam_image = camera_post_capture_process();
        bayer_time = ARM_PMU_Get_CCNTR() - bayer_time;

        // Do color correction for the ARX3A0 camera
        aipl_error_t aipl_ret = AIPL_ERR_OK;

#if CAM_COLOR_CORRECTION
// See camera.c for coefficients
uint32_t cc_time = ARM_PMU_Get_CCNTR();
aipl_ret = aipl_color_correction_rgb_img(&cam_image, &cam_image, camera_get_color_correction_matrix());
if (aipl_ret != AIPL_ERR_OK) {
printf("Error: color correction aipl_ret = %s\r\n", aipl_error_str(aipl_ret));
__BKPT(0);
}

        aipl_ret = aipl_lut_transform_rgb_img(&cam_image, &cam_image, camera_get_gamma_lut());
        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: gamma correction aipl_ret = %s\r\n", aipl_error_str(aipl_ret));
            __BKPT(0);
        }
        cc_time = ARM_PMU_Get_CCNTR() - cc_time;
         // /SD CARD*/
        // SD card save block
        char filename[32];
        static int image_index = 1;  // Declare at the top of main()
        UINT bw;

        generate_filename(filename, sizeof(filename), image_index);

        FATFS fs;
        FIL file;
        FRESULT res;
       printf("hello1\n");
        
       printf("Saving image of resolution: %ux%u\n", cam_image.width, cam_image.height);
       printf("hello2\n");
    // Open file
    res = f_open(&file, filename, FA_CREATE_ALWAYS | FA_WRITE);
     printf("%s\n",res);
         if (res == FR_OK) {
        rgb565_to_grayscale(cam_image.data, grayscale, cam_image.width, cam_image.height);
        jpec_enc_t *e = jpec_enc_new(grayscale, cam_image.width, cam_image.height);
        int jpeg_len;
        const uint8_t *jpeg_data = jpec_enc_run(e, &jpeg_len);
        // rgb565_to_rgb888(cam_image.data, grayscale, cam_image.width, cam_image.height);
        size_t image_size = cam_image.width *cam_image.height ;  
        res = f_write(&file, jpeg_data, image_size, &bw);
        printf("hello3\n");
     if (res == FR_OK && bw > 0) {
      printf("Saved %s (%u bytes)\n", filename, bw);
     } else {
        printf("Write error: %d\n", res);
       }

    f_close(&file);
        image_index++;
   } else {
        printf("File open error: %d\n", res);
     }
     printf("helloend\n");

#endif

        // Measure the image processing time (crop and resize)
        uint32_t ip_time = ARM_PMU_Get_CCNTR();

        // Crop image to a square using the smaller of the camera dimensions
        const uint32_t crop_dim = cam_image.width > cam_image.height ? cam_image.height : cam_image.width;
        const uint32_t crop_border = (cam_image.width - crop_dim) / 2;
        const uint32_t crop_header = (cam_image.height - crop_dim) / 2;

        aipl_image_t crop_image;
        aipl_ret = aipl_image_create(&crop_image, crop_dim, crop_dim, crop_dim, cam_image.format);
        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: Failed allocating crop image\r\n");
            __BKPT(0);
        }

        aipl_ret = aipl_crop_img(&cam_image, &crop_image, crop_border, crop_header, cam_image.width - crop_border,
                                 cam_image.height - crop_header);
        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: crop aipl_ret = %s\r\n", aipl_error_str(aipl_ret));
            __BKPT(0);
        }

        // Resize the cropped image so that it fits to full display width
        aipl_image_t res_image;
        aipl_ret = aipl_image_create(&res_image, MY_DISP_HOR_RES, MY_DISP_HOR_RES, MY_DISP_HOR_RES, crop_image.format);
        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: Failed allocating resize temp image\r\n");
            __BKPT(0);
        }

        aipl_ret = aipl_resize_img(&crop_image, &res_image,
                                   true);  // interpolate

        aipl_image_destroy(&crop_image);

        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: resize aipl_ret = %s\r\n", aipl_error_str(aipl_ret));
            __BKPT(0);
        }

        // Draw the resized image to display
        aipl_image_t *draw_image = &res_image;

        // Rotate image 180 on AppKit (Camera connected to the connector on the other side than the display)

#ifdef BOARD_IS_ALIF_APPKIT_B1_VARIANT
aipl_image_t rot_image;
aipl_ret = aipl_image_create(&rot_image, res_image.width, res_image.width, res_image.height, res_image.format);
if (aipl_ret != AIPL_ERR_OK) {
printf("Error: Failed allocating rotate temp image\r\n");
__BKPT(0);
}

        aipl_ret = aipl_rotate_img(&res_image, &rot_image, AIPL_ROTATE_180);
        if (aipl_ret != AIPL_ERR_OK) {
            printf("Error: rotate aipl_ret = %s\r\n", aipl_error_str(aipl_ret));
            __BKPT(0);
        }
        aipl_image_destroy(&res_image);
        draw_image = &rot_image;

#endif

        ip_time = ARM_PMU_Get_CCNTR() - ip_time;

        uint32_t render_time = ARM_PMU_Get_CCNTR();
        aipl_dave2d_prepare();
        aipl_image_draw(0, 0, draw_image);
        aipl_image_draw_clut(100, 600, get_alif_logo());
        aipl_dave2d_render();
       
         
        
        // /SD CARD*/
        aipl_image_destroy(draw_image);
        render_time = ARM_PMU_Get_CCNTR() - render_time;

        if (clock() - print_ts >= PRINT_INTERVAL_CLOCKS) {
            print_ts = clock();
            printf("Frame capture took %.3fms\r\n", capture_time * 1000.0f / SystemCoreClock);

#if !CAM_USE_RGB565
float bayer_time_s = (float)bayer_time / SystemCoreClock;
printf("Bayer conversion %.3fms (throughput=%.2fMpix/s)\r\n", bayer_time_s * 1000.0f,
CAM_MPIX / bayer_time_s);
#endif

#if CAM_COLOR_CORRECTION
float cc_time_s = (float)cc_time / SystemCoreClock;
printf("Color correction %.3fms (throughput=%.2fMpix/s)\r\n", cc_time_s * 1000.0f,
CAM_MPIX / cc_time_s);
#endif

            float ip_time_s = (float)ip_time / SystemCoreClock;
            printf("Image processing %.3fms (throughput=%.2fMpix/s)\r\n", ip_time_s * 1000.0f,
                                                                          CAM_MPIX / ip_time_s);

            float render_time_s = (float)render_time / SystemCoreClock;
            printf("Rendering to display %.3fms (throughput=%.2fMpix/s)\r\n", render_time_s * 1000.0f,
                                                                              CAM_MPIX / render_time_s);
        }
    } else {
        printf("\r\n Error: CAMERA Capture Frame failed.\r\n");
    }
}

// Set RED LED in error case
BOARD_LED1_Control(BOARD_LED_STATE_HIGH);

while (1) {
    __WFI();
}

}

void clock_init(void) {
uint32_t service_error_code = 0;
/* Enable Clocks */
uint32_t error_code = SERVICES_clocks_enable_clock(se_services_s_handle, CLKEN_CLK_100M, true, &service_error_code);
if (error_code || service_error_code) {
printf("SE: 100MHz clock enable error_code=%u se_error_code=%u\n", error_code, service_error_code);
return;
}

error_code = SERVICES_clocks_enable_clock(se_services_s_handle, CLKEN_HFOSC, true, &service_error_code);
if (error_code || service_error_code) {
    printf("SE: HFOSC enable error_code=%u se_error_code=%u\n", error_code, service_error_code);
    return;
}

 /* Enable SDMMC Clocks */
 error_code = SERVICES_clocks_enable_clock(se_services_s_handle, CLKEN_CLK_100M, true, &service_error_code);
 if(error_code)
 {
     printf("SE: SDMMC 100MHz clock enable = %d\n", error_code);
     return 0;
 }

 error_code = SERVICES_clocks_enable_clock(se_services_s_handle, CLKEN_USB, true, &service_error_code);
 if(error_code)
 {
     printf("SE: SDMMC 20MHz clock enable = %d\n", error_code);
     return 0;
 }

}
void generate_filename(char *buffer, size_t buffer_size, int image_index) {
snprintf(buffer, buffer_size, "image%03d.raw", image_index); // Produces: image001.raw
}
void rgb565_to_grayscale(uint8_t *rgb565, uint8_t *grayscale, int width, int height) {
for (int i = 0; i < width * height; i++) {
uint16_t pixel = (rgb565[2 * i + 1] << 8) | rgb565[2 * i + 0];

    uint8_t r = ((pixel >> 11) & 0x1F) << 3;  // 5-bit red to 8-bit
    uint8_t g = ((pixel >> 5) & 0x3F) << 2;   // 6-bit green to 8-bit
    uint8_t b = (pixel & 0x1F) << 3;          // 5-bit blue to 8-bit

    // Luminosity grayscale formula
    grayscale[i] = (uint8_t)(0.299f * r + 0.587f * g + 0.114f * b);
}

}
void rgb565_to_rgb888(uint16_t *rgb565, uint8_t *rgb888, int width, int height) {
int total_pixels = width * height;
for (int i = 0; i < total_pixels; i++) {
uint16_t pixel = rgb565[i];

    // Extract RGB components from RGB565
    uint8_t r = (pixel >> 11) & 0x1F;
    uint8_t g = (pixel >> 5) & 0x3F;
    uint8_t b = pixel & 0x1F;

    // Expand to 8-bit per channel
    rgb888[i * 3 + 0] = (r << 3) | (r >> 2); // Red
    rgb888[i * 3 + 1] = (g << 2) | (g >> 4); // Green
    rgb888[i * 3 + 2] = (b << 3) | (b >> 2); // Blue
}

}

void SD_Baremetal_fatfs_test(unsigned long int args)
{
unsigned long int actual;
unsigned long int startCnt, EndCnt;
FRESULT fr;
UINT br,bw;
FILE *fp = NULL;
printf("In SD hardware intialization\n");
#if (SDC_PINS == SDC_A)
pinconf_set(PORT_7, PIN_0, PINMUX_ALTERNATE_FUNCTION_6, PADCTRL_READ_ENABLE); //cmd
pinconf_set(PORT_7, PIN_1, PINMUX_ALTERNATE_FUNCTION_6, PADCTRL_READ_ENABLE); //clk
pinconf_set(PORT_5, PIN_0, PINMUX_ALTERNATE_FUNCTION_7, PADCTRL_READ_ENABLE); //d0
#if RTE_SDC_BUS_WIDTH == SDMMC_4_BIT_MODE
pinconf_set(PORT_5, PIN_1, PINMUX_ALTERNATE_FUNCTION_7, PADCTRL_READ_ENABLE); //d1
pinconf_set(PORT_5, PIN_2, PINMUX_ALTERNATE_FUNCTION_7, PADCTRL_READ_ENABLE); //d2
pinconf_set(PORT_5, PIN_3, PINMUX_ALTERNATE_FUNCTION_6, PADCTRL_READ_ENABLE); //d3
#endif

#elif (SDC_PINS == SDC_B)
pinconf_set(PORT_14, PIN_0, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //cmd
pinconf_set(PORT_14, PIN_1, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //clk
pinconf_set(PORT_14, PIN_2, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //rst
pinconf_set(PORT_13, PIN_0, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //d0
#if RTE_SDC_BUS_WIDTH == SDMMC_4_BIT_MODE
pinconf_set(PORT_13, PIN_1, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //d1
pinconf_set(PORT_13, PIN_2, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //d2
pinconf_set(PORT_13, PIN_3, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //d3
#endif

#elif (SDC_PINS == SDC_C)
pinconf_set(PORT_7, PIN_0, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //cmd
pinconf_set(PORT_7, PIN_1, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //clk
pinconf_set(PORT_5, PIN_0, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //d0
#if RTE_SDC_BUS_WIDTH == SDMMC_4_BIT_MODE
pinconf_set(PORT_5, PIN_1, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //d1
pinconf_set(PORT_5, PIN_2, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //d2
pinconf_set(PORT_5, PIN_3, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | PADCTRL_DRIVER_DISABLED_BUS_REPEATER); //d3
#endif
pinconf_set(PORT_9, PIN_0, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //cmd
pinconf_set(PORT_9, PIN_1, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //clk
pinconf_set(PORT_8, PIN_0, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //d0
#if RTE_SDC_BUS_WIDTH == SDMMC_4_BIT_MODE
pinconf_set(PORT_8, PIN_1, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //d1
pinconf_set(PORT_8, PIN_2, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //d2
pinconf_set(PORT_8, PIN_3, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE | PADCTRL_OUTPUT_DRIVE_STRENGTH_8MA); //d3
#endif

#elif (SDC_PINS == SDC_D)
pinconf_set(PORT_9, PIN_0, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //cmd
pinconf_set(PORT_9, PIN_1, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //clk
//pinconf_set(PORT_9, PIN_2, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //rst
pinconf_set(PORT_8, PIN_0, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //d0
#if RTE_SDC_BUS_WIDTH == SDMMC_4_BIT_MODE
pinconf_set(PORT_8, PIN_1, PINMUX_ALTERNATE_FUNCTION_4, PADCTRL_READ_ENABLE); //d1
pinconf_set(PORT_8, PIN_2, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //d2
pinconf_set(PORT_8, PIN_3, PINMUX_ALTERNATE_FUNCTION_5, PADCTRL_READ_ENABLE); //d3
#endif

#else
#error "Invalid SDMMC Pins defined...\n"

#endif

}`