Bosch Sensortec Community

    cancel
    Showing results for 
    Search instead for 
    Did you mean: 

    BMA400 accelerometer design guide

     Introduction

    This document is meant as a reference guide on how to design using Bosch Sensortec’s BMA400 accelerometer.

     Selecting the right part

    The BMA400 is the first ultra-low power accelerometer with anti-aliasing performance, so strictly speaking, currently there is no compatible sensors in Bosch SensorTec products. However, a comparison between BMA400 & BMA4xy series is helpful for user to understand BMA400’s performance better.

    Table 1 shows an overview of the features.

                                                                                     Table 1 sensor main features

    10.png

     

    Common characteristics

    The main characteristics of this product family are:

      Key features

    • LGA package (12 pins), 2mm x 2mm x 0.95mm
    • Ultra-low power consumption:      3.5uA @800Hz to 14uA@800Hz (configurable in normal mode)
    • 0.8uA @25Hz to 1.2uA @25Hz (configurable in low power mode)
    • Anti-aliasing: consecutive sampling in normal mode (not duty-cycling)
    • Configurable Acceleration ranges ±2g/±4g/±8g/±16g
    • Configurable output data rate: 12.5Hz to 800Hz (normal mode)
    • 1 KB FIFO
    • Auto-low power/Auto wakeup
    • Activity/In-activity
    • Step Counter (overall device current consumption 4µA)
    • Activity Recognition (Walking, Running, Standing still)
    • Orientation detection
    • Tap/double tap  
    • Free-fall detection
    • Wearables, position

    Differences between products

    BMA400 is the only one product with ultra-low power feature from Bosch Sensor tech. The key parameters are listed in Table 2.

                                                                        Table 2 Key parameters of BMA400

    2.png

    Available evaluation tools and software

    To best to evaluate the products from the BMA400 family is the following combination of evaluation tools:

    • COINES Desktop software,

    BST_download_page -> ‘Software’ Tap -> ‘Communication with Inertial and Environmental Sensors (COINES)’

    • Application board 2.0

    https://ae-bst.resource.bosch.com/media/_tech/media/shuttleboard_flyer/Applicationboard-2-0_Flyer.pd...

    Reference design

    See Figure 1 for a complete schematic of a typical use-case.

    3.png

    Note:

    1. SPI is highly recommended because of the low current consumption. Since if I2C interface is applied, the pull-up resistors will consume significantly high current comparing to BMA400 ultra-low power consumption.
    2. The VDDIO of MCU and BMA400 should be connected to same power source (level).
    3. GPIO1 & GPIO2 of MCU should be configured as input if connected to INT1/INT2 of BMA400.
    4. In case I2C interface is used (even not recommended), connect CSB to VDDIO to prevent unwanted level jumps on CSB pin, which might bring BMA400 from I2C mode to SPI mode, especially during ESD test.

    Table 3 shows the bill of materials.

                                                                  Table 3 BMA400 relevant Bill of materials

    4.png

     Layout recommendations

    Because the BMA400 sensor family contains tiny mechanical structure inside the package, care must be taken during the layout phase to ensure the best performance. The complete handling and soldering guide can be found on the Bosch Sensortec’s website.

    BST_BMA400 -> ‘downloads’ -> ‘Handling & Soldering instructions’

    In addition to the attached guidelines, see below for the typical integration & manufacturing procedure for the BMA400 accelerometer.

      
    Landing Pattern

    5.png                                                                Figure 2 Landing pattern

        
    Typical Layout

    6.png

    Figure 3 Typical layout

    Note:

    1. No via under sensor.
    2. On top layer, where sensor is mounted, no copper under sensor; while on the 2nd layer (bottom layer of 2-layers PCB), ground copper is welcomed to prevent EMI interference.
    3. Traces should be fanned out to the outside of sensor, not inside.
    4. In the area of sensor, no trace should be on the 2nd layer (bottom layer of 2-layers PCB); When there is ground copper on the 2nd layer, traces can be on 3rd( and 4th/5th …) layers; But keep high frequency or high current signals away from sensor area, from top to bottom.

    Manufacturing notes

    7.png

                                                                                 Table 4 Manufacturing parameters

    First power-on

    After powering the sensor for the first time, the initial specs would be to test for communication with the device. This can be done simply by reading the chip identification code in the register 0x00. See below for the expected values:

    8.png

                                                                      Table 5 Chip ID of the BMA400 product

    To properly initialize the device, the user must decide which interface to use (I2C or SPI) during hardware design.

    After power up, BMA400 is by default in I2C mode, until detect a rising edge on CSB pin, then BMA400 will switch to SPI mode until next soft rest or power on reset. Therefore, once BMA400 is connected to SPI interface from host, firstly a rising edge on CSB pin should be triggered, which can be implemented, for example, by a read from CHIPID register. For I2C connect, pulling the CSB pin to VDDIO directly or through a resistor will prevent BMA400 switches to SPI mode during running or ESD.

    For SPI read, the first byte got from BMA400 is always a dummy byte, which should be skipped. The valuable information start from the second byte.

    Here is some sample code on how to perform a CHIPID reading, using the COINES software (check Chapter 2.3 for detailed information) as the host.

    * @brief This internal API is used to initializes the bma400 sensor with default
     * settings like power mode and OSRS settings
     *
     * @param[in] void
     *
     * @return void
     *
     */
    static void init_bma400(void)
    {
        int8_t rslt;
        rslt = bma400_init(&bma400dev);
        if (rslt == BMA400_OK)
        {
            printf("BMA400 Initialization Success!\n");
            printf("Chip ID 0x%x\n", bma400dev.chip_id);
        }
        else
        {
            print_rslt(rslt);        
            exit(COINES_E_FAILURE);
        }
        coines_delay_msec(100);   
    }
    /********************** Global function definitions ************************/
    /*!
     *  @brief This API is the entry point, Call this API before using other APIs.
     *  This API reads the chip-id of the sensor which is the first step to
     *  verify the sensor and updates the trim parameters of the sensor.
     */
    int8_t bma400_init(struct bma400_dev *dev)
    {
        int8_t rslt;
        uint8_t chip_id = 0;
    
        /* Check for null pointer in the device structure*/
        rslt = null_ptr_check(dev);
        /* Proceed if null check is fine */
        if (rslt == BMA400_OK) {
            /* Initial power-up time */
            dev->delay_ms(5);
            /* Assigning dummy byte value */
            if (dev->intf == BMA400_SPI_INTF) {
                /* Dummy Byte availability */
                dev->dummy_byte = 1;
                /* Dummy read of Chip-ID in SPI mode */
                rslt = bma400_get_regs(BMA400_CHIP_ID_ADDR, &chip_id, 1, dev);
            } else {
                dev->dummy_byte = 0;
            }
            if (rslt == BMA400_OK) {
                /* Chip ID of the sensor is read */
                rslt = bma400_get_regs(BMA400_CHIP_ID_ADDR, &chip_id, 1, dev);
                /* Proceed if everything is fine until now */
                if (rslt == BMA400_OK) {
                    /* Check for chip id validity */
                    if (chip_id == BMA400_CHIP_ID) {
                        /* Store the chip ID in dev structure */
                        dev->chip_id = chip_id;
                    } else {
                        rslt = BMA400_E_DEV_NOT_FOUND;
                    }
                }
            }
        }
        return rslt;
    }

    How to test the sensor’s functionality

    The BMA400 accelerometer features a fully integrated and motionless self-test procedure on the ASIC itself. When the self-test is triggered, the accelerometer uses electric fields to physically move the electrodes in all directions, senses the deflection and compares it with the expected output.

    Therefore, the built-in self-test features is the recommended way to test the sensor’s functionality.

    Here are some sample codes on how to perform this self-test, based on BMA400, using the COINES software as the host.

    Codes from COINS(caller):

    /*!
     *  @brief This internal API is used to perform the self test
     *
     *  @param[in] bma400dev: device structure
     *
     *  @return void
     *
     */
    static void perform_self_test(struct bma400_dev *bma400dev)
    {
        int8_t rslt;
        /* Doing soft reset */
        rslt = bma400_soft_reset(bma400dev);
        print_rslt(rslt);
        printf("Running self test...\r\n");
        coines_delay_msec(500);
    
        rslt = bma400_perform_self_test(bma400dev);
        print_rslt(rslt);
    
        if (rslt == BMA400_OK) {
            printf("Self test passed!\r\n");
        }
        fflush(stdout);
    }

     Codes from BMA400 API:

    /*!
     * @brief This is used to perform self test of accelerometer in BMA400
     */
    int8_t bma400_perform_self_test(const struct bma400_dev *dev)
    {
        int8_t rslt;
        int8_t self_test_rslt = 0;
        struct bma400_sensor_data accel_pos, accel_neg;
    
        /* Check for null pointer in the device structure */
        rslt = null_ptr_check(dev);
        /* Proceed if null check is fine */
        if (rslt == BMA400_OK) {
            /* pre-requisites for self test*/
            rslt = enable_self_test(dev);
            if (rslt == BMA400_OK) {
                rslt = positive_excited_accel(&accel_pos, dev);
                if (rslt == BMA400_OK) {
                    rslt = negative_excited_accel(&accel_neg, dev);
                    if (rslt == BMA400_OK) {
                        /* Validate the self test result */
                        rslt = validate_accel_self_test(&accel_pos, &accel_neg);
                    }
                }
            }
        }
        /* Check to ensure bus error does not occur */
        if (rslt >= BMA400_OK) {
            /* Store the status of self test result */
            self_test_rslt = rslt;
            /* Perform soft reset */
            rslt = bma400_soft_reset(dev);
        }
        /* Check to ensure bus operations are success */
        if (rslt == BMA400_OK) {
            /* Restore self_test_rslt as return value */
            rslt = self_test_rslt;
        }
        return rslt;
    }

    How to test the sensor’s performance

    There are two performance parameters that can easily be tested with the device motionless: offset and noise. See below for the typical values of the sensors.

    Note: Typical values are defined as ±1σ, which means that we expect 68.3% of sensors to fall within these values. Min/Max values are defined as ±3σ, which means 99.7% of sensors shall be within these values.

    9.png

    For the offset, the test procedure is quite simple. With the device in a known position, such as a flat surface, calculate the average value for each axis, and subtract the expected output (e.g. 0G, 0G, +1G) from the data. The result is the offset of the sensor. Here is some sample code on how to perform this test, based on BMA400, using the COINES software as the host.

    Missed BMA400 offset calculation examples:

    /*!
     * @brief   This internal API is used to measure the sensor offset
     *
     * @param[out] x_off_mg, y_off_mg, z_off_mg
     *
     * @return void
     *
     */
    static void bma423_get_offset(double *x_off_mg, double *y_off_mg, double *z_off_mg) {
        uint16_t commrslt;
        /* Declare an accelerometer configuration structure */
        struct bma4_accel_config accel_conf;
        /* Declare a data buffer for the sensor data structure */
        struct bma4_accel sens_data[20];
        
        /* Enable the accelerometer */

    The noise calculation is a bit more complicated. First, subtract the offset from each data point. The RMS value can be calculated as the square root of the arithmetic mean of the squares of the noise values.

    Since the noise value is affected by the bandwidth of the digital filter, we need to convert it back to noise density with the following formula. Note: this applied only to a second order filter.

    Here is some sample code on how to perform this test, based on BMI160, using the COINES software as the host.

    Calibrating the sensor

    The first question to ask concerning calibration is whether it is required for the intended application. Accelerometer calibration mainly consists of calibrating the accelerometer’s offset. The main impact for this is in tilt-sensing application, where the offset will induce an error in the measurement of the horizon.

    The accelerometer comes from the factory pre-trimmed, but the soldering process and PCB bending due to assembly can vary the offset, therefore it is preferable to calibrate the accelerometer after assembling the device into the device housing. Therefore, it is recommended to calibrate the sensor after assembling the device into the device housing.

    The acceleration sensor offset consists of two parts: the static “unwanted” offset mainly due to soldering drift, and the offset generated when an acceleration is applied to the sensor. The latter depends on the applied acceleration and its magnitude if defined by the sensor’s sensitivity. However, the sensitivity has a certain tolerance (typ. <1%). This means that in order to compensate for the static offset, the sensor must be oriented in such a way that no external acceleration is applied to the sensing axis. As gravity also causes a sensor signal, the sensing axis must be oriented perpendicular to the gravity field.

    The compensation process described below focuses on the x/y-axis. The z-axis can also be compensated in the same way, but the user has to consider the applied gravity. Alternatively, the process can be repeated after turning the device, with the z-axis perpendicular to the gravity vector.

    1. Place your sensor (the system with the sensor inside) on a well-defined surface, for example, a horizontal table. The expected sensor output for the x/y-axis should be 0 mg.
    2. Set the sensor to the lowest g-range (2G)
    3. Measure the sensor output to ensure the sensor is fully at rest, without vibrations, inclinations, big temperature changes or strong VDD fluctuations. It is advisable to take several values and generate the average over the values (e.g. 1000 values).
    4. Consider the resolution of BMA400, and save the offset in LSB or mg.
    5. The offset subtracted from the future accelerometer sensor data.

     Usage

    The COINES installation provides sample code on how to turn on the sensor, configure it and read out the acceleration data.

      Sample code

    The main function shows the initialization process of BMA400 based on COINS software & APP2.0 board.

    /*!
     *  @brief Main Function where the execution getting started to test the code.
     *
     *  @param[in] argc
     *  @param[in] argv
     *
     *  @return status
     *
     */
    int main(int argc, char const *argv[])
    {
        struct coines_board_info board_info;
        struct bma400_sensor_data data;
        struct bma400_dev bma;
        int8_t rslt;
        uint8_t n_samples = 200;
        float t, x, y, z;
        init_bma400_sensor_driver_interface(&bma);
    
        rslt = coines_open_comm_intf(COINES_COMM_INTF_USB);
        if (rslt < 0)
        {
            printf("\n Unable to connect with Application Board ! \n"
                   " 1. Check if the board is connected and powered on. \n"
                   " 2. Check if Application Board USB driver is installed. \n"
                   " 3. Check if board is in use by another application. (Insufficient permissions to access USB) \n");
            exit(rslt);
        }
    
        
        /* Check if the right board is connected (implicitly check if board was reset) */
        rslt = coines_get_board_info(&board_info);
        if (rslt == COINES_SUCCESS)
        {
            if(board_info.shuttle_id != BMA400_SHUTTLE_ID)
            {
                printf("Invalid sensor shuttle ID (not a BMA400 shuttle)\n(sometimes board power off-power on helps.)\n");
                fflush(stdout);
                exit(COINES_E_FAILURE);
            }
        }
        
        init_sensor_interface();
        
        /* after sensor init introduce 200 msec sleep */
        coines_delay_msec(200);
    
        init_bma400(&bma);
    
        rslt = bma400_soft_reset(&bma);
        print_rslt(rslt);
    
        rslt = set_sensor_config(&bma);
        if(rslt != BMA400_OK)
        {
            printf("Error setting bma400 config.\n");
            fflush(stdout);
            exit(rslt);
        }   
    
        while (n_samples && (rslt == BMA400_OK)) {
            bma.delay_ms(10); /* Wait for 10ms as ODR is set to 100Hz */
    
            rslt = bma400_get_accel_data(BMA400_DATA_SENSOR_TIME, &data, &bma);
            print_rslt(rslt);
    
            /* 12-bit accelerometer at range 2G */
            x = lsb_to_ms2(data.x, 2, 12);
            y = lsb_to_ms2(data.y, 2, 12);
            z = lsb_to_ms2(data.z, 2, 12);
            t = sensor_ticks_to_s(data.sensortime);
    
            printf("t[s]:%.4f\tdata[m/s2]: ax:%.4f\tay:%.4f\taz:%.4f\n", t, x, y, z);
            fflush(stdout);
    
            n_samples--;
        }
    
        return 0;
    }

    Below function described how to coinfigure the BMA400:

    /*!
     *  @brief This internal API is used to configure the sensor 
     *
     *  @param[in] bma400dev: bma400 device structure
     *
     *  @return Results of API execution status.
     *  @retval 0 -> Success
     *  @retval Any non zero value -> Fail
     *
     */
    static int8_t set_sensor_config(struct bma400_dev *bma400dev)
    {
        int8_t rslt;
        struct bma400_sensor_conf conf;
    
    
        /* Select the type of configuration to be modified */
        conf.type = BMA400_ACCEL;
    
        /* Get the accelerometer configurations which are set in the sensor */
        rslt = bma400_get_sensor_conf(&conf, 1, bma400dev);
        print_rslt(rslt);
    
        /* Modify the desired configurations as per macros
         * available in bma400_defs.h file */
        conf.param.accel.odr = BMA400_ODR_100HZ;
        conf.param.accel.range = BMA400_2G_RANGE;
        conf.param.accel.data_src=BMA400_DATA_SRC_ACCEL_FILT_1;
    
        /* Set the desired configurations to the sensor */
        rslt = bma400_set_sensor_conf(&conf, 1, bma400dev);
        print_rslt(rslt);
    
        rslt = bma400_set_power_mode(BMA400_LOW_POWER_MODE, bma400dev);
        print_rslt(rslt);
    
        return rslt;
    }

    Below codes come from BMA400 API, which describe how to read and set BMA400 sensor configuration, and how to read sensor data.

    /*!
     * @brief This API is used to get the accel data along with the sensor-time
     */
    int8_t bma400_get_accel_data(uint8_t data_sel, struct bma400_sensor_data *accel, const struct bma400_dev *dev)
    {
        int8_t rslt;
    
        /* Check for null pointer in the device structure*/
        rslt = null_ptr_check(dev);
        /* Proceed if null check is fine */
        if ((rslt == BMA400_OK) || (accel != NULL)) {
            /* Read and store the accel data */
            rslt = get_accel_data(data_sel, accel, dev);
        } else {
            rslt = BMA400_E_NULL_PTR;
        }
        return rslt;
    }
    /*!
     * @brief This API is used to set the sensor settings like sensor
     * configurations and interrupt configurations
     */
    int8_t bma400_set_sensor_conf(const struct bma400_sensor_conf *conf, uint16_t n_sett, const struct bma400_dev *dev)
    {
        int8_t rslt;
        uint16_t idx = 0;
        uint8_t data_array[3] = { 0 };
    
        /* Check for null pointer in the device structure*/
        rslt = null_ptr_check(dev);
        /* Proceed if null check is fine */
        if (rslt == BMA400_OK) {
            /* Read the interrupt pin mapping configurations */
            rslt = bma400_get_regs(BMA400_INT_MAP_ADDR, data_array, 3, dev);
            if (rslt == BMA400_OK) {
                for (idx = 0; idx < n_sett; idx++) {
                    switch (conf[idx].type) {
                    case BMA400_ACCEL:
                        /* Setting Accel configurations */
                        rslt = set_accel_conf(&conf[idx].param.accel, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_DATA_READY_INT_MAP,
                                    conf[idx].param.accel.int_chan);
                        }
                        break;
                    case BMA400_TAP_INT:
                        /* Setting TAP configurations */
                        rslt = set_tap_conf(&conf[idx].param.tap, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_TAP_INT_MAP,
                                    conf[idx].param.tap.int_chan);
                        }
                        break;
                    case BMA400_ACTIVITY_CHANGE_INT:
                        /* Setting activity change config */
                        rslt = set_activity_change_conf(&conf[idx].param.act_ch, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_ACT_CH_INT_MAP,
                                    conf[idx].param.act_ch.int_chan);
                        }
                        break;
                    case BMA400_GEN1_INT:
                        /* Setting Generic int 1 config */
                        rslt = set_gen1_int(&conf[idx].param.gen_int, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_GEN1_INT_MAP,
                                    conf[idx].param.gen_int.int_chan);
                        }
                        break;
                    case BMA400_GEN2_INT:
                        /* Setting Generic int 2 config */
                        rslt = set_gen2_int(&conf[idx].param.gen_int, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_GEN2_INT_MAP,
                                    conf[idx].param.gen_int.int_chan);
                        }
                        break;
                    case BMA400_ORIENT_CHANGE_INT:
                        /* Setting orient int config */
                        rslt = set_orient_int(&conf[idx].param.orient, dev);
                        if (rslt == BMA400_OK) {
                            /* Int pin mapping settings */
                            map_int_pin(data_array, BMA400_ORIENT_CH_INT_MAP,
                                    conf[idx].param.orient.int_chan);
                        }
                        break;
                    case BMA400_STEP_COUNTER_INT:
                        /* Int pin mapping settings */
                        map_int_pin(data_array, BMA400_STEP_INT_MAP, conf[idx].param.step_cnt.int_chan);
                        break;
                    }
                }
                if (rslt == BMA400_OK) {
                    /* Set the interrupt pin mapping configurations */
                    rslt = bma400_set_regs(BMA400_INT_MAP_ADDR, data_array, 3, dev);
                }
            }
        }
        return rslt;
    }
    /*!
     * @brief This API is used to get the sensor settings like sensor
     * configurations and interrupt configurations and store
     * them in the corresponding structure instance
     */
    int8_t bma400_get_sensor_conf(struct bma400_sensor_conf *conf, uint16_t n_sett, const struct bma400_dev *dev)
    {
        int8_t rslt = BMA400_OK;
        uint16_t idx = 0;
        uint8_t data_array[3] = { 0 };
    
        if (conf == NULL) {
            rslt = BMA400_E_NULL_PTR;
        }
    
        if (rslt == BMA400_OK) {
            /* Read the interrupt pin mapping configurations */
            rslt = bma400_get_regs(BMA400_INT_MAP_ADDR, data_array, 3, dev);
        }
    
        for (idx = 0; (idx < n_sett) && (rslt == BMA400_OK); idx++) {
            switch (conf[idx].type) {
            case BMA400_ACCEL:
                /* Accel configuration settings */
                rslt = get_accel_conf(&conf[idx].param.accel, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_DATA_READY_INT_MAP, &conf[idx].param.accel.int_chan);
                }
                break;
            case BMA400_TAP_INT:
                /* TAP configuration settings */
                rslt = get_tap_conf(&conf[idx].param.tap, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_TAP_INT_MAP, &conf[idx].param.tap.int_chan);
                }
                break;
            case BMA400_ACTIVITY_CHANGE_INT:
                /* Activity change configurations */
                rslt = get_activity_change_conf(&conf[idx].param.act_ch, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_ACT_CH_INT_MAP, &conf[idx].param.act_ch.int_chan);
                }
                break;
            case BMA400_GEN1_INT:
                /* Generic int1 configurations */
                rslt = get_gen1_int(&conf[idx].param.gen_int, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_GEN1_INT_MAP, &conf[idx].param.gen_int.int_chan);
                }
                break;
            case BMA400_GEN2_INT:
                /* Generic int2 configurations */
                rslt = get_gen2_int(&conf[idx].param.gen_int, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_GEN2_INT_MAP, &conf[idx].param.gen_int.int_chan);
                }
                break;
            case BMA400_ORIENT_CHANGE_INT:
                /* Orient int configurations */
                rslt = get_orient_int(&conf[idx].param.orient, dev);
                if (rslt == BMA400_OK) {
                    /* Get the INT pin mapping */
                    get_int_pin_map(data_array, BMA400_ORIENT_CH_INT_MAP, &conf[idx].param.orient.int_chan);
                }
                break;
            case BMA400_STEP_COUNTER_INT:
                /* Get int pin mapping settings */
                get_int_pin_map(data_array, BMA400_STEP_INT_MAP, &conf[idx].param.step_cnt.int_chan);
                break;
            default:
                rslt = BMA400_E_INVALID_CONFIG;
            }
        }
    
        return rslt;
    }

    Further reads

    Datasheets:

    Application notes:

    Handing soldering and mounting instructions

     

     

      

     

     

      

     

     

     

     

     

               

                                  

                     

     

                   

                            

                      

               

                  

     

     

                 

     

                 

     

     

     

     

     

     

     

     

        

               

     

         

     

          

              

       

        

     

          

     

                

     

     

    Version history
    Revision #:
    3 of 3
    Last update:
    ‎08-14-2019 10:20 AM
    Updated by:
     
    Contributors
    Icon--AD-black-48x48Icon--address-consumer-data-black-48x48Icon--appointment-black-48x48Icon--back-left-black-48x48Icon--calendar-black-48x48Icon--center-alignedIcon--Checkbox-checkIcon--clock-black-48x48Icon--close-black-48x48Icon--compare-black-48x48Icon--confirmation-black-48x48Icon--dealer-details-black-48x48Icon--delete-black-48x48Icon--delivery-black-48x48Icon--down-black-48x48Icon--download-black-48x48Ic-OverlayAlertIcon--externallink-black-48x48Icon-Filledforward-right_adjustedIcon--grid-view-black-48x48IC_gd_Check-Circle170821_Icons_Community170823_Bosch_Icons170823_Bosch_Icons170821_Icons_CommunityIC-logout170821_Icons_Community170825_Bosch_Icons170821_Icons_CommunityIC-shopping-cart2170821_Icons_CommunityIC-upIC_UserIcon--imageIcon--info-i-black-48x48Icon--left-alignedIcon--Less-minimize-black-48x48Icon-FilledIcon--List-Check-grennIcon--List-Check-blackIcon--List-Cross-blackIcon--list-view-mobile-black-48x48Icon--list-view-black-48x48Icon--More-Maximize-black-48x48Icon--my-product-black-48x48Icon--newsletter-black-48x48Icon--payment-black-48x48Icon--print-black-48x48Icon--promotion-black-48x48Icon--registration-black-48x48Icon--Reset-black-48x48Icon--right-alignedshare-circle1Icon--share-black-48x48Icon--shopping-bag-black-48x48Icon-shopping-cartIcon--start-play-black-48x48Icon--store-locator-black-48x48Ic-OverlayAlertIcon--summary-black-48x48tumblrIcon-FilledvineIc-OverlayAlertwhishlist