iBreathe Breathalyzer can now talk thanks to the Text to Speech Click Board
Dependencies: Hexi_KW40Z Hexi_OLED_SSD1351 text_to_speak_mbed
Fork of iBreathe_Breathalyzer by
Diff: main.cpp
- Revision:
- 9:fe5114551ec3
- Parent:
- 7:5d272a0e250b
diff -r 3ce1c2cee4b4 -r fe5114551ec3 main.cpp --- a/main.cpp Wed Sep 28 11:12:05 2016 +0000 +++ b/main.cpp Fri Oct 07 20:09:39 2016 +0000 @@ -1,14 +1,16 @@ /**************************************************************************** * Title : iBreathe Breathalyzer -* Filename : breathalyzer +* Filename : Talking_breathalyzer * Author : Dave Clarke * Origin Date : 27/09/2016 -* Notes : Breathalyzer utilizing Hexiware, Alcohol click and Wolksense +* Notes : Breathalyzer utilizing Hexiware, Alcohol click and + Wolksense. Now with added voice thanks to the + Text-To-Speech Click board *****************************************************************************/ /**************************CHANGE LIST ************************************** * * Date Software Version Initials Description -* 27/09/16 1.0.0 DC Interface Created. +* 07/10/16 1.0.0 DC Interface Created. * *****************************************************************************/ @@ -21,6 +23,7 @@ * <li><b> Dev. Board </b> : HEXIWEAR </li> * <li><b> Oscillator </b> : 12 MHz external </li> * <li><b> Ext. Modules </b> : Alcohol Click on mikroBUS 1 </li> + * <li><b> Ext. Modules </b> : TTS Click on mikroBUS 2 </li> * <li><b> SW </b> : mBed OS5 </li> * </ul> */ @@ -31,9 +34,10 @@ * @par This will show you how much you've drunk and tell you with an Emoticon if * you're too hammered to even consider driving. Using the Hexiware app the readings * are transmitted to the cloud via bluetooth. Is it time to give up drinking yet?! + * It now talks to you! * <h3> Alcohol Features </h3> - * @par Alcohol click, Hexiwear docking station, Hexiware + * @par Text to Speech Click, Alcohol click, Hexiwear docking station, Hexiware */ /****************************************************************************** @@ -47,6 +51,11 @@ #include "OpenSans_Font.h" #include "string.h" #include "iBreatheImages.h" +#include "text_to_speech.h" +#include "text_to_speech_hal.h" +#include "text_to_speech_hw.h" +#include "text_to_speech_img.h" + /****************************************************************************** * Module Variable Definitions @@ -87,12 +96,49 @@ value1[20]; // initial sensor set up values bool isFirstBoot = true; - + + +/* Indication Flags */ +static volatile bool _tts_rdy_f; +static volatile bool _spc_rdy_f; +static volatile bool _tts_fin_f; +static volatile bool _spc_fin_f; + +/* Error Buffers */ +static uint16_t _req_err; +static uint16_t _err_code; +/* Default Configuration */ +static ACONF_t _audio_conf; +static TTSCONF_t _tts_conf; +static PMANCONF_t _pman_conf; + +static bool _flush_enable; + +/* Timer flag and counter */ +static volatile bool _ticker_f; +static volatile uint16_t _ticker; + +/* Input and output buffers */ +static ISC_REQ_t _last_req; +static ISC_RESP_t _last_rsp; + +static uint8_t test[ 8 ] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; +int frequency = 750000; +VER_t *version; /****************************************************************************** * Function Prototypes *******************************************************************************/ +/* Checks for indications */ +static int _parse_ind( void ); +/* Message block and error callback function pointers */ +static void ( *_fatal_err_callback )( uint16_t *err_code ); +static void ( *_err_callback )( uint16_t *err_code ); +static void ( *_msg_block_callback )( uint16_t *msg_code, + uint16_t *err_code ); + +void voiceinit(void); void sysinit(void); void ReadSensor(); void CalculatePPM(int times, bool amb); @@ -101,10 +147,14 @@ void StopHaptic(void const *n); void ButtonUp(void); void txTask(void); +void fatal_err( uint16_t *err ); +void msg_blk( uint16_t *req, uint16_t *err ); /****************************************************************************** * Instance setups *******************************************************************************/ + + /* Define timer for haptic feedback */ RtosTimer hapticTimer(StopHaptic, osTimerOnce); @@ -126,6 +176,18 @@ DigitalOut blueLed(LED3); DigitalOut haptic(PTB9); +/* Instantiate the Click Text to Speech pinout */ +DigitalOut TTS_RST(PTB19); +DigitalOut TTS_CS(PTC3); +DigitalOut TTS_MUTE(PTB3); +DigitalIn TTS_RDY(PTB8); + +//Instantiate SPI for comms with Speak module +SPI TextToSpeech(PTC6, PTC7, PTC5); // MOSI, MISO, SCK + +// Debug Serial +Serial pc(USBTX, USBRX); + /****************************************************************************** * Bluetooth button functions and passkey function *******************************************************************************/ @@ -167,6 +229,8 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { + + /* Set pointers to the BMPs stored in iBreatheImages.c */ welcome = iBreatheWS_bmp; // Welcome screen image blank = iBreatheBlank_bmp; // blank image @@ -176,9 +240,17 @@ hang = iBreatheHang_bmp; // You'll have a hangover image ini = iBreatheini_bmp; // Initialising image sober = iBreatheSober_bmp; // Sober as a judge image - - /* Set initial Values */ - sysinit(); + + /* Set initial Values */ + sysinit(); + + /* initialise voice engine */ + voiceinit(); + + /* Welcome message on reset */ + tts_speak( "Hello, welcome to the eye brethalizer " ); + wait(0.5); + tts_speak( "please press start. " ); } /****************************************************************************** @@ -363,14 +435,16 @@ isFirstBoot = false; } + /*read ambient atmosphere levels with 10 samples and set flag to show it's ambient basline figure*/ + tts_speak( "initializing" ); ambient(10); CalculatePPM(10,Ref); /* Fill 96px by 96px Screen with 96px by 96px Blowing Image starting at x=0,y=0 */ oled.DrawImage(blow,0,0); - + tts_speak( "please blow until buzzing stops" ); /*read breathe alcohol levels with 10 samples and set flag to show it's breathilyzer test figure*/ CalculatePPM(10,Test); @@ -385,12 +459,18 @@ /* Fill 96px by 96px Screen with 96px by 96px Blank Background Image starting at x=0,y=0 */ oled.DrawImage(blank,0,0); - + tts_speak( "Test Complete" ); + Thread::wait(500); /* Show Calculated alcohol level in PPM and send data via bluetooth to the cloud */ oled.SetTextProperties(&textProperties); oled.Label(ppmText,20,36); + tts_speak( "you blew" ); sprintf(text,"%.2f",ppm); + Thread::wait(50); + tts_speak( text ); oled.Label((uint8_t *)text,50,36); + Thread::wait(50); + tts_speak( "pee pee emm" ); Thread::wait(1000); /* Currently sending to the Pressure variable as a temp place holder */ @@ -401,6 +481,7 @@ /* You've got a Hangover coming!*/ if ( ppm > 200) { + tts_speak("you have got a hang over coming"); redLed = LED_ON; greenLed = LED_OFF; blueLed = LED_OFF; @@ -414,6 +495,7 @@ /* You Shouldn't drive */ else if (ppm < 200 && ppm > 150) { + tts_speak("you shouldn't drive"); redLed = LED_ON; greenLed = LED_OFF; blueLed = LED_ON; @@ -427,6 +509,7 @@ /* You've had a drink */ else if (ppm < 150 && ppm > 50) { + tts_speak("you have had a drinky"); redLed = LED_OFF; greenLed = LED_ON; blueLed = LED_ON; @@ -440,6 +523,7 @@ /* Sober as a judge*/ else { + tts_speak("you are as sober as a judge"); redLed = LED_OFF; greenLed = LED_ON; blueLed = LED_OFF; @@ -465,7 +549,7 @@ **************************************************************************************************/ void sysinit(void) { - /* Set LED to Blue by default*/ + /* Set LED to Blue by default*/ redLed = LED_OFF; greenLed = LED_OFF; blueLed = LED_ON; @@ -489,4 +573,1269 @@ oled.GetTextProperties(&textProperties); textProperties.fontColor = COLOR_WHITE; oled.SetTextProperties(&textProperties); -} \ No newline at end of file +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* Function void voiceinit(void) +* ------------------------------------------------------------------------------------------------- +* Overview: initialise voice engine +* Input: None +* Output: None +**************************************************************************************************/ +void voiceinit(void) +{ + + /*setting up the SPI defaults*/ + TextToSpeech.lock(); + TextToSpeech.format(8,3); + TextToSpeech.frequency(frequency); + TextToSpeech.unlock(); + + /* initialise voice */ + pc.printf("System Init Done!\r\n"); + tts_init(); + pc.printf("tts Init Done!\r\n"); + tts_setup(); + pc.printf("tts setup Done!\r\n"); + tts_msg_block_callback( msg_blk ); + tts_fatal_err_callback( fatal_err ); + tts_config( 0x10, false, TTSV_US, 0x0080 ); + tts_unmute(); + +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* Function msg_blk( uint16_t *req, uint16_t *err ) +* ------------------------------------------------------------------------------------------------- +* Overview: receive a blocked message from S1V30120; +**************************************************************************************************/ +void msg_blk( uint16_t *req, uint16_t *err ) +{ + char txt[ 6 ]; + + pc.printf( " MSG BLOCKED \r\n" ); + sprintf( txt, "%x\r\n", *req ); + pc.printf( txt ); + sprintf( txt, "%x\r\n", *err ); + pc.printf( txt ); +} +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* Function fatal_err( uint16_t *err ) +* ------------------------------------------------------------------------------------------------- +* Overview: error detected +**************************************************************************************************/ +void fatal_err( uint16_t *err ) +{ + pc.printf( "Fatal Error Detected" ); + tts_init(); + tts_fatal_err_callback( fatal_err ); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* text_to_speech_hal.c +* ------------------------------------------------------------------------------------------------- +* Overview: Functions to control SPI interface. +**************************************************************************************************/ + +void tts_hal_cs_high() +{ + + TTS_CS = 1; +} + +void tts_hal_cs_low() +{ + TTS_CS = 0; + +} + +void tts_hal_mut_high() +{ + TTS_MUTE = 1; +} + +void tts_hal_mut_low() +{ + TTS_MUTE = 0; +} + +void tts_hal_reset( void ) +{ + tts_hal_cs_high(); + TTS_RST = 0; + tts_hal_write_pad(1); + wait(0.01); + TTS_RST = 1; + wait(POR_TIME); +} + +bool tts_hal_msg_rdy( void ) +{ + return TTS_RDY; +} + +void tts_hal_init() +{ + tts_hal_reset(); + tts_hal_cs_high(); + tts_hal_mut_low(); +} + +void tts_hal_write( uint8_t *buffer, + uint16_t count, bool boot ) +{ + TextToSpeech.lock(); + while( count-- ) + { + if(!boot) + pc.printf("%02X\r\n", *buffer); + + TextToSpeech.write( *buffer++ ); + + } + TextToSpeech.unlock(); +} + + +void tts_hal_write_pad( int cnt ) +{ + TextToSpeech.lock(); + tts_hal_cs_low(); + while(cnt--) + { + TextToSpeech.write( PADDING_BYTE ); + } + + tts_hal_cs_high(); + TextToSpeech.unlock(); +} + +void tts_hal_read( uint8_t *buffer, + uint16_t count ) +{ + TextToSpeech.lock(); + while(count--) + { + *buffer++ = TextToSpeech.write( DUMMY_BYTE ); //read spi bus + + + //pc.printf("buffer = %X\n\r", *buffer); + } + TextToSpeech.unlock(); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* text_to_speech.c +* ------------------------------------------------------------------------------------------------- +* Overview: Functions to control the setup and speech controls +**************************************************************************************************/ + +static int _parse_ind( void ) +{ + uint16_t rsp_idx = tts_rsp_idx(); + if ( rsp_idx == ISC_MSG_BLOCKED_RESP ) + { + uint8_t rsp_data[ 4 ] = { 0 }; + + _req_err = 0; + _err_code = 0; + + tts_rsp_data( rsp_data ); + + _req_err |= rsp_data[ 0 ]; + _req_err |= rsp_data[ 1 ] << 8; + _err_code |= rsp_data[ 2 ]; + _err_code |= rsp_data[ 3 ] << 8; + + if( _msg_block_callback != NULL ) + _msg_block_callback( &_req_err, &_err_code ); + + return 1; + + } else if ( rsp_idx == ISC_ERROR_IND ) { + + uint8_t rsp_data[ 4 ] = { 0 }; + + _req_err = 0; + _err_code = 0; + + tts_rsp_data( rsp_data ); + + _err_code |= rsp_data[ 0 ]; + _err_code |= rsp_data[ 1 ] << 8; + + if ( _err_code && _err_code < 0x8000 ) + { + if( _err_callback != NULL ) + _err_callback( &_err_code ); + + } else if ( _err_code && _err_code > 0x7FFF ) { + + if( _fatal_err_callback != NULL ) + _fatal_err_callback( &_err_code ); + } + + return 1; + + } else if ( rsp_idx == ISC_TTS_READY_IND ) { + + _tts_rdy_f = 1; + + } else if ( rsp_idx == ISC_SPCODEC_READY_IND ) { + + _spc_rdy_f = 1; + + } else if ( rsp_idx == ISC_TTS_FINISHED_IND ) { + + _tts_fin_f = 1; + + } else if ( rsp_idx == ISC_SPCODEC_FINISHED_IND ) { + + _spc_fin_f = 1; + } + + return 0; +} + +void tts_init() +{ + _req_err = 0; + _err_code = 0; + + _tts_rdy_f = true; + _spc_rdy_f = true; + _tts_fin_f = true; + _spc_fin_f = true; + + _audio_conf.as = 0x00; + _audio_conf.ag = 0x43; + _audio_conf.amp = 0x00; + _audio_conf.asr = ASR_11KHZ; + _audio_conf.ar = 0x00; + _audio_conf.atc = 0x00; + _audio_conf.acs = 0x00; + _audio_conf.dc = 0x00; + + _tts_conf.sr = 0x01; + _tts_conf.voice = 0x00; + _tts_conf.ep = 0x00; + _tts_conf.lang = TTSV_US; + _tts_conf.sr_wpm_lsb = 0xc8; + _tts_conf.sr_wpm_msb = 0x00; + _tts_conf.ds = 0x00; + _tts_conf.res = 0x00; + + _pman_conf.am_lsb = 0x01; + _pman_conf.am_msb = 0x00; + _pman_conf.spi_clk = 0x01; + _pman_conf.pad = PADDING_BYTE; + + _flush_enable = false; + + _msg_block_callback = NULL; + _fatal_err_callback = NULL; + _err_callback = NULL; + + tts_hw_init(); +} + +void tts_msg_block_callback( void( *msg_blk_ptr )( uint16_t *req_ptr, + uint16_t *err_ptr ) ) +{ + _msg_block_callback = msg_blk_ptr; +} + +void tts_fatal_err_callback( void( *fatal_err_ptr )( uint16_t *err_ptr ) ) +{ + _fatal_err_callback = fatal_err_ptr; +} + +void tts_err_callback( void( *error_ptr )( uint16_t *err_ptr ) ) +{ + _err_callback = error_ptr; +} + +void tts_mute() +{ + tts_mute_cmd( true ); +} + +void tts_unmute() +{ + tts_mute_cmd( false ); +} + + +void tts_setup() +{ + //check HW version + tts_version_boot(); + + int succ = tts_image_load( (uint8_t*)TTS_INIT_DATA, sizeof( TTS_INIT_DATA ) ); + + if ( succ != 0x0001 ) + { + // image load failed, try turning it off and on again + pc.printf("tts init data failed!\n\r"); + pc.printf("returned value: %X\n\r", succ); + while(1); + } + pc.printf("tts image load done\n\r"); + succ = tts_image_exec(); + + if ( succ != 0x0001 ) + { + // image boot failed, try turning it off and on again + pc.printf("tts image exec failed!\n\r"); + pc.printf("returned value: %X\n\r", succ); + while(1); + } + pc.printf("tts image exec done\n\r"); + + tts_interface_test(); + pc.printf("tts interface test done\n\r"); + + tts_power_default_config(); + pc.printf("tts power default done\n\r"); + + tts_audio_default_config(); + pc.printf("tts audio default done\n\r"); + + tts_volume_set( 0 ); + pc.printf("tts volume set done\n\r"); + + tts_default_config(); + pc.printf("tts default config done\n\r"); +} + +void tts_version_boot( void ) +{ + + uint8_t tmp_resp[ 16 ] = { 0 }; + + wait( RESET_TO_BOOT_TIME ); + + tts_parse_req( ISC_VERSION_REQ_BOOT, NULL, 0 ); + + while( !tts_rsp_chk( ISC_VERSION_RESP_BOOT ) ) + { + tts_get_resp(); + } + tts_hal_write_pad( 16); + tts_rsp_data( tmp_resp ); + pc.printf("hwver0 %X \n\r", tmp_resp[ 0 ]); + pc.printf("hwver1 %X \n\r", tmp_resp[ 1 ]); +} + +uint16_t tts_image_load(const uint8_t *image, + uint16_t count ) +{ + uint16_t tmp_resp = 0; + uint16_t index = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + while ( ( count - index ) > ( BOOT_MESSAGE_MAX - 4 ) ) + { + + tts_parse_boot_img( image + index, BOOT_MESSAGE_MAX - 4 ); + wait(0.01); + index += ( BOOT_MESSAGE_MAX - 4 ); + } + tts_parse_boot_img( image + index, count - index ); + wait(0.01); + + while( !tts_rsp_chk( ISC_BOOT_LOAD_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_image_exec() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + tts_parse_req( ISC_BOOT_RUN_REQ, NULL, 0 ); + + while( !tts_rsp_chk( ISC_BOOT_RUN_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_interface_test() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + wait( BOOT_TO_MAIN_MODE ); + + tts_parse_req( ISC_TEST_REQ, test, 8 ); + + while( !tts_rsp_chk( ISC_TEST_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + + uint16_t tts_version_main( VER_t *buffer ) +{ + char tmp_char[ 3 ] = { 0 }; + uint32_t tmp_fwf = 0; + uint32_t tmp_fwef = 0; + uint8_t tmp_resp[ 20 ] = { 0 }; + + tts_parse_req( ISC_VERSION_REQ_MAIN, NULL, 0 ); + + while( !tts_rsp_chk( ISC_VERSION_RESP_MAIN ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( tmp_resp ); + sprintf(tmp_char, "%c", tmp_resp[ 0 ]); + strcpy( buffer->hwver, tmp_char ); + strcat( buffer->hwver, "." ); + sprintf(tmp_char, "%c", tmp_resp[ 1 ]); + strcat( buffer->hwver, tmp_char ); + sprintf(tmp_char, "%c", tmp_resp[ 2 ]); + strcpy( buffer->fwver, tmp_char ); + strcat( buffer->fwver, "." ); + sprintf(tmp_char, "%c", tmp_resp[ 3 ]); + strcat( buffer->fwver, tmp_char ); + strcat( buffer->fwver, "." ); + sprintf(tmp_char, "%c", tmp_resp[ 12 ]); + strcat( buffer->fwver, tmp_char ); + + tmp_fwf |= tmp_resp[ 4 ]; + tmp_fwf |= tmp_resp[ 5 ] << 8; + tmp_fwf |= tmp_resp[ 6 ] << 16; + tmp_fwf |= tmp_resp[ 7 ] << 24; + buffer->fwf = (FF_t)tmp_fwf; + tmp_fwef |= tmp_resp[ 8 ]; + tmp_fwef |= tmp_resp[ 9 ] << 8; + tmp_fwef |= tmp_resp[ 10 ] << 16; + tmp_fwef |= tmp_resp[ 11 ] << 24; + buffer->fwef = (EFF_t)tmp_fwef; + + return 0x0000; +} + +uint16_t tts_power_default_config() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + tts_parse_req( ISC_PMAN_CONFIG_REQ, ( uint8_t* )&_pman_conf, 4 ); + + while( !tts_rsp_chk( ISC_PMAN_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_standby_enter() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + tts_parse_req( ISC_PMAN_STANDBY_ENTRY_REQ, NULL, 0 ); + + while( !tts_rsp_chk( ISC_PMAN_STANDBY_ENTRY_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_standby_exit() +{ + wait( STBY_MODE_ENTERY ); + tts_parse_req( ISC_PMAN_STANDBY_EXIT_IND, NULL, 0 ); + + while( !tts_rsp_chk( ISC_PMAN_STANDBY_EXIT_IND ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + return 0x0000; +} + +uint16_t tts_audio_default_config() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + tts_parse_req( ISC_AUDIO_CONFIG_REQ, ( uint8_t* )&_audio_conf, 8 ); + + while( !tts_rsp_chk( ISC_AUDIO_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_audio_config( int8_t audio_gain, + ASR_t sample_rate, + bool dac_control ) +{ + ACONF_t audio_conf; + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + if ( audio_gain < -48 || audio_gain > 18 ) + return 0xFFFF; + + if ( sample_rate != 0 || sample_rate != 1 || sample_rate != 3 ) + return 0xFFFF; + + audio_conf.ag = ( uint8_t )audio_gain; + audio_conf.asr = sample_rate; + audio_conf.dc = dac_control; + + tts_parse_req( ISC_AUDIO_CONFIG_REQ, ( uint8_t* )&audio_conf, 8 ); + + while( !tts_rsp_chk( ISC_AUDIO_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_volume_set( int16_t gain ) +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_gain[ 2 ] = { 0 }; + + tmp_gain[ 0 ] = gain & 0x00FF; + tmp_gain[ 1 ] = ( gain & 0xFF00 ) >> 8; + + tts_parse_req( ISC_AUDIO_VOULME_REQ, tmp_gain, 2 ); + + while( !tts_rsp_chk( ISC_AUDIO_VOLUME_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_audio_mute() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_mute[ 2 ] = { 1, 0 }; + + tts_parse_req( ISC_AUDIO_MUTE_REQ, tmp_mute, 2 ); + + while( !tts_rsp_chk( ISC_AUDIO_MUTE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_audio_unmute() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_mute[ 2 ] = { 0, 0 }; + + tts_parse_req( ISC_AUDIO_MUTE_REQ, tmp_mute, 2 ); + + while( !tts_rsp_chk( ISC_AUDIO_MUTE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_default_config() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + tts_parse_req( ISC_TTS_CONFIG_REQ, ( uint8_t* )&_tts_conf, 8 ); + + while( !tts_rsp_chk( ISC_TTS_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_config( uint8_t voice_type, + bool epson_parse, + TTSV_t language, + uint16_t speaking_rate ) +{ + TTSCONF_t tts_conf; + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + if ( voice_type > 8 ) + return 0xFFFF; + + if ( language > 4 ) + return 0xFFFF; + + if ( speaking_rate < 0x004B || speaking_rate > 0x0258 ) + return 0xFFFF; + + tts_conf.voice = voice_type; + tts_conf.ep = epson_parse; + tts_conf.lang = language; + tts_conf.sr_wpm_lsb = ( speaking_rate & 0x00FF ); + tts_conf.sr_wpm_msb = ( speaking_rate & 0xFF00 ) >> 8; + + tts_parse_req( ISC_TTS_CONFIG_REQ, ( uint8_t* )&tts_conf, 8 ); + + while( !tts_rsp_chk( ISC_TTS_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_speak( char *word ) +{ + bool tmp_f = false; + char *wptr = word; + uint8_t raw_resp[ 2 ] = { 0 }; + uint16_t tmp_resp = 0; + uint32_t wlen = strlen( wptr ); + + tts_parse_speak_req( ISC_TTS_SPEAK_REQ, _flush_enable, wptr, wlen ); + + _tts_rdy_f = 0; + _tts_fin_f = 0; + + while( !( tmp_f && _tts_rdy_f ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + + if( tts_rsp_chk( ISC_TTS_SPEAK_RESP ) ) + { + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + tmp_f = true; + } + } + + return tmp_resp; +} + +uint16_t tts_pause( void ) +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_pause[ 2 ] = { 1, 0 }; + + tts_parse_req( ISC_TTS_PAUSE_REQ, tmp_pause, 2 ); + + while( !tts_rsp_chk( ISC_TTS_PAUSE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_unpause( void ) +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_pause[ 2 ] = { 0 }; + + tts_parse_req( ISC_TTS_PAUSE_REQ, tmp_pause, 2 ); + + while( !tts_rsp_chk( ISC_TTS_PAUSE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_stop( bool reset ) +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_reset[ 2 ] = { 0 }; + + if( reset ) + tmp_reset[ 0 ] = 0x01; + + tts_parse_req( ISC_TTS_STOP_REQ, tmp_reset, 2 ); + + while( !tts_rsp_chk( ISC_TTS_STOP_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_user_dict( bool erase, + uint8_t *udict_data, + uint16_t count ) +{ + uint16_t cnt = 2; + uint16_t tmp_rsp = 0; + uint8_t rsp_data[ 2 ] = { 0 }; + uint8_t tmp_data[ BOOT_MESSAGE_MAX ] = { 0 }; + + if ( erase ) + tmp_data[ 0 ] = 1; + + while ( count-- ) + tmp_data[ cnt ++ ] = *( udict_data++ ); + + tts_parse_req( ISC_TTS_UDICT_DATA_REQ, tmp_data, count + 2 ); + + while( !tts_rsp_chk( ISC_TTS_UDICT_DATA_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( rsp_data ); + + tmp_rsp |= rsp_data[ 0 ]; + tmp_rsp |= rsp_data[ 1 ] << 8; + + return tmp_rsp; +} + +uint16_t tts_codec_configure() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_codec[ 32 ] = { 0 }; + + tmp_codec[ 0 ] = 0x01; + tmp_codec[ 1 ] = 0x01; + tmp_codec[ 24 ] = 0x02; + + tts_parse_req( ISC_SPCODEC_CONFIG_REQ , tmp_codec, 32 ); + + while( !tts_rsp_chk( ISC_SPCODEC_CONFIG_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_codec_start( uint8_t *codec_data, + uint16_t count ) +{ + bool tmp_f = false; + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + + if ( count != 512 || count != 1024 || count != 2048 ) + return 0xFFFF; + + while( !_spc_fin_f ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_parse_req( ISC_SPCODEC_START_REQ , codec_data, count ); + + _spc_rdy_f = 0; + _spc_fin_f = 0; + + while( !( tmp_f && _spc_rdy_f ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + + if( tts_rsp_chk( ISC_TTS_SPEAK_RESP ) ) + { + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + tmp_f = true; + } + } + + return tmp_resp; +} + +uint16_t tts_codec_pause() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_data[ 2 ] = { 1, 0 }; + + tts_parse_req( ISC_SPCODEC_PAUSE_REQ , tmp_data, 2 ); + + while( !tts_rsp_chk( ISC_SPCODEC_PAUSE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_codec_unpause() +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_data[ 2 ] = { 0 }; + + tts_parse_req( ISC_SPCODEC_PAUSE_REQ , tmp_data, 2 ); + + while( !tts_rsp_chk( ISC_SPCODEC_PAUSE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} + +uint16_t tts_codec_stop( bool reset ) +{ + uint16_t tmp_resp = 0; + uint8_t raw_resp[ 2 ] = { 0 }; + uint8_t tmp_data[ 2 ] = { 0 }; + + if( reset ) + tmp_data[ 0 ] = 1; + + tts_parse_req( ISC_SPCODEC_STOP_REQ, tmp_data, 2 ); + + while( !tts_rsp_chk( ISC_SPCODEC_PAUSE_RESP ) ) + { + tts_get_resp(); + + if( _parse_ind() ) + return _err_code; + } + + tts_rsp_data( raw_resp ); + + tmp_resp |= raw_resp[ 0 ]; + tmp_resp |= raw_resp[ 1 ] << 8; + + return tmp_resp; +} +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +/************************************************************************************************** +* text_to_speech_hw.c +* ------------------------------------------------------------------------------------------------- +* Overview: Mainly read and write functions with parsing +**************************************************************************************************/ + +void _read_rsp() +{ + uint8_t tmp_byte = 0; + uint16_t tmp_len = 0; + + tts_hal_cs_low(); + + tts_hal_read( &tmp_byte, 1 ); + + if( tmp_byte == START_MESSAGE ) + { + tts_hal_read( ( uint8_t* )&_last_rsp, 2 ); + tmp_len |= _last_rsp.len[ 0 ]; + tmp_len |= _last_rsp.len[ 1 ] << 8; + tts_hal_read( ( uint8_t* )&_last_rsp + 2, tmp_len ); + + } else { + + wait( 0.005 ); + } + + tts_hal_cs_high(); +} + +void _write_req(bool boot) +{ + uint16_t cnt = 0; + uint8_t start = START_MESSAGE; + + cnt |= _last_req.len[ 0 ]; + cnt |= _last_req.len[ 1 ] << 8; + + tts_hal_cs_low(); + + + if(boot) // use for debug - displays the current buffer on serial + { + tts_hal_write( &start, 1, true ); + tts_hal_write( ( uint8_t* )&_last_req, cnt, true); + } + else + { + tts_hal_write( &start, 1, false ); + tts_hal_write( ( uint8_t* ) &_last_req, cnt, false ); + } + + tts_hal_cs_high(); + +} + +/****************************************************************************** +* Public Function Definitions +*******************************************************************************/ +void tts_hw_init( void ) +{ + tts_hal_init(); + + _ticker_f = false; + _ticker = 0; + + _last_req.idx[ 0 ] = 0; + _last_req.idx[ 1 ] = 0; + _last_req.len[ 0 ] = 0; + _last_req.len[ 1 ] = 0; + memset( _last_req.payload, 0, MAIN_MESSAGE_MAX ); + + _last_rsp.idx[ 0 ] = 255; + _last_rsp.idx[ 1 ] = 255; + _last_rsp.len[ 0 ] = 0; + _last_rsp.len[ 1 ] = 0; + memset( _last_rsp.payload, 0, RESP_MESSAGE_MAX ); +} + +void tts_tick_isr() +{ + _ticker++; + + if( _ticker > 500 ) + _ticker_f == true; +} + +void tts_mute_cmd( bool cmd ) +{ + if( cmd ) + tts_hal_mut_high(); + else + tts_hal_mut_low(); +} + +void tts_parse_req( uint16_t req, + uint8_t *payload, + uint16_t pl_len ) +{ + uint8_t *pl = payload; + uint16_t i = 0; + uint16_t tmp = pl_len + 4; + + _last_req.len[ 0 ] = tmp & 0x00FF; + _last_req.len[ 1 ] = ( tmp & 0xFF00 ) >> 8; + _last_req.idx[ 0 ] = req & 0x00FF; + _last_req.idx[ 1 ] = ( req & 0xFF00 ) >> 8; + _last_rsp.idx[ 0 ] = 0xFF; + _last_rsp.idx[ 1 ] = 0xFF; + + if ( payload != NULL ) + { + while ( pl_len-- ) + _last_req.payload[ i++ ] = *( pl++ ); + + } + + _write_req(true); +} + +void tts_parse_boot_img( const uint8_t *payload, + uint16_t pl_len ) +{ + uint16_t i = 0; + uint16_t tmp = pl_len + 0x04; + + _last_req.len[ 0 ] = tmp & 0x00FF; + _last_req.len[ 1 ] = ( tmp & 0xFF00 ) >> 8; + _last_req.idx[ 0 ] = 0x00; + _last_req.idx[ 1 ] = 0x10; + _last_rsp.idx[ 0 ] = 0xFF; + _last_rsp.idx[ 1 ] = 0xFF; + + if ( payload != NULL ) + { + while ( pl_len-- ) + _last_req.payload[ i++ ] = payload[ i ]; + } + + _write_req(true); +} + +void tts_parse_speak_req( uint16_t req, + uint8_t flush_en, + char *word, + uint16_t word_len ) +{ + char *ptr = word; + uint16_t i = 1; + uint16_t tmp = word_len; + + word_len += 7; + + _last_req.len[ 0 ] = word_len & 0x00FF; + _last_req.len[ 1 ] = ( word_len & 0xFF00 ) >> 8; + _last_req.idx[ 0 ] = req & 0x00FF; + _last_req.idx[ 1 ] = ( req & 0xFF00 ) >> 8; + _last_rsp.idx[ 0 ] = 0xFF; + _last_rsp.idx[ 1 ] = 0xFF; + + if( flush_en ) + { + _last_req.payload[ 0 ] = 1; + + } else { + + _last_req.payload[ 0 ] = 0; + } + + while( tmp-- ) + _last_req.payload[ i++ ] = *( ptr++ ); + + _last_req.payload[ i++ ] = 0x20; + _last_req.payload[ i ] = 0x00; + + _write_req(true); +} + +void tts_get_resp() +{ + // only read if ready + if( tts_hal_msg_rdy() ) + { + _read_rsp(); + } +} + +bool tts_rsp_chk( uint16_t idx ) +{ + uint16_t tmp = 0; + + tmp |= _last_rsp.idx[ 0 ]; + tmp |= _last_rsp.idx[ 1 ] << 8; + + return ( idx == tmp ) ? true : false; +} + +uint16_t tts_rsp_idx() +{ + uint16_t tmp = 0; + + tmp |= _last_rsp.idx[ 0 ]; + tmp |= _last_rsp.idx[ 1 ] << 8; + + return tmp; +} + +void tts_rsp_data( uint8_t *buffer ) +{ + uint8_t *bfr = buffer; + uint16_t cnt = 0; + uint8_t *ptr = _last_rsp.payload; + + cnt |= _last_rsp.len[ 0 ]; + cnt |= _last_rsp.len[ 1 ] << 8; + cnt -= 4; + + while( cnt-- ) + *( bfr++ ) = *( ptr++ ); +} + +/*************** END OF FUNCTIONS *********************************************/ \ No newline at end of file