2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发

Cypress-BLE 开发套件可以快速开发 物联网电子产品。

PSOC编程特点:

A 拖放各PSoC 组件到工作区中,以设计原理图

B 完成各组件之间的布线,并配置GPIO

C 使用所包含的组件API 开发和调试固件


一:使用入门:

  PSOC Creator :一款 IDE工具,可以直接进行硬件和固件设计,如下图,创建新工程后。我们可以配置电路图,选择需要用的Lib,和设置PSOC。

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第1张图片

1. 将组件图标拖放到主要设计工作区中,以进行您的硬件系统设计。

2. 对您的应用固件和PSoC 硬件进行协同设计。

3. 使用配置工具配置各组件

4. 研究包含100 多个组件的库

5. 查看组件数据手册


二:硬件框图

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第2张图片

A.>PSOC4 就是PSOC芯片了具体配置查datasheet

B> PSOC5LP是用来配合调试和串口通讯用的 ,还带了很多集成的模数模块,

其他的东西都可以在help文件里面找到。


三:开始项目

   扯淡没用,开始项目。

A 原理框图

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第3张图片

  PSOC的作用就是把很多原来外围电路 配置到IC内部。而Cypress的优势就是把BLE模块集成化,配置蓝牙参数就像填数字,傻瓜操作。

B:Topdesign 顶层设计(就是模块设置咯)

   如下图,配置好Pin脚,Uart串口,Ble模块,设置DAC (其他的模块省略)

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第4张图片

C  配置引脚

 如下图,把需要用到的引脚配置好就行。

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第5张图片

D    配置时钟,中断,模拟电路,Flash等,方法同上,傻瓜操作。


E 写main函数,其他库函数都自动生成了,但功能逻辑函数还是要自己写的,这里编程就和STM32编程一样。

   不过PSOC的优势是:所有底层配置都已经ok,只需要加功能性指令。Test功能函数如下,其他函数都是已经配置好了的。

#include"tester.h"#include "tools.h"#include "debug.h"#include "cmd_list.h"#include "hw.h"#include "ble_srv_update.h"#include "ble_srv_list.h"#include "tasks.h"tester_t tester;voidtester_init(void){

    memset((void*)&tester,0,sizeof(tester_t));

    tester.leds_timeout =1;

}

u8 tester_started_get(void){

    return tester.started;

}void tester_started_set(u8 started){

    tester.started = started;

    // If test is finished - disconnect and delete the macif(!started){

        if(tester.ble_connected){

            memset(tester.mac, 0,6);

            CyBle_GapDisconnect(cyBle_connHandle.bdHandle);

        }

        // Just in case - Reset the processor        CySoftwareReset();


        tester.update_timeout    =0;

        tester.board            =0;

    }

    tester.key                    =0;

    tester.state                =0;

    tester.error_timeout        =0;

    PIN_11_ON;

}

u8 tester_ble_connected_get(void){

    return tester.started;       

}void tester_ble_connected_set(u8 val){

    tester.ble_connected = val;

    if(!val) {

        tester.ble_paired        = val;

        tester.update_timeout    =0;


        // If the 0x0E board is disconnected - reset the testerif((tester.board ==0x0E) && (tester.state == TESTER_STATE_PASSED)){

            tester_started_set(0);

        }

        DBG_LOG(DEBUG_ACC, "\n\rTESTER: BLE Disconnected ");

    } else {

        DBG_LOG(DEBUG_ACC, "\n\rTESTER: BLE Connected ");   

    }

    tester.update_timeout = TESTER_UPDATE_TIMEOUT;

}void tester_board_set(u8 val){

    tester.board = val;

    // We will write and read the characteristic

    // on read event - busy will be cleared    ble_srv_update(BLE_SU_TEST_MODE);

    tester.state    =0;

}

u8 tester_board_get(void){

    return tester.board;

}void tester_ble_paired_set(u8 val){


    if(val){

        // Clear busy flag if the cause is waiting for pairif((!tester.ble_paired) && \

            (tester.status & TESTER_FIELD_BUSY)) {

            tester.status &=~TESTER_FIELD_BUSY;

        }

        // Just in case, if disconnection happens, after reconnection

        // it will go to the test modeif(val && tester.board) {

            ble_srv_update(BLE_SU_TEST_MODE);

        }

        DBG_LOG(DEBUG_ACC, "\n\rTESTER: BLE Paired ");

    }

    tester.ble_paired = val;

    tester.error_timeout =0;

}

u8 *tester_mac_get(void){

    return tester.mac;       

}voidtester_mac_set(u8 *mac){

    if(mac == NULL)return;

    // If test is not started - do not connectif(!tester.started)return;

    memcpy(tester.mac, mac, 6);

}voidtester_mac_parse(u8 *data){

    u8 sum, sum_rx, i;

    if(tester.ble_connected)return;

    if(data == NULL)return;

    if(data[0] !='<')return;

    if(data[13]!='>')return;


    memset((void*)&tester.mac_tmp[0],0,sizeof(tester.mac_tmp));


    for(i=0, sum=0; i<6; i++){

        tester.mac_tmp[5-i] = (ASCII_HEX_TO_DEC(data[1+i*2]) <<4);

        tester.mac_tmp[5-i]|= ASCII_HEX_TO_DEC(data[2+i*2]);

        sum += tester.mac_tmp[5-i];

    }


    sum_rx = (ASCII_HEX_TO_DEC(data[14]) <<4);

    sum_rx|= ASCII_HEX_TO_DEC(data[15]);


    if(sum != sum_rx)return;


    tester_mac_set(tester.mac_tmp);

}void tester_triac_write(u8 idx, u8 state){

    if(state >1)return;

    if((idx >3) || (!idx))return;


    tester.idx_triac = idx;

    if(idx ==1)        tester.outputs.triac_1 = state;

    elseif(idx ==2)    tester.outputs.triac_2 = state;

    elseif(idx ==3)    tester.outputs.triac_3 = state;

    ble_srv_update(BLE_SU_TRIAC);

}void tester_relay_write(u8 idx, u8 state){

    if(state >1)return;

    if((idx >3) || (!idx))return;


    tester.idx_relay = idx;

    if(idx ==1)        tester.outputs.relay_1 = state;

    elseif(idx ==2)    tester.outputs.relay_2 = state;

    elseif(idx ==3)    tester.outputs.relay_3 = state;

    ble_srv_update(BLE_SU_RELAY);

}

u8 tester_triac_idx_get(void){

    return tester.idx_triac;

}

u8 tester_relay_idx_get(void){

    return tester.idx_relay;

}

u8 tester_triac_state_get(u8 idx){

    if(idx ==1)return tester.outputs.triac_1;

    elseif(idx ==2)return tester.outputs.triac_2;

    elseif(idx ==3)return tester.outputs.triac_3;

    return0;

}

u8 tester_relay_state_get(u8 idx){

    if(idx ==1)return tester.outputs.relay_1;

    elseif(idx ==2)return tester.outputs.relay_2;

    elseif(idx ==3)return tester.outputs.relay_3;

    return0;

}void tester_error_set(u8 val){

    tester.error = val;

}void tester_key_set(u8 val){

    if(tester.key != val) tester.timeout =1;// Speed up on changetester.key = val;

}void tester_ntc_set(u8 val){

    tester.ntc = val;

}void tester_auto_timeout_set(u8 val){

    tester.auto_timeout = val;

    tester.state |=0x80;

    tester.error_timeout =0;

}voidtester_buzzer_timeout_update(void){

    if(tester.buzzer_timeout <0xFFFF) tester.buzzer_timeout++;

}// Tester state machinevoidtester_10ms_run(void){

    // Wrong states - back to initial stateif(!tester.started){

        // If connected but it not supposed to be connectedif(tester.ble_paired){

            memset(tester.mac, 0,6);

            CyBle_GapDisconnect(cyBle_connHandle.bdHandle);

            DBG_LOG(DEBUG_ACC, "\n\rTESTER: BLE paired - disconnecting ");

        } elseif(tester.ble_connected){

            memset(tester.mac, 0,6);

            CyBle_GapDisconnect(cyBle_connHandle.bdHandle);

            DBG_LOG(DEBUG_ACC, "\n\rTESTER: BLE connected - disconnecting ");

        }


        // Standalone application

        // Wait till the button will be releasedif(SW2_STATE){

            tester.sw_debaunce =0;

            while(SW2_STATE){

                CyDelay(10);

                if(tester.sw_debaunce <0xFF) tester.sw_debaunce++;

            }

            // If the button was pressed more than 60 msif(tester.sw_debaunce >6){

                // Start EP4114 testDBG_LOG(DEBUG_ACC,"\n\rTESTER: EP4114 Test starting... ");

                tester_started_set(1);

                tester_board_set(0x0E);

            }

        }


    // Test is started    }else {


        // Check if the error happenedif((tester.error_timeout > TESTER_FAIL_TIMEOUT) && (tester.state != TESTER_STATE_FAILED)){

            if(tester.ble_paired || (!tester.ble_paired && (tester.error_timeout > TESTER_PAIR_FAIL_TIMEOUT))) {

                tester.status |= TESTER_FIELD_ERROR;

                tester.status &=~TESTER_FIELD_BUSY;

                tester.state = TESTER_STATE_FAILED;

                DBG_LOG(DEBUG_ACC, "\n\rTESTER: FAILED ");

                tester.error_timeout =0;

            }

        }


        // If not paired - tell PC that it is busyif(!tester.ble_paired) {

            tester.status |= TESTER_FIELD_BUSY;

            tester.error_timeout++;   

        } else {

            // Busy - all except errorsif(ble_srv_update_busy_get())    {

                if(ble_srv_update_ids_get() &~BLE_SU_ERROR)    tester.status |= TESTER_FIELD_BUSY;

            }

            elseif(tester.board !=0x0E)                    tester.status &=~TESTER_FIELD_BUSY;


            if(tester.error || ((tester.board ==0x0E) && (tester.state == TESTER_STATE_FAILED)))

                                            tester.status |= TESTER_FIELD_ERROR;

            elsetester.status &=~TESTER_FIELD_ERROR;


            if(tester.key)                    tester.status |= TESTER_FIELD_SWITCH;

            elsetester.status &=~TESTER_FIELD_SWITCH;


            // Zero cross generator for EP4114if(tester.board ==0x0E){

                if(PIN_9_STATE) PIN_9_OFF;

                else            PIN_9_ON;

            }


            // EP4114 is automated testif((tester.board ==0x0E) && (!ble_srv_update_busy_get())){


                switch(tester.state){


                    /* *****************************

                    *    Hi / Lo Level test

                    ********************************/// ********** PIN 2 test **********

                    // Turn Oncase TESTER_STATE_PIN2_ON_TURN:

                        tester.status |= TESTER_FIELD_BUSY;

                        tester.outputs.relay_3    =1;

                        tester.idx_relay        =3;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Oncase TESTER_STATE_PIN2_ON_TEST:

                        if(PIN_2_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN2:  ON  OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN2:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Turn OFFcase TESTER_STATE_PIN2_OFF_TURN:

                        tester.outputs.relay_3    =0;

                        tester.idx_relay        =3;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Offcase TESTER_STATE_PIN2_OFF_TEST:

                        if(!PIN_2_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN2:  OFF OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN2:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // ********** PIN 3 test **********

                    // Turn Oncase TESTER_STATE_PIN3_ON_TURN:

                        tester.outputs.triac_1    =1;

                        tester.idx_triac        =1;

                        ble_srv_update(BLE_SU_TRIAC);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Oncase TESTER_STATE_PIN3_ON_TEST:

                        if(PIN_3_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN3:  ON  OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN3:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Turn Offcase TESTER_STATE_PIN3_OFF_TURN:

                        tester.outputs.triac_1    =0;

                        tester.idx_triac        =1;

                        ble_srv_update(BLE_SU_TRIAC);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Off    case TESTER_STATE_PIN3_OFF_TEST:   

                        if(!PIN_3_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN3:  OFF OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN3:  Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    // ********** PIN 4 test **********

                    // Turn Oncase TESTER_STATE_PIN4_ON_TURN:

                        tester.outputs.triac_2    =1;

                        tester.idx_triac        =2;

                        ble_srv_update(BLE_SU_TRIAC);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Oncase TESTER_STATE_PIN4_ON_TEST:

                        if(PIN_4_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN4:  ON  OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN4:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Turn Offcase TESTER_STATE_PIN4_OFF_TURN:

                        tester.outputs.triac_2    =0;

                        tester.idx_triac        =2;

                        ble_srv_update(BLE_SU_TRIAC);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Offcase TESTER_STATE_PIN4_OFF_TEST:

                        if(!PIN_4_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN4:  OFF OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN4:  Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    // ********** PIN 7 test **********

                    // Turn Oncase TESTER_STATE_PIN7_ON_TURN:

                        tester.outputs.relay_1    =1;

                        tester.idx_relay        =1;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Oncase TESTER_STATE_PIN7_ON_TEST:

                        if(PIN_7_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN7:  ON  OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN7:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Turn Offcase TESTER_STATE_PIN7_OFF_TURN:

                        tester.outputs.relay_1    =0;

                        tester.idx_relay        =1;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Offcase TESTER_STATE_PIN7_OFF_TEST:

                        if(!PIN_7_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN7:  OFF OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN7:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // ********** PIN 8 test **********

                    // Turn Oncase TESTER_STATE_PIN8_ON_TURN:

                        tester.outputs.relay_2    =1;

                        tester.idx_relay        =2;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Oncase TESTER_STATE_PIN8_ON_TEST:

                        if(PIN_8_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN8:  ON  OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN8:  Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Turn Offcase TESTER_STATE_PIN8_OFF_TURN:

                        tester.outputs.relay_2    =0;

                        tester.idx_relay        =2;

                        ble_srv_update(BLE_SU_RELAY);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Offcase TESTER_STATE_PIN8_OFF_TEST:

                        if(!PIN_8_STATE){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN8:  OFF OK ");

                        } else {

                            // Failedif(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN8:  Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    /* *****************************

                    *    Advance

                    ********************************/// PIN 5 - ADCcase TESTER_STATE_PIN5_TEST:

                        if( ((((info_error_t)tester.error != INFO_ERROR_NTC_ROOM)&& \

                            ((info_error_t)tester.error != INFO_ERR_NTC_ROOM)) )    && \

                            ((tester.ntc >  TESTER_NTC_LIM_MIN) && (tester.ntc < TESTER_NTC_LIM_MAX)) ) {

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN5:      OK %u %u ", tester.error, tester.ntc);

                            tester.error_timeout =0;

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN5:  Failed %u %u ", tester.error, tester.ntc);

                            tester.error_timeout++;

                        }

                        break;


                    // PIN 9 - Zero crosscase TESTER_STATE_PIN9_TEST:

                        if((info_error_t)tester.error != INFO_ERR_ZERO_CROSS){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN9:      OK %u ", tester.error);

                            tester.error_timeout =0;

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN9:  Failed %u ", tester.error);

                            tester.error_timeout++;

                        }

                        tester.buzzer_timeout =0;

                        break;


                    // PIN 10 - Buzzer

                    // Lowcase TESTER_STATE_PIN10_OFF_TEST:

                        if(tester.buzzer_timeout <3000){

                            while(PIN_10_STATE){

                                tasks_run_critical();

                                if(tester.buzzer_timeout >3000)break;

                            }

                            if(tester.buzzer_timeout <3000){

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN10: OFF OK ");

                                tester.state++;

                                tester.buzzer_timeout =0;

                                tester.error_timeout =0;

                            }

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN10: Failed ");

                            tester.error_timeout++;

                        }

                        break;

                    // Highcase TESTER_STATE_PIN10_ON_TEST:

                        if(tester.buzzer_timeout <3000){

                            while(!PIN_10_STATE){

                                tasks_run_critical();

                                if(tester.buzzer_timeout >3000)break;

                            }

                            if(tester.buzzer_timeout <3000){

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN10: ON  OK ");

                                tester.state++;

                                tester.buzzer_timeout =0;

                                tester.error_timeout =0;

                            }

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN10: Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    // PIN 11 - Switch

                    // Turn Offcase TESTER_STATE_PIN11_OFF_TURN:

                        PIN_11_ON;

                        tester_auto_timeout_set(TESTER_AUTO_SW_TIMEOUT);

                        break;


                    // Read the statecase TESTER_STATE_PIN11_OFF_READ:

                        ble_srv_update(BLE_SU_ERROR);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;

                    // Offcase TESTER_STATE_PIN11_OFF_TEST:

                        if(tester.key ==0){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN11: OFF OK ");

                            tester.error_timeout =0;

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN11: Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    // Turn Oncase TESTER_STATE_PIN11_ON_TURN:

                        PIN_11_OFF;

                        tester_auto_timeout_set(TESTER_AUTO_SW_TIMEOUT);

                        break;


                    // Readcase TESTER_STATE_PIN11_ON_READ:

                        ble_srv_update(BLE_SU_ERROR);

                        tester_auto_timeout_set(TESTER_AUTO_TIMEOUT);

                        break;


                    // Oncase TESTER_STATE_PIN11_ON_TEST:

                        if(tester.key){

                            tester.state++;

                            DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN11: ON  OK ");

                            tester.error_timeout =0;

                            PIN_11_ON;

                        } else {

                            if(tester.error_timeout == TESTER_FAIL_TIMEOUT)

                                DBG_LOG(DEBUG_ACC, "\n\rTESTER: PIN11: Failed ");

                            tester.error_timeout++;

                        }

                        break;


                    case TESTER_STATE_CLEAR_BUSY:

                        tester.status &=~TESTER_FIELD_BUSY;

                        DBG_LOG(DEBUG_ACC, "\n\rTESTER: PASSED ");

                        tester.state++;

                        tester.error_timeout =0;

                        break;


                    case TESTER_STATE_PASSED:

                    case TESTER_STATE_FAILED:

                        // Stay herebreak;



                    case(TESTER_STATE_PIN2_ON_TURN|0x80):

                    case(TESTER_STATE_PIN2_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN3_ON_TURN|0x80):

                    case(TESTER_STATE_PIN3_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN4_ON_TURN|0x80):

                    case(TESTER_STATE_PIN4_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN7_ON_TURN|0x80):

                    case(TESTER_STATE_PIN7_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN8_ON_TURN|0x80):

                    case(TESTER_STATE_PIN8_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN11_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN11_OFF_READ|0x80):

                    case(TESTER_STATE_PIN11_ON_TURN|0x80):

                    case(TESTER_STATE_PIN11_ON_READ|0x80):

                        if(tester.auto_timeout){

                            if(!(--tester.auto_timeout)){

                                tester.state = (tester.state &0x7F) +1;

                            }

                        }

                        break;


                    default:

                        tester.state =0;

                        break;

                }

            }


        }


    }


    // Tester board to PC UART wirte handlingif(tester.timeout) {

        if(!(--tester.timeout)){

            // Send that the error or busy no longer existsif(!(tester.status & (TESTER_FIELD_ERROR | TESTER_FIELD_BUSY))) cmd_status(tester.status, tester.mac);

        }

    } else {

        // If error - send it up to the PCif(tester.status & (TESTER_FIELD_ERROR | TESTER_FIELD_BUSY)) {

            cmd_status(tester.status, tester.mac);

            tester.timeout = TESTER_UART_TIMEOUT;

        }

    }


    // Error update from the BLEif(tester.update_timeout) {

        if(!(--tester.update_timeout)){

            if(tester.ble_paired) ble_srv_list_read_add(BLE_SRV_LIST_TEST);

            tester.update_timeout = TESTER_UPDATE_TIMEOUT;

            // If no comunication is on going send the status packetif(!tester.timeout){

                //cmd_status(tester.status, tester.mac); // ?            }

        }

    }



    // Board LEDs handlingif(tester.started){

        // Blueif(tester.ble_paired){

            if(tester.board ==0x0E){

                switch(tester.state){

                    case TESTER_STATE_PASSED:

                    case TESTER_STATE_CLEAR_BUSY:

                        LED_RED_OFF;

                        LED_GREEN_ON;

                        LED_BLUE_OFF;

                        break;

                    case TESTER_STATE_PIN2_ON_TEST:

                    case TESTER_STATE_PIN2_OFF_TEST:

                    case TESTER_STATE_PIN3_ON_TEST:

                    case TESTER_STATE_PIN3_OFF_TEST:

                    case TESTER_STATE_PIN4_ON_TEST:

                    case TESTER_STATE_PIN4_OFF_TEST:

                    case TESTER_STATE_PIN7_ON_TEST:

                    case TESTER_STATE_PIN7_OFF_TEST:

                    case TESTER_STATE_PIN8_ON_TEST:

                    case TESTER_STATE_PIN8_OFF_TEST:

                    case TESTER_STATE_PIN5_TEST:

                    case TESTER_STATE_PIN9_TEST:

                    case TESTER_STATE_PIN11_OFF_TEST:

                    case TESTER_STATE_PIN11_ON_TEST:

                    case TESTER_STATE_PIN10_OFF_TEST:

                    case TESTER_STATE_PIN10_ON_TEST:

                        LED_RED_ON;

                        LED_GREEN_OFF;

                        LED_BLUE_ON;

                        break;

                    case (TESTER_STATE_PIN2_ON_TURN):

                    case (TESTER_STATE_PIN2_OFF_TURN):

                    case (TESTER_STATE_PIN3_ON_TURN):

                    case (TESTER_STATE_PIN3_OFF_TURN):

                    case (TESTER_STATE_PIN4_ON_TURN):

                    case (TESTER_STATE_PIN4_OFF_TURN):

                    case (TESTER_STATE_PIN7_ON_TURN):

                    case (TESTER_STATE_PIN7_OFF_TURN):

                    case (TESTER_STATE_PIN8_ON_TURN):

                    case (TESTER_STATE_PIN8_OFF_TURN):

                    case (TESTER_STATE_PIN11_OFF_TURN):

                    case (TESTER_STATE_PIN11_OFF_READ):

                    case (TESTER_STATE_PIN11_ON_TURN):

                    case (TESTER_STATE_PIN11_ON_READ):

                    case(TESTER_STATE_PIN2_ON_TURN|0x80):

                    case(TESTER_STATE_PIN2_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN3_ON_TURN|0x80):

                    case(TESTER_STATE_PIN3_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN4_ON_TURN|0x80):

                    case(TESTER_STATE_PIN4_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN7_ON_TURN|0x80):

                    case(TESTER_STATE_PIN7_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN8_ON_TURN|0x80):

                    case(TESTER_STATE_PIN8_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN11_OFF_TURN|0x80):

                    case(TESTER_STATE_PIN11_OFF_READ|0x80):

                    case(TESTER_STATE_PIN11_ON_TURN|0x80):

                    case(TESTER_STATE_PIN11_ON_READ|0x80):

                        LED_RED_OFF;

                        LED_GREEN_OFF;

                        LED_BLUE_ON;

                        break;

                    case TESTER_STATE_FAILED:

                    default:

                        LED_RED_ON;

                        LED_GREEN_OFF;

                        LED_BLUE_OFF;

                        break;

                }

            } else {

                LED_RED_OFF;

                LED_GREEN_OFF;

                LED_BLUE_ON;

            }

        // Blue Flashing slow}elseif(tester.ble_connected){

            if(tester.leds_timeout){

                if(!(--tester.leds_timeout)){

                    tester.leds_timeout = TESTER_LEDS_SLOW_TIMEOUT;


                    if(LED_BLUE_STATE){

                        LED_RED_OFF;

                        LED_GREEN_OFF;

                        LED_BLUE_OFF;

                    } else {

                        LED_RED_OFF;

                        LED_GREEN_OFF;

                        LED_BLUE_ON;

                    }

                }

            }

        // Blue Flashing fast}else {

            if(tester.state == TESTER_STATE_FAILED){

                LED_RED_ON;

                LED_GREEN_OFF;

                LED_BLUE_OFF;

            } else {

                if(tester.leds_timeout){

                    if(!(--tester.leds_timeout)){

                        tester.leds_timeout = TESTER_LEDS_FAST_TIMEOUT;


                        if(LED_BLUE_STATE){

                            LED_RED_OFF;

                            LED_GREEN_OFF;

                            LED_BLUE_OFF;

                        } else {

                            LED_RED_OFF;

                            LED_GREEN_OFF;

                            LED_BLUE_ON;

                        }

                    }

                }

            }

        }

    // Red}else {

        if(tester.leds_timeout){

            if(!(--tester.leds_timeout)){

                tester.leds_timeout = TESTER_LEDS_TIMEOUT;


                if(LED_RED_STATE){

                    LED_RED_OFF;

                    LED_GREEN_OFF;

                    LED_BLUE_OFF;

                } else {

                    LED_RED_ON;

                    LED_GREEN_OFF;

                    LED_BLUE_OFF;

                }

            }

        }

    }

}

四:调试

   这里只测试了BLE输出电平逻辑,LCD ,KEY, Cap sense 等在另一板子上。

2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发_第6张图片


4总结

一般MCU的开发流程..而psoc的开发环境里面有很多用户模块,比如I2C SPI... 这些用户模块一般MCU编写的时候,需要自己写时序,写底层代码,而PSOC已经写好了这些函数,只需调用相应的API函数 就可以,省了写这些code的时间.. 这个是最明显的区别,psoc不用操作底层寄存器,除非你需要改变某个设置;你还可以配置芯片内部模块 。


缺点:psoc芯片价格昂贵。这一颗Cypress芯片需要 10美金,加上外围产品,成本会比ARm芯片贵很多。 这也是中国很少用PSOC的原因吧。

你可能感兴趣的:(2018-05-28 PSOC第一枪:基于cypress的蓝牙产品开发)