Raspberry PI 500 released! Arduino Nano Matter released! AI Scale... prototyped!

0:00:00 / -

Watch now on YouTube Watch now

Gopro Camera Bluetooth Remote

Made by ashokr / Communication / Photos & Video / Productivity / Retro Tech / Wearables

About the project

Making own Bluetooth remote for GoPro Hero 6/7/8

Project info

Difficulty: Moderate

Platforms: Cypress, GoPro, Infineon

Estimated time: 1 day

License: Creative Commons Attribution CC BY version 4.0 or later (CC BY 4+)

Items used in this project

Hardware components

	GoPro Hero 7	x 1
	PSoC 6 Wi-Fi BT Prototyping Kit	x 1

Software apps and online services

CySmartApp Only for Testing

Story

Introduction:

The Aim of this project is to provide easy soluiton for GoPro Camera users with capsense enabled Bluetooth remote. I used to travel lot in car. To control the camera all time my co passenger has to reach the camera or through mobile app. Voice control also there but it will drain our tongue :) . This is simple remote prototype design board , i can break the board and attach into my dash board. Its easy for me to reach the board and control my camera.

Implementation:

I took the Gopro Camera and put into paring mode. I used Cy-smart app to find out the UUID and GATT characteristic.

Found the UUID as 0xFEA6 which is 16bit UUID,

then there are many BLE GATT Services like, Battery, Device Information etc. the one we need is Custom service where we can send commands to GoPro.

The Custom Service UUID is { 0xfbu, 0x34u, 0x9bu, 0x5fu, 0x80u, 0x00u, 0x00u, 0x80u, 0x00u, 0x10u, 0x00u, 0x00u, 0xa6u, 0xfeu, 0x00u, 0x00u }

Cypress PSoC 6 Proto Kit is used in this project, Used Eclipse IDE for Modus Toolbox 2.1 is used as project development environment. Cypress Anycloud SDK 1.0.0 is used for bluetooth development.

Just create Empty project for PSoC 6 Proto Kit and add bluetooth , capsense libs into it from library manager or CLI commands using "make getlibs" ,

the deps folder contains the all dependency for the project. Initialize the BT stack, GATT DB and Capsense then Implement the GATT services as client and scan for the Gopro UUID, once the UUID matches then start discover the characteristic for custom service UUID. The stack returns with the handler value if its valid.

Next step is to write the values to the GATT attributes.

GoPro Camera Commands set:

For Video Mode: {0x03 0x02 0x01 0x00 }

For Photo Mode: {0x03 0x02 0x01 0x01 }

For Time Wrap Mode: {0x03 0x02 0x01 0x02 }

Shutter ON: {0x03 , 0x1, 0x01, 0x01}

Shutter Off: {0x03 , 0x1, 0x01, 0x00}

CapSense slider and button values are monitored and used to send the GATT commands on touch.

The final working video is here.

Schematics, diagrams and documents

Schematic

https://github.com/embeddedclub/Schematics/blob/master/CY8CPROTO-062-4343W%20Schematic.pdf

Go to download

Code

Code Snippet

/*******************************************************************************
* Copyright (2020), Cypress Semiconductor Corporation.
********************************************************************************
* This software, including source code, documentation and related materials
* (“Software”), is owned by Cypress Semiconductor Corporation or one of its
* subsidiaries (“Cypress”) and is protected by and subject to worldwide patent
* protection (United States and foreign), United States copyright laws and
* international treaty provisions. Therefore, you may use this Software only
* as provided in the license agreement accompanying the software package from
* which you obtained this Software (“EULA”).
*
* If no EULA applies, Cypress hereby grants you a personal, nonexclusive,
* non-transferable license to copy, modify, and compile the Software source
* code solely for use in connection with Cypress’s integrated circuit products.
* Any reproduction, modification, translation, compilation, or representation
* of this Software except as specified above is prohibited without the express
* written permission of Cypress.
*
* Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress
* reserves the right to make changes to the Software without notice. Cypress
* does not assume any liability arising out of the application or use of the
* Software or any product or circuit described in the Software. Cypress does
* not authorize its products for use in any products where a malfunction or
* failure of the Cypress product may reasonably be expected to result in
* significant property damage, injury or death (“High Risk Product”). By
* including Cypress’s product in a High Risk Product, the manufacturer of such
* system or application assumes all risk of such use and in doing so agrees to
* indemnify Cypress against all liability.
*******************************************************************************/


void task_ble(void* param)
{
    BaseType_t rtos_api_result = pdFALSE;
    wiced_result_t result = WICED_BT_SUCCESS;
    cy_en_em_eeprom_status_t eeprom_status;
    /* Suppress warning for unused parameter */
    (void)param;

    /* Configure platform specific settings */
    cybt_platform_config_init(&bt_platform_cfg_settings);

    /* Register call back and configuration with stack */
    result = wiced_bt_stack_init(ble_app_management_cb, &wiced_bt_cfg_settings);

	wiced_bt_create_heap ("DEFAULT", NULL, 0x1200, NULL, WICED_TRUE);

    /* Check if stack initialization was successful */
    if( CY_RSLT_SUCCESS == result)
    {
        printf("Bluetooth Stack Initialization Successful!\r\n");
    }
    else
    {
        printf("Bluetooth Stack Initialization failed!\r\n");
        CY_ASSERT(0);
    }
    /* Repeatedly running part of the task */
    for(;;)
    {
         /* Block until a command has been received over queue */
		rtos_api_result = xQueueReceive(ble_capsense_data_q, &ble_cam_data,
																portMAX_DELAY);
		/* Command has been received from queue */
		if(pdTRUE == rtos_api_result)
		{
	    	printf("Trigger :%d Cammod: %d\r\n",ble_cam_data.trigger, ble_cam_data.cammode);

	    	ble_app_gatt_writecval(ble_cam_data);

		}
    }
}


void ble_app_init( void )
{
	wiced_bt_gatt_status_t gatt_status = WICED_BT_GATT_ERROR;
	wiced_result_t result = WICED_BT_ERROR;
	wiced_bt_device_address_t  local_device_bd_addr;

	printf("Init GATT Client\r\n");

	/* Register with BT stack to receive GATT callback */
	gatt_status=wiced_bt_gatt_register(ble_app_gatt_event_cb);

	printf("GATT event handler registration status: 0x%x\r\n", gatt_status);
	/* Initialize GATT Database */
	gatt_status=wiced_bt_gatt_db_init(gatt_database, gatt_database_len, NULL);

	printf("GATT database initiliazation status: 0x%x\r\n", gatt_status);

	/* Enable pairing for this application */
	wiced_bt_set_pairable_mode(WICED_TRUE, 0);
 
	/* Start Undirected LE Advertisements on device startup.
	 * The corresponding parameters are contained in 'app_bt_cfg.c' */
	result = wiced_bt_ble_scan(BTM_BLE_SCAN_TYPE_HIGH_DUTY,WICED_TRUE,
            						ble_app_scan_result_cback);

	/* Failed to start advertisement. Stop program execution */
	if ((WICED_BT_PENDING == result) || (WICED_BT_BUSY == result))
	{
		printf("Scanning.....\r\n");
	}
	else
	{
		printf("Failed to start scanning, Error code: %d\r\n", result);
	}
}

static void ble_app_gatt_writecval(ble_capsense_data_t value)
{
	wiced_bt_gatt_value_t   *p_write = NULL;

	uint8_t data[4] = {0x3, 0x2, 0x1, 0x0};
	p_write = (wiced_bt_gatt_value_t *)wiced_bt_get_buffer(sizeof(wiced_bt_gatt_value_t) + CCCD_LENGTH);
	wiced_bt_gatt_status_t status = WICED_BT_GATT_ERROR;

	if(value.cmd==0)
    {
      data[1] = 0x2;
      data[3] =value.cammode;
	}
	else
    {
      data[1] = 0x1;
      data[3] =value.trigger;
	}

	if (p_write)
	{

		memset(p_write, 0, sizeof(wiced_bt_gatt_write_t) + CCCD_LENGTH);
		p_write->handle   =  gopro_cam_handle +2;
		p_write->len  = CCCD_LENGTH;
		p_write->auth_req= GATT_AUTH_REQ_NONE;
		p_write->value[0] = data[0];
		p_write->value[1] = data[1];
		p_write->value[2] = data[2];
		p_write->value[3] = data[3];
		p_write->offset = 0;
		printf("GATT write value:");
		for(int i=0;i<CCCD_LENGTH;i++)
		{
			printf(" 0x%x",data[i]);
		}
		printf("\r\n");
		status = wiced_bt_gatt_send_write(gopro_cam.connection_id, GATT_WRITE, p_write);
		if(WICED_BT_GATT_SUCCESS == status){

			printf("GATT Write successfull!\r\n");
		}
		else
		{
			printf("GATT Write failed! status = 0x%x \r\n",status);
		}
		wiced_bt_free_buffer(p_write);
	}
}

void task_capsense(void* param)
{
    BaseType_t rtos_api_result = pdFAIL;
    cy_status status;
    capsense_command_t capsense_cmd;

    /* Remove warning for unused parameter */
    (void)param;

    /* Initialize timer for periodic CapSense scan */
    scan_timer_handle = xTimerCreate ("Scan Timer", CAPSENSE_SCAN_INTERVAL_MS,
                                      pdTRUE, NULL, capsense_timer_callback);

    /* Setup communication between Tuner GUI and PSoC 6 MCU */
    tuner_init();

    /* Initialize CapSense block */
    status = capsense_init();
    if(CY_RET_SUCCESS != status)
    {
        CY_ASSERT(0u);
    }

    /* Start the timer */
    xTimerStart(scan_timer_handle, 0u);

    /* Repeatedly running part of the task */
    for(;;)
    {
        /* Block until a CapSense command has been received over queue */
        rtos_api_result = xQueueReceive(capsense_command_q, &capsense_cmd,
                portMAX_DELAY);

        /* Command has been received from capsense_cmd */
        if(rtos_api_result == pdTRUE)
        {
            /* Check if CapSense is busy with a previous scan */
            if(CY_CAPSENSE_NOT_BUSY == Cy_CapSense_IsBusy(&cy_capsense_context))
            {
                switch(capsense_cmd)
                {
                    case CAPSENSE_SCAN:
                    {
                        /* Start scan */
                        Cy_CapSense_ScanAllWidgets(&cy_capsense_context);
                        break;
                    }
                    case CAPSENSE_PROCESS:
                    {
                        /* Process all widgets */
                        Cy_CapSense_ProcessAllWidgets(&cy_capsense_context);
                        process_touch();

                        /* Establishes synchronized operation between the CapSense
                         * middleware and the CapSense Tuner tool.
                         */
                        Cy_CapSense_RunTuner(&cy_capsense_context);
                        break;
                    }
                    /* Invalid command */
                    default:
                    {
                        break;
                    }
                }
            }
        }
        /* Task has timed out and received no data during an interval of
         * portMAXDELAY ticks.
         */
        else
        {
            /* Handle timeout here */
        }
    }
}

Credits

ashokr

Hello! I’m Ashok. I’m currently working as software engineer. passionate about doing Hobbies Projects and Animations works.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast