VZTECH / Mbed 2 deprecated main_src

Modularizando o src

Dependencies:   EALib EthernetInterface_vz mbed-rtos mbed

Fork of header_main_colinas_V0-20-09-14 by VZTECH

main.cpp@84:b64f0e3b283e, 2015-01-02 (annotated)

Committer:
klauss
Date:
Fri Jan 02 19:17:19 2015 +0000
Revision:
84:b64f0e3b283e
Parent:
83:b8a1d8fdeaeb
Child:
85:b6f2dc1d0f4f
wdt++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
klauss 74:81c47fff88a5 1 #include "telemetry.h"
klauss 74:81c47fff88a5 2 #include "eth.h"
klauss 74:81c47fff88a5 3 #include "bits.h"
klauss 74:81c47fff88a5 4 #include "UART3Interrupt.h" // for RXBuffer[ __CB_BUFFER_SIZE__ ];
klauss 74:81c47fff88a5 5 #include "utils.h"
klauss 74:81c47fff88a5 6 #include "parallelcpld.h"
klauss 74:81c47fff88a5 7 #include "debug.h"
klauss 74:81c47fff88a5 8 #include "flood.h"
klauss 74:81c47fff88a5 9 #include "bootloader_cbx.h"
klauss 74:81c47fff88a5 10 #include "call_manager.h"
klauss 74:81c47fff88a5 11 #include "call_box_manager.h"
klauss 74:81c47fff88a5 12 #include "sip_manager.h"
klauss 74:81c47fff88a5 13 #include "shared_variables.h"
klauss 74:81c47fff88a5 14 #include "prompt.h"
klauss 0:4d17cd9c8f9d 15 #include "configs.h"
klauss 0:4d17cd9c8f9d 16
klauss 0:4d17cd9c8f9d 17 int main(){
klauss 81:3656f00ab3db 18 init_wdt();
klauss 79:9bc12aa305a9 19
klauss 81:3656f00ab3db 20 config_lpc();
klauss 79:9bc12aa305a9 21
klauss 0:4d17cd9c8f9d 22 start_cpld();
klauss 79:9bc12aa305a9 23
klauss 43:455522f98de5 24 init_fsystem();
klauss 43:455522f98de5 25
klauss 78:1353744f01e1 26 short int eth_status = __init_eth__();
klauss 8:e3bfe62a477e 27 if( eth_status ){
klauss 48:195c97f12e8e 28 send_msg("Cannot connect to eth\n\r");
klauss 43:455522f98de5 29 }else{
klauss 81:3656f00ab3db 30 send_msg("******* Connection eth - ok *******");
klauss 78:1353744f01e1 31 init_prompt_eth();
klauss 82:f55d13babca0 32 init_external_wdt()
klauss 8:e3bfe62a477e 33 }
klauss 78:1353744f01e1 34
klauss 78:1353744f01e1 35 Timer sync_timer, led_sync_timer;
klauss 78:1353744f01e1 36 sync_timer.start(), led_sync_timer.start();
klauss 0:4d17cd9c8f9d 37
klauss 0:4d17cd9c8f9d 38 /* representa ramal do call box */
klauss 0:4d17cd9c8f9d 39 int ext = 0;
klauss 0:4d17cd9c8f9d 40
klauss 0:4d17cd9c8f9d 41 /* representa porta do call box */
klauss 78:1353744f01e1 42 int port = 0;
klauss 78:1353744f01e1 43
klauss 0:4d17cd9c8f9d 44 /* buffer para onde se copia os dados vindos do cb para tratameno interno */
klauss 0:4d17cd9c8f9d 45 uint8_t buffer[ __CB_BUFFER_SIZE__ ];
klauss 0:4d17cd9c8f9d 46
klauss 0:4d17cd9c8f9d 47 /* buffer de escrita do pacote de saida que sera enviado pro cb / servidor */
klauss 0:4d17cd9c8f9d 48 uint8_t write_buffer[ __CB_BUFFER_SIZE__ ];
klauss 0:4d17cd9c8f9d 49
klauss 0:4d17cd9c8f9d 50 /* ponteiro que aponta para os dados vindo do CPLD */
klauss 0:4d17cd9c8f9d 51 uint8_t * buffer_from_cb_ptr = ( uint8_t * )RXBuffer;
klauss 0:4d17cd9c8f9d 52
klauss 62:07e5bdc9f8f7 53 /* Armazena o ultimo pacote recebido dos CBx */
klauss 62:07e5bdc9f8f7 54 uint8_t cb_rx_buffer[ __CB_BUFFER_SIZE__ ];
klauss 62:07e5bdc9f8f7 55
klauss 0:4d17cd9c8f9d 56 /* referencia para os dados contidos no pacote, sem o header */
klauss 0:4d17cd9c8f9d 57 uint8_t * data = NULL;
klauss 0:4d17cd9c8f9d 58
klauss 0:4d17cd9c8f9d 59 /* gerencia o tipo do pacote para providenciar tratamento adequado */
klauss 0:4d17cd9c8f9d 60 volatile uint8_t type = __DO_NOTHING__;
klauss 0:4d17cd9c8f9d 61
klauss 0:4d17cd9c8f9d 62 /* representa a lista dos Call Boxes atualmente reconhecidos pela cabeceira */
klauss 0:4d17cd9c8f9d 63 Vector * v_cb = new Vector();
klauss 0:4d17cd9c8f9d 64
klauss 0:4d17cd9c8f9d 65 /* representa a lista de ligacoes ativas na cabeceira */
klauss 0:4d17cd9c8f9d 66 Vector * v_call = new Vector();
klauss 0:4d17cd9c8f9d 67
klauss 0:4d17cd9c8f9d 68 /* gerencia a distribuicao de timeslice para os call boxes */
klauss 0:4d17cd9c8f9d 69 Timeslice * ts = new Timeslice();
klauss 78:1353744f01e1 70
klauss 81:3656f00ab3db 71 /* instancia o vetor de call boxes // calls */
klauss 0:4d17cd9c8f9d 72 if( v_cb == NULL ){
klauss 0:4d17cd9c8f9d 73 while( v_cb == NULL ){
klauss 0:4d17cd9c8f9d 74 Vector * v_cb = new Vector();
klauss 78:1353744f01e1 75 if( sync_timer.read() > 5 ){
klauss 48:195c97f12e8e 76 send_msg("Erro ao alocar o vetor de CBx");
klauss 78:1353744f01e1 77 sync_timer.reset();
klauss 0:4d17cd9c8f9d 78 }
klauss 0:4d17cd9c8f9d 79 }
klauss 0:4d17cd9c8f9d 80 }else if( v_call == NULL ){
klauss 0:4d17cd9c8f9d 81 while( v_call == NULL ){
klauss 0:4d17cd9c8f9d 82 Vector * v_call = new Vector();
klauss 78:1353744f01e1 83 if( sync_timer.read() > 5 ){
klauss 48:195c97f12e8e 84 send_msg("Erro ao alocar o vetor de Calls");
klauss 78:1353744f01e1 85 sync_timer.reset();
klauss 0:4d17cd9c8f9d 86 }
klauss 0:4d17cd9c8f9d 87 }
klauss 0:4d17cd9c8f9d 88 }
klauss 63:0d95da692bb4 89
klauss 63:0d95da692bb4 90 for( register uint16_t i = 0; i < __CB_BUFFER_SIZE__; i++ ){
klauss 63:0d95da692bb4 91 cb_rx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 92 cb_tx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 93 }
klauss 63:0d95da692bb4 94
klauss 0:4d17cd9c8f9d 95 reset_leds();
klauss 78:1353744f01e1 96
klauss 33:735fd60e96d8 97 udp_timer.start();
klauss 68:b54993674190 98
klauss 68:b54993674190 99 init_telemetry_handler();
klauss 68:b54993674190 100
klauss 81:3656f00ab3db 101 init_ranges();
klauss 81:3656f00ab3db 102
klauss 80:61d61c9eb75c 103 init_refresh();
klauss 80:61d61c9eb75c 104
klauss 78:1353744f01e1 105 init_aging();
klauss 78:1353744f01e1 106
klauss 81:3656f00ab3db 107 //init_invite_pgk_retry_manager();
klauss 81:3656f00ab3db 108
klauss 81:3656f00ab3db 109 //void init_bye_pgk_retry_manager();
klauss 62:07e5bdc9f8f7 110 static uint8_t count = 0;
klauss 78:1353744f01e1 111
klauss 78:1353744f01e1 112 short int bl_ret = init_bl_handler();
klauss 67:cdedc64d9921 113 if( dbl ) send_msg("Valor de retorno do bl_habdler = %d", bl_ret );
klauss 67:cdedc64d9921 114
klauss 78:1353744f01e1 115 uint8_t max_registered_cbx = 0;
klauss 78:1353744f01e1 116
klauss 81:3656f00ab3db 117 bool wake_all = false;
klauss 81:3656f00ab3db 118
klauss 81:3656f00ab3db 119 uint16_t pkg_wdt = RX_CB_IDLE;
klauss 81:3656f00ab3db 120 uint16_t eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 68:b54993674190 121
klauss 83:b8a1d8fdeaeb 122 uint32_t uptime = 0;
klauss 83:b8a1d8fdeaeb 123
klauss 68:b54993674190 124 send_msg("Ready");
klauss 68:b54993674190 125
klauss 78:1353744f01e1 126 /*------------------------------------------ main loop ---------------------------------------------------------------*/
Cola 21:0bd688722e81 127 while( true ){
klauss 78:1353744f01e1 128 if( v_cb->size() > max_registered_cbx ) max_registered_cbx = v_cb->size();
klauss 78:1353744f01e1 129
klauss 78:1353744f01e1 130 if( sync_timer.read() > 5 ){
klauss 78:1353744f01e1 131 sync_timer.reset();
klauss 78:1353744f01e1 132
klauss 78:1353744f01e1 133 if( debug_cks == true ){
klauss 81:3656f00ab3db 134 pcks_s = true;
klauss 78:1353744f01e1 135 }
klauss 78:1353744f01e1 136
klauss 78:1353744f01e1 137 if( debug_alive == true ){
klauss 81:3656f00ab3db 138 pshowcb = true;
klauss 78:1353744f01e1 139 }
klauss 81:3656f00ab3db 140
klauss 81:3656f00ab3db 141 if( !( ++count % 15 ) ){
klauss 78:1353744f01e1 142 if( eth_status ){
klauss 78:1353744f01e1 143 eth_status = __init_eth__();
klauss 78:1353744f01e1 144 if( eth_status ){
klauss 78:1353744f01e1 145 if( debug_main ) debug_msg("Cannot connect to eth");
klauss 78:1353744f01e1 146 }else{
klauss 78:1353744f01e1 147 if( debug_main ) debug_msg("Connection eth - ok");
klauss 78:1353744f01e1 148 init_prompt_eth();
klauss 82:f55d13babca0 149 init_external_wdt()
klauss 78:1353744f01e1 150 }
klauss 78:1353744f01e1 151 }
klauss 78:1353744f01e1 152 }
klauss 81:3656f00ab3db 153 //35 sec.
klauss 81:3656f00ab3db 154 if( ( count > 7 ) && ( wake_all == false ) ){
klauss 81:3656f00ab3db 155 wake_all = true;
klauss 78:1353744f01e1 156 if( debug_wake == true ) send_msg( "Time to wake" );
klauss 78:1353744f01e1 157 }
klauss 78:1353744f01e1 158
klauss 81:3656f00ab3db 159 if( wake_all ) if( v_call->size() == 0 ) wake_all_up( v_cb, buffer, write_buffer );
klauss 78:1353744f01e1 160 }
klauss 78:1353744f01e1 161
klauss 68:b54993674190 162 //FIXMEj colocar uma condicao aqui caso necessario pra nao comprometer ligacoes ...
klauss 35:96885a7931f0 163 prompt_process( NULL );
klauss 63:0d95da692bb4 164
klauss 63:0d95da692bb4 165 if( r_stats ){
klauss 63:0d95da692bb4 166 boot_counter = 0;
klauss 63:0d95da692bb4 167 registry_counter = 0;
klauss 63:0d95da692bb4 168 invite_counter = 0;
klauss 63:0d95da692bb4 169 audio_counter = 0;
klauss 63:0d95da692bb4 170 telemetry_counter = 0;
klauss 63:0d95da692bb4 171 cb_bye_counter = 0;
klauss 63:0d95da692bb4 172 prompt_counter = 0;
klauss 63:0d95da692bb4 173 flood_counter = 0;
klauss 67:cdedc64d9921 174 bootloader_cbx_counter = 0;
klauss 63:0d95da692bb4 175 r_stats = false;
klauss 63:0d95da692bb4 176 stats = true;
klauss 63:0d95da692bb4 177 }
klauss 81:3656f00ab3db 178
klauss 63:0d95da692bb4 179 if( stats ){
klauss 63:0d95da692bb4 180 char str[ 200 ];
klauss 81:3656f00ab3db 181 snprintf( str, 200, "\n\rReceived Pkgs::\n\r Boot :: %u\n\r Registry :: %u\n\r Ivite :: %u\n\r Audio :: %u\n\r Telemetry :: %u\n\r Cb_bye :: %u\n\r Prompt :: %u\n\r Flood :: %u\n\r Bootloader_cbx :: %u\n\r",
klauss 67:cdedc64d9921 182 boot_counter, registry_counter, invite_counter, audio_counter, telemetry_counter, cb_bye_counter, prompt_counter, flood_counter, bootloader_cbx_counter );
klauss 63:0d95da692bb4 183 send_msg( str );
klauss 63:0d95da692bb4 184 stats =false;
klauss 63:0d95da692bb4 185 }
klauss 63:0d95da692bb4 186
klauss 62:07e5bdc9f8f7 187 if( list ){
klauss 78:1353744f01e1 188 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 78:1353744f01e1 189
klauss 78:1353744f01e1 190 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 78:1353744f01e1 191
klauss 78:1353744f01e1 192 if( min_ext % 2 ) missed_cb++;
klauss 78:1353744f01e1 193
klauss 78:1353744f01e1 194 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 78:1353744f01e1 195
klauss 78:1353744f01e1 196 send_msg("Registered %d[ %d ] CBx ( %d - %d ) - Missed %d -- Remain_timeslices :: %d :: v_call->size() :: %d", v_cb->size(), max_registered_cbx, min_ext, max_ext, missed_cb, ts->remain_timeslices(), v_call->size() );
klauss 78:1353744f01e1 197 if( v_cb->size() == 1 ){
klauss 78:1353744f01e1 198 send_msg(" %d ", ( ( Call_Box * )v_cb->get_element( 0 ) )->get_ext() );
klauss 78:1353744f01e1 199 }else if( v_cb->size() > 1 ){
klauss 62:07e5bdc9f8f7 200 char str[ 1024 ];
klauss 78:1353744f01e1 201 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 62:07e5bdc9f8f7 202 register int i = 0;
klauss 62:07e5bdc9f8f7 203 for( ; i < v_cb->size(); i++ ){
klauss 78:1353744f01e1 204 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 62:07e5bdc9f8f7 205 }
klauss 62:07e5bdc9f8f7 206
klauss 62:07e5bdc9f8f7 207 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 62:07e5bdc9f8f7 208
klauss 62:07e5bdc9f8f7 209 char aux[ 16 ];
klauss 78:1353744f01e1 210 strcpy( str, "\r\n> " );
klauss 62:07e5bdc9f8f7 211 for( i = 0; i < v_cb->size() - 1; i++ ){
klauss 62:07e5bdc9f8f7 212 sprintf( aux, "%i, ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 213 strcat( str, aux );
klauss 78:1353744f01e1 214 if( ( i != 0 ) && !( ( i + 1 ) % 16 ) ) strcat( str, "\r\n> " );
klauss 62:07e5bdc9f8f7 215 }
klauss 62:07e5bdc9f8f7 216 sprintf( aux, "%i ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 217 strcat( str, aux );
klauss 62:07e5bdc9f8f7 218 send_msg( "%s", str );
klauss 62:07e5bdc9f8f7 219 }
klauss 62:07e5bdc9f8f7 220 list = false;
klauss 62:07e5bdc9f8f7 221 }
klauss 62:07e5bdc9f8f7 222
klauss 81:3656f00ab3db 223 if( long_list ){
klauss 81:3656f00ab3db 224 //FIXME implementar um algoritmo que me mostre o timeout de cada cbx do lado da linha, desse.
klauss 81:3656f00ab3db 225 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 81:3656f00ab3db 226
klauss 81:3656f00ab3db 227 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 81:3656f00ab3db 228
klauss 81:3656f00ab3db 229 if( min_ext % 2 ) missed_cb++;
klauss 81:3656f00ab3db 230
klauss 81:3656f00ab3db 231 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 81:3656f00ab3db 232
klauss 81:3656f00ab3db 233 send_msg("Registered %d[ %d ] CBx ( %d - %d ) - Missed %d -- Remain_timeslices :: %d :: v_call->size() :: %d", v_cb->size(), max_registered_cbx, min_ext, max_ext, missed_cb, ts->remain_timeslices(), v_call->size() );
klauss 81:3656f00ab3db 234 if( v_cb->size() == 1 ){
klauss 81:3656f00ab3db 235 send_msg(" %d ", ( ( Call_Box * )v_cb->get_element( 0 ) )->get_ext() );
klauss 81:3656f00ab3db 236 }else if( v_cb->size() > 1 ){
klauss 81:3656f00ab3db 237 char str[ 1024 ];
klauss 81:3656f00ab3db 238 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 81:3656f00ab3db 239 register int i = 0;
klauss 81:3656f00ab3db 240 for( ; i < ( v_cb->size() * 2 ); i += 2 ){
klauss 81:3656f00ab3db 241 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 81:3656f00ab3db 242 ext_list[ i + 1 ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_elapsed_time();
klauss 81:3656f00ab3db 243 }
klauss 81:3656f00ab3db 244
klauss 81:3656f00ab3db 245 qsort( ext_list, v_cb->size(), sizeof( int ) * 2, ls_comp );
Cola 24:270b436a1bb0 246
klauss 81:3656f00ab3db 247 char aux[ 16 ];
klauss 81:3656f00ab3db 248 strcpy( str, "\r\n> " );
klauss 81:3656f00ab3db 249 for( i = 0; i < ( v_cb->size() * 2 ) - 2; i++ ){
klauss 81:3656f00ab3db 250 sprintf( aux, "%i - %i,", ext_list[ i ], ext_list[ i + 1 ] );
klauss 81:3656f00ab3db 251 strcat( str, aux );
klauss 81:3656f00ab3db 252 strcat( str, "\r\n> " );
klauss 81:3656f00ab3db 253 }
klauss 81:3656f00ab3db 254 sprintf( aux, "%i - %i,", ext_list[ i ], ext_list[ i + 1 ] );
klauss 81:3656f00ab3db 255 strcat( str, aux );
klauss 81:3656f00ab3db 256 send_msg( "%s", str );
klauss 81:3656f00ab3db 257 }
klauss 81:3656f00ab3db 258 list = false;
klauss 52:12930cef17c4 259 }
klauss 52:12930cef17c4 260
klauss 78:1353744f01e1 261 if( pshowcb == true ){
klauss 78:1353744f01e1 262 send_msg("Registered %d ( of %d ) CBx ( %d - %d ) -- Remain_timeslices :: %d :: v_call->size() :: %d", v_cb->size(), max_registered_cbx, min_ext, max_ext, ts->remain_timeslices(), v_call->size() );
Cola 24:270b436a1bb0 263 for( register uint8_t i = 0; i < v_cb->size(); i++ ){
klauss 30:8dfb6d8de53d 264 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 78:1353744f01e1 265 char cb_status[ 32 ];
klauss 78:1353744f01e1 266 char cb_sip_status[ 32 ];
klauss 78:1353744f01e1 267 switch( cb->status ){
klauss 78:1353744f01e1 268 case cb_idle : { strcpy( cb_status, "cb_idle" ); break; }
klauss 78:1353744f01e1 269 case cb_ringing : { strcpy( cb_status, "cb_ringing" ); break; }
klauss 78:1353744f01e1 270 case cb_trying : { strcpy( cb_status,"cb_trying" ); break; }
klauss 78:1353744f01e1 271 case cb_on_call : { strcpy( cb_status, "cb_on_call" ); break; }
klauss 78:1353744f01e1 272 case cb_busy : { strcpy( cb_status, "cb_busy" ); break; }
klauss 78:1353744f01e1 273 case cb_denied : { strcpy( cb_status, "cb_denied" ); break; }
klauss 78:1353744f01e1 274 }
klauss 78:1353744f01e1 275 switch( cb->sip->status ){
klauss 78:1353744f01e1 276 case sip_idle : { strcpy( cb_sip_status, "sip_idle" ); break; }
klauss 78:1353744f01e1 277 case sip_waiting_trying : { strcpy( cb_sip_status, "sip_waiting_trying" ); break; }
klauss 78:1353744f01e1 278 case sip_trying : { strcpy( cb_sip_status, "sip_trying" ); break; }
klauss 78:1353744f01e1 279 case sip_ringing : { strcpy( cb_sip_status, "sip_ringing" ); break; }
klauss 78:1353744f01e1 280 case sip_busy : { strcpy( cb_sip_status, "sip_busy" ); break; }
klauss 78:1353744f01e1 281 case sip_ok : { strcpy( cb_sip_status, "sip_ok" ); break; }
klauss 78:1353744f01e1 282 case sip_on_call : { strcpy( cb_sip_status, "sip_on_call" ); break; }
klauss 78:1353744f01e1 283 case sip_denied : { strcpy( cb_sip_status, "sip_denied" ); break; }
klauss 78:1353744f01e1 284 }
klauss 78:1353744f01e1 285 char cbx_to_string[ 254 ];
klauss 78:1353744f01e1 286 char aux[ 16 ];
klauss 78:1353744f01e1 287 strcpy( cbx_to_string, "Ext :: " );
klauss 78:1353744f01e1 288 itoa( cb->get_ext(), aux , 10 );
klauss 78:1353744f01e1 289 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 290 strcat( cbx_to_string, " :: Status -- " );
klauss 78:1353744f01e1 291 strcat( cbx_to_string, cb_status );
klauss 78:1353744f01e1 292 strcat( cbx_to_string, " - " );
klauss 78:1353744f01e1 293 strcat( cbx_to_string, cb_sip_status );
klauss 78:1353744f01e1 294 if( cb->get_timeslice() != 0 ){
klauss 78:1353744f01e1 295 strcat( cbx_to_string, " -- on TimeSlice :: " );
klauss 78:1353744f01e1 296 itoa( cb->get_timeslice(), aux , 10 );
klauss 78:1353744f01e1 297 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 298 }
klauss 78:1353744f01e1 299 send_msg( cbx_to_string );
klauss 48:195c97f12e8e 300 }
klauss 78:1353744f01e1 301 pshowcb = false;
klauss 48:195c97f12e8e 302 }
Cola 22:d2a4b5939115 303
klauss 81:3656f00ab3db 304 if( pflood == true ) flood();
klauss 81:3656f00ab3db 305
klauss 81:3656f00ab3db 306 if( debug_eth ){
klauss 81:3656f00ab3db 307 debug_eth = false;
klauss 81:3656f00ab3db 308 send_msg("Eth status %s", ( eth_status == 0 ) ? "Connected" : "Disconnected" );
klauss 81:3656f00ab3db 309 }
klauss 30:8dfb6d8de53d 310
klauss 0:4d17cd9c8f9d 311 if( status != __WAITING__ ){
klauss 81:3656f00ab3db 312 pkg_wdt = RX_CB_IDLE;
klauss 74:81c47fff88a5 313 xmemcpy( cb_rx_buffer, buffer_from_cb_ptr, __CB_BUFFER_SIZE__ );
klauss 0:4d17cd9c8f9d 314 status = __WAITING__;
klauss 81:3656f00ab3db 315 missed_pkg--;
klauss 78:1353744f01e1 316 xmemcpy( buffer, cb_rx_buffer, __CB_BUFFER_SIZE__ );
klauss 81:3656f00ab3db 317
klauss 81:3656f00ab3db 318 if( debug_cpld ){
klauss 81:3656f00ab3db 319 rx = true;
klauss 81:3656f00ab3db 320 tx = true;
klauss 81:3656f00ab3db 321 }
klauss 81:3656f00ab3db 322
klauss 81:3656f00ab3db 323 if( rx ){
klauss 81:3656f00ab3db 324 char str[ 1024 ];
klauss 81:3656f00ab3db 325 strcpy( str, "RX :: \n\r " );
klauss 81:3656f00ab3db 326 for( register uint16_t i = 0; i < __CB_BUFFER_SIZE__; i++ ){
klauss 81:3656f00ab3db 327 char tmp[ 16 ];
klauss 81:3656f00ab3db 328 strcat( str, itoa( cb_rx_buffer[ i ], tmp, 16 ) );
klauss 81:3656f00ab3db 329 if( ( i != 0 ) && !( ( i + 1 ) % 50 ) ) strcat( str, "\n\r " );
klauss 81:3656f00ab3db 330
klauss 81:3656f00ab3db 331 else strcat( str, " " );
klauss 81:3656f00ab3db 332 }
klauss 81:3656f00ab3db 333 send_msg( "%s", str );
klauss 81:3656f00ab3db 334 rx = false;
klauss 81:3656f00ab3db 335 }
klauss 81:3656f00ab3db 336
klauss 34:f19d9735428e 337 data = __parse_vz_pkg__( &ext, &port, &type, buffer );
klauss 0:4d17cd9c8f9d 338
klauss 78:1353744f01e1 339 if( data != NULL ){
klauss 78:1353744f01e1 340 if( min_ext == 0 ) min_ext = ext;
klauss 78:1353744f01e1 341
klauss 78:1353744f01e1 342 if( ext > max_ext ) max_ext = ext;
klauss 78:1353744f01e1 343
klauss 78:1353744f01e1 344 if( ext < min_ext ) min_ext = ext;
klauss 78:1353744f01e1 345
klauss 78:1353744f01e1 346 if( debug_cb_rx == true ) debug_msg("Pkg from CBx :: %d -- Type :: %d", ext, type );
klauss 78:1353744f01e1 347
klauss 7:019b08223b87 348 if( type != __AUDIO__ ){
klauss 0:4d17cd9c8f9d 349 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 0:4d17cd9c8f9d 350 if( cb != NULL ){
klauss 78:1353744f01e1 351 if( ( data[ 0 ] & BIT7 ) >= BIT7 ){
klauss 78:1353744f01e1 352 if( type == __BOOT__ ){
klauss 78:1353744f01e1 353 send2callboxes( __build_cb_package__( ext, port, __REGISTRY__,
klauss 78:1353744f01e1 354 ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 81:3656f00ab3db 355 }else if( ( data[ 0 ] & BIT7 ) == BIT7 ){
klauss 81:3656f00ab3db 356 if( debug_main ) debug_msg("Received ack pkg with seq_num %d", data[ 0 ] );
klauss 81:3656f00ab3db 357 //algum motivo pra sempre receber alguma coisa com o type == 7 ???
klauss 81:3656f00ab3db 358 if( type == 0x07 ){
klauss 81:3656f00ab3db 359 char str[ 1024 ];
klauss 81:3656f00ab3db 360 strcpy( str, "RX :: \n\r " );
klauss 81:3656f00ab3db 361 for( register uint16_t i = 0; i < __CB_BUFFER_SIZE__; i++ ){
klauss 81:3656f00ab3db 362 char tmp[ 16 ];
klauss 81:3656f00ab3db 363 strcat( str, itoa( cb_rx_buffer[ i ], tmp, 16 ) );
klauss 81:3656f00ab3db 364 if( ( i != 0 ) && !( ( i + 1 ) % 50 ) ) strcat( str, "\n\r " );
klauss 81:3656f00ab3db 365
klauss 81:3656f00ab3db 366 else strcat( str, " " );
klauss 81:3656f00ab3db 367 }
klauss 81:3656f00ab3db 368 send_msg( "%s", str );
klauss 81:3656f00ab3db 369 rx = false;
klauss 81:3656f00ab3db 370 }
klauss 81:3656f00ab3db 371 switch( type ){
klauss 81:3656f00ab3db 372 case __INVITE__ : {
klauss 81:3656f00ab3db 373 if( debug_main || debug_invite ) debug_msg("Invite Ack from %d on msg_id %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 374 cb->set_invite_response_ok();
klauss 81:3656f00ab3db 375 break;
klauss 81:3656f00ab3db 376 }
klauss 81:3656f00ab3db 377 case __CB_BYE__ : {
klauss 81:3656f00ab3db 378 if( debug_main || debug_invite ) debug_msg("BYE Ack from %d on msg_id %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 379 cb->set_bye_response_ok();
klauss 81:3656f00ab3db 380 break;
klauss 81:3656f00ab3db 381 }
klauss 81:3656f00ab3db 382 case __REGISTRY__ : {
klauss 81:3656f00ab3db 383 if( debug_main || debug_aging ) debug_msg("Registry ACK from %d in pkg :: %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 384 break;
klauss 81:3656f00ab3db 385 }
klauss 81:3656f00ab3db 386 default : {
klauss 81:3656f00ab3db 387 if( debug_main || debug_aging ) debug_msg("ACK from %d in pkg :: %d :: type %d", ext, cb->get_msg_id(), type );
klauss 81:3656f00ab3db 388 }
klauss 81:3656f00ab3db 389 }
klauss 82:f55d13babca0 390 if( type != __REGISTRY__ && type != __CB_BYE__ ) type = __DO_NOTHING__;
klauss 82:f55d13babca0 391 //if( type != __REGISTRY__ ) type = __DO_NOTHING__;
klauss 0:4d17cd9c8f9d 392 }
klauss 0:4d17cd9c8f9d 393 }
klauss 0:4d17cd9c8f9d 394 }
klauss 0:4d17cd9c8f9d 395 }
klauss 0:4d17cd9c8f9d 396 }else type = __DO_NOTHING__;
klauss 0:4d17cd9c8f9d 397 }
klauss 78:1353744f01e1 398
klauss 81:3656f00ab3db 399 if( main_test == true ){
klauss 82:f55d13babca0 400 static int next_value = 5010;
klauss 82:f55d13babca0 401 Call_Box * cb = new Call_Box( next_value, next_value++ );
klauss 82:f55d13babca0 402 v_cb->add( cb );
klauss 82:f55d13babca0 403 cb->cb_set_status( cb_on_call );
klauss 82:f55d13babca0 404 cb->set_timeslice( ts->get_timeslice() );
klauss 82:f55d13babca0 405
klauss 81:3656f00ab3db 406 // cb = new Call_Box( 5011, 5011 );
klauss 81:3656f00ab3db 407 // v_cb->add( cb );
klauss 82:f55d13babca0 408
klauss 81:3656f00ab3db 409 main_test = false;
klauss 81:3656f00ab3db 410 send_msg("Missed_Pkg :: %d ::", missed_pkg );
klauss 82:f55d13babca0 411
klauss 81:3656f00ab3db 412 }
klauss 81:3656f00ab3db 413
klauss 81:3656f00ab3db 414 if( reset_cks == true ){
klauss 81:3656f00ab3db 415 pkg_cksok = 0;
klauss 81:3656f00ab3db 416 pkg_ckserr = 0;
klauss 81:3656f00ab3db 417 reset_cks = false;
klauss 81:3656f00ab3db 418 pcks_s = true;
klauss 81:3656f00ab3db 419 }
klauss 81:3656f00ab3db 420
klauss 81:3656f00ab3db 421 if( pcks_s == true ){
klauss 81:3656f00ab3db 422 send_msg("PKG_CSK OK: %d :: PKG_CSK ERR: %d :: PKG_ZERO: %d :: Out_of_range: %d :: Missed_Pkg :: %d", pkg_cksok, pkg_ckserr, pkg_zero, out_of_range, missed_pkg );
klauss 81:3656f00ab3db 423 pcks_s = false;
klauss 81:3656f00ab3db 424 }
klauss 81:3656f00ab3db 425
klauss 78:1353744f01e1 426 if( led_sync_timer.read() > 1 ){
klauss 78:1353744f01e1 427 led_sync_timer.reset();
klauss 78:1353744f01e1 428 led3 = !led3;
klauss 78:1353744f01e1 429 CAB_LED = !CAB_LED;
klauss 78:1353744f01e1 430 }
klauss 78:1353744f01e1 431
klauss 0:4d17cd9c8f9d 432 switch( type ){
klauss 0:4d17cd9c8f9d 433 case __DO_NOTHING__ :{}
klauss 0:4d17cd9c8f9d 434 break;
klauss 0:4d17cd9c8f9d 435
klauss 0:4d17cd9c8f9d 436 case __CB_BYE__ : {
klauss 81:3656f00ab3db 437 //FIXME como mandar um BYE pro servidor ?
klauss 63:0d95da692bb4 438 cb_bye_counter++;
klauss 0:4d17cd9c8f9d 439 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 0:4d17cd9c8f9d 440 if( cb != NULL ){
klauss 81:3656f00ab3db 441 if( debug_invite || debug_main ) debug_msg("Received bye pkg with msg_id %d e pkg_id %d", cb->get_msg_id(), data[ 0 ] );
klauss 0:4d17cd9c8f9d 442 data[ 0 ] |= BIT7;
klauss 0:4d17cd9c8f9d 443 cb->set_msg_id( data[ 0 ] );
klauss 81:3656f00ab3db 444 if( debug_main || debug_invite ) debug_msg( "Request bye from CBx " );
klauss 81:3656f00ab3db 445 bool already_removed = true;
klauss 0:4d17cd9c8f9d 446 for( register uint8_t i = 0; i < v_call->size(); i++ ){
klauss 0:4d17cd9c8f9d 447 VZ_call * call = (VZ_call *)v_call->get_element( i );
klauss 0:4d17cd9c8f9d 448 if( call->get_cb_ext() == ext ){
klauss 81:3656f00ab3db 449 already_removed = false;
klauss 4:de46f0d9b14d 450 cb->send_bye();
klauss 78:1353744f01e1 451
klauss 0:4d17cd9c8f9d 452 ts->return_timeslice( cb->get_timeslice() );
klauss 0:4d17cd9c8f9d 453 cb->set_timeslice( 0x00 );
klauss 78:1353744f01e1 454 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 78:1353744f01e1 455
klauss 0:4d17cd9c8f9d 456 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 457 set_status( cb->sip->status, sip_idle );
klauss 78:1353744f01e1 458
klauss 81:3656f00ab3db 459 v_call->remove_element( i );
klauss 81:3656f00ab3db 460
klauss 74:81c47fff88a5 461 send2callboxes( __build_cb_package__( ext, port, __CB_BYE__,
klauss 0:4d17cd9c8f9d 462 ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 82:f55d13babca0 463
klauss 82:f55d13babca0 464 cb->set_msg_id( ( cb->get_msg_id() & ~BIT7 ) + 1 );
klauss 78:1353744f01e1 465
klauss 3:cd9148672e25 466 delete( call );
klauss 29:7246460b73f8 467 cb->re_start_timer();
klauss 0:4d17cd9c8f9d 468 }
klauss 0:4d17cd9c8f9d 469 }
klauss 82:f55d13babca0 470 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from vector call" );
klauss 82:f55d13babca0 471
klauss 82:f55d13babca0 472 //ok, mas nem sempre o cbx "entrou em call
klauss 82:f55d13babca0 473 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 82:f55d13babca0 474 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 82:f55d13babca0 475 if( cb->get_ext() == ext ) {
klauss 82:f55d13babca0 476 already_removed = true;
klauss 82:f55d13babca0 477 if( cb->get_status() != cb_idle ) {
klauss 82:f55d13babca0 478 already_removed = false;
klauss 82:f55d13babca0 479 cb->send_bye();
klauss 82:f55d13babca0 480
klauss 82:f55d13babca0 481 ts->return_timeslice( cb->get_timeslice() );
klauss 82:f55d13babca0 482 cb->set_timeslice( 0x00 );
klauss 82:f55d13babca0 483 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 82:f55d13babca0 484
klauss 82:f55d13babca0 485 set_status( cb->status, cb_idle );
klauss 82:f55d13babca0 486 set_status( cb->sip->status, sip_idle );
klauss 82:f55d13babca0 487
klauss 82:f55d13babca0 488 send2callboxes( __build_cb_package__( ext, port, __CB_BYE__,
klauss 82:f55d13babca0 489 ( char * )data, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 82:f55d13babca0 490
klauss 82:f55d13babca0 491 cb->set_msg_id( ( cb->get_msg_id() & ~BIT7 ) + 1 );
klauss 82:f55d13babca0 492
klauss 82:f55d13babca0 493 cb->re_start_timer();
klauss 82:f55d13babca0 494 }
klauss 82:f55d13babca0 495 }
klauss 82:f55d13babca0 496 }
klauss 82:f55d13babca0 497
klauss 82:f55d13babca0 498
klauss 82:f55d13babca0 499 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from inviting queue" );
klauss 81:3656f00ab3db 500
klauss 78:1353744f01e1 501 cb->registry();
klauss 81:3656f00ab3db 502 }else if( debug_invite || debug_main ) debug_msg("Bye from who ? %d", ext );
klauss 7:019b08223b87 503 }break;
klauss 7:019b08223b87 504
klauss 0:4d17cd9c8f9d 505 case __INVITE__ : {
klauss 63:0d95da692bb4 506 invite_counter++;
klauss 78:1353744f01e1 507 if( debug_invite ) debug_msg("Request Invite received from Cbx %i", ext);
klauss 0:4d17cd9c8f9d 508 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 0:4d17cd9c8f9d 509 if( cb == NULL ){
klauss 78:1353744f01e1 510 if( debug_main ) debug_msg( "Adding CBx :: %i", ext );
klauss 0:4d17cd9c8f9d 511 cb = new Call_Box( ext, port );
klauss 0:4d17cd9c8f9d 512 v_cb->add( cb );
klauss 0:4d17cd9c8f9d 513 }
klauss 78:1353744f01e1 514 cb->registry();
klauss 78:1353744f01e1 515 cb->set_msg_id( data[ 0 ] );
klauss 78:1353744f01e1 516 invite_handler( v_call, v_cb, ts, cb );
klauss 0:4d17cd9c8f9d 517 }break;
klauss 4:de46f0d9b14d 518 case __REGISTRY__ : {
klauss 63:0d95da692bb4 519 registry_counter++;
klauss 78:1353744f01e1 520 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 2:93bec7313ccc 521
klauss 78:1353744f01e1 522 if( cb == NULL ){
klauss 78:1353744f01e1 523 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 4:de46f0d9b14d 524 cb = new Call_Box( ext, port );
klauss 4:de46f0d9b14d 525 v_cb->add( cb );
klauss 30:8dfb6d8de53d 526 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 0:4d17cd9c8f9d 527 }
klauss 78:1353744f01e1 528 if( debug_main ) debug_msg("Registered %d - %d", ext, port );
klauss 78:1353744f01e1 529
klauss 4:de46f0d9b14d 530 cb->registry();
klauss 78:1353744f01e1 531
klauss 4:de46f0d9b14d 532 }break;
klauss 4:de46f0d9b14d 533 case __BOOT__ : {
klauss 63:0d95da692bb4 534 boot_counter++;
klauss 74:81c47fff88a5 535 send2callboxes( __build_cb_package__( ext, port, __REGISTRY__,
klauss 78:1353744f01e1 536 ( char * )data, data[ 0 ] | BIT7, __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 4:de46f0d9b14d 537 }break;
klauss 4:de46f0d9b14d 538 case __TELEMETRY__ : {
klauss 78:1353744f01e1 539 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 78:1353744f01e1 540 if( cb == NULL ){
klauss 78:1353744f01e1 541 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 78:1353744f01e1 542 cb = new Call_Box( ext, port );
klauss 78:1353744f01e1 543 v_cb->add( cb );
klauss 78:1353744f01e1 544 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 78:1353744f01e1 545 }
klauss 78:1353744f01e1 546 cb->registry();
klauss 83:b8a1d8fdeaeb 547 //FIXME mandar um pacote do tipo 2 pro cbx ?
klauss 63:0d95da692bb4 548 telemetry_counter++;
klauss 78:1353744f01e1 549 if( debug_telemetry ) send_msg("::Telemetry from %d - %d::", ext, port );
klauss 53:bb492a8f115a 550 build_telemetry_report( ext, port, ( char *)data );
klauss 4:de46f0d9b14d 551 }break;
klauss 36:728498a78e1e 552
klauss 67:cdedc64d9921 553 case __BOOTLOADER_CBX__ : {
klauss 67:cdedc64d9921 554 bootloader_cbx_counter++;
klauss 67:cdedc64d9921 555 int ret = bl_cbx_reply_to_eth( ext, ( char * )data );
klauss 67:cdedc64d9921 556 }break;
klauss 67:cdedc64d9921 557
klauss 36:728498a78e1e 558 case __PROMPT__ : {
klauss 78:1353744f01e1 559 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 78:1353744f01e1 560 if( cb == NULL ){
klauss 78:1353744f01e1 561 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 78:1353744f01e1 562 cb = new Call_Box( ext, port );
klauss 78:1353744f01e1 563 v_cb->add( cb );
klauss 78:1353744f01e1 564 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 48:195c97f12e8e 565 }
klauss 78:1353744f01e1 566
klauss 78:1353744f01e1 567 cb->registry();
klauss 48:195c97f12e8e 568
klauss 78:1353744f01e1 569 if( xstrmatch( ( uint8_t * )data, ( uint8_t * )"ping" ) ){
klauss 78:1353744f01e1 570 if( debug_ping ) send_msg( "Prompt pkg from ( %i, %i ) :: Ping", ext, port );
klauss 78:1353744f01e1 571 }else{
klauss 78:1353744f01e1 572 prompt_counter++;
klauss 78:1353744f01e1 573 //fixme isso nao poderia ser resolvido com um sendmsg ?
klauss 78:1353744f01e1 574 send_msg( "Prompt pkg from ( %i, %i ) ::", ext, port );
klauss 78:1353744f01e1 575 for( register uint8_t i = 0; i < 32; i++ ){
klauss 78:1353744f01e1 576 pc.printf("%c", data[ i ] );
klauss 78:1353744f01e1 577 if( i == 15 ) pc.printf( "\r\n" );
klauss 78:1353744f01e1 578 }
klauss 78:1353744f01e1 579 pc.printf("\n\r> ");
klauss 78:1353744f01e1 580
klauss 78:1353744f01e1 581 if( tcp_session ){
klauss 78:1353744f01e1 582 char aux[ __CB_BUFFER_SIZE__ + 3 ];
klauss 78:1353744f01e1 583 strncpy( aux, (char * )data, __CB_BUFFER_SIZE__ );
klauss 78:1353744f01e1 584 strcat( aux, "\n\r\0" );
klauss 78:1353744f01e1 585 tcp_client.send_all( ( char *)data, strlen( (char * )data ) );
klauss 78:1353744f01e1 586 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 78:1353744f01e1 587 }
klauss 48:195c97f12e8e 588 }
klauss 36:728498a78e1e 589 }break;
klauss 0:4d17cd9c8f9d 590 case __AUDIO__ : {
klauss 63:0d95da692bb4 591 audio_counter++;
klauss 78:1353744f01e1 592 VZ_call * call = __find_Call__( v_call, ext );
klauss 0:4d17cd9c8f9d 593 if( call != NULL ){
klauss 30:8dfb6d8de53d 594 char * pkg = call->build_eth_package( data + 2 );
klauss 0:4d17cd9c8f9d 595 call->send_message( pkg );
klauss 78:1353744f01e1 596 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 0:4d17cd9c8f9d 597 if( cb != NULL ) cb->reset_elapsed_time();
klauss 18:01a93677e40c 598 }else{
klauss 78:1353744f01e1 599 if( debug_main ) debug_msg("received missed package from CBx :: %i", ext );
klauss 0:4d17cd9c8f9d 600 }
klauss 0:4d17cd9c8f9d 601 }break;
klauss 9:ffa64f38ef9c 602 }// fim switch
klauss 81:3656f00ab3db 603
klauss 78:1353744f01e1 604 for( register uint8_t i = 0; i < v_call->size(); i++ ){
klauss 0:4d17cd9c8f9d 605 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 0:4d17cd9c8f9d 606 int length = 0;
klauss 0:4d17cd9c8f9d 607 char * tmp = call->get_eth_message( &length );
klauss 0:4d17cd9c8f9d 608 if( tmp != NULL ){
klauss 0:4d17cd9c8f9d 609 int cb_port = 0xffff;
klauss 78:1353744f01e1 610 Call_Box * cb = __find_CB__( v_cb, call->get_cb_ext() );
klauss 4:de46f0d9b14d 611
klauss 4:de46f0d9b14d 612 if( cb != NULL ){
klauss 4:de46f0d9b14d 613 cb_port = cb->get_port();
klauss 78:1353744f01e1 614
klauss 78:1353744f01e1 615 uint8_t * pkg2cb = __build_cb_package__( call->get_cb_ext(), cb_port, __AUDIO__,
klauss 0:4d17cd9c8f9d 616 tmp, __AUDIO__, length, write_buffer );
klauss 4:de46f0d9b14d 617
klauss 78:1353744f01e1 618 send2callboxes( pkg2cb );
klauss 78:1353744f01e1 619 }else if( debug_main ) debug_msg("received missed package from CBx :: %i -- Type :: %i", ext, type );
klauss 0:4d17cd9c8f9d 620 }
klauss 14:22a35f575502 621 }
klauss 81:3656f00ab3db 622 //if( v_call->size() == 0 ) refresh( v_cb, buffer, write_buffer, NULL );
klauss 81:3656f00ab3db 623 refresh( v_cb, buffer, write_buffer, NULL );
klauss 78:1353744f01e1 624
klauss 78:1353744f01e1 625 //Fixme pensar melhor nessa parte durante ligacoes, pode complicar com muitos cbx ...
klauss 81:3656f00ab3db 626 //if( v_call->size() == 0 ) registry_aging( v_cb, buffer, write_buffer );
klauss 4:de46f0d9b14d 627
klauss 78:1353744f01e1 628 // check sip messages only for cbx in call ?
klauss 78:1353744f01e1 629 int ext_to__be_removed = sip_manager( v_cb );
klauss 78:1353744f01e1 630 if( ext_to__be_removed > 0x00 ){
klauss 78:1353744f01e1 631 Call_Box * cb = __find_CB__( v_cb, ext_to__be_removed );
klauss 4:de46f0d9b14d 632 if( cb != NULL ){
klauss 4:de46f0d9b14d 633 if( cb->status == cb_on_call ){
klauss 4:de46f0d9b14d 634 ts->return_timeslice( cb->get_timeslice() );
klauss 4:de46f0d9b14d 635 cb->set_timeslice( 0x00 );
klauss 4:de46f0d9b14d 636 buffer[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 78:1353744f01e1 637
klauss 78:1353744f01e1 638 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 639 set_status( cb->sip->status, sip_idle );
klauss 78:1353744f01e1 640
klauss 4:de46f0d9b14d 641 for( register uint8_t i = 0; i < v_call->size(); i++ ){
klauss 4:de46f0d9b14d 642 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 78:1353744f01e1 643 if( call->get_cb_ext() == ext_to__be_removed ){
klauss 4:de46f0d9b14d 644 v_call->remove_element( i );
klauss 4:de46f0d9b14d 645 delete( call );
klauss 4:de46f0d9b14d 646 }
klauss 2:93bec7313ccc 647 }
klauss 78:1353744f01e1 648
klauss 82:f55d13babca0 649 cb->set_msg_id( ( cb->get_msg_id() & ~BIT7 ) + 1 );
klauss 82:f55d13babca0 650 //cb->set_msg_id( 80 );
klauss 81:3656f00ab3db 651
klauss 82:f55d13babca0 652 //debug_msg("msg_id -- %d", cb->get_msg_id() );
klauss 81:3656f00ab3db 653
klauss 74:81c47fff88a5 654 send2callboxes( __build_cb_package__( ext, port, __CB_BYE__,
klauss 4:de46f0d9b14d 655 ( char * )buffer, cb->get_msg_id(), __CB_BUFFER_SIZE__ - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 78:1353744f01e1 656
klauss 81:3656f00ab3db 657 //cb->re_start_timer();
klauss 0:4d17cd9c8f9d 658 }
klauss 78:1353744f01e1 659 }else if( debug_main ) debug_msg("Missed bye request from * CBx :: %d", ext );
klauss 0:4d17cd9c8f9d 660 }
klauss 13:ae278302dffe 661
klauss 81:3656f00ab3db 662 /* Verifica andamento de ligações para eventualmente encerra-las por timeout */
klauss 10:22da1a0ac1e1 663 call_manager( v_call, v_cb, buffer, write_buffer, ts );
klauss 0:4d17cd9c8f9d 664
klauss 81:3656f00ab3db 665 /* tratamento de pedidos de ligação */
klauss 81:3656f00ab3db 666 invite_handler( v_call, v_cb, ts, NULL );
klauss 78:1353744f01e1 667
klauss 81:3656f00ab3db 668 /* rotina de verificação de TS's perdidos */
klauss 78:1353744f01e1 669 if( ( v_call->size() == 0 ) && ( ts->remain_timeslices() != __MAX_TIMESLICES__ ) ){
klauss 78:1353744f01e1 670 bool ts_reset = true;
klauss 78:1353744f01e1 671 for( register uint8_t i = 0; i < v_cb->size(); i++ ){
klauss 82:f55d13babca0 672 if ( ( ( Call_Box * )v_cb->get_element( i ) )->get_status() != cb_idle &&
klauss 82:f55d13babca0 673 ( ( Call_Box * )v_cb->get_element( i ) )->get_sip_status() != sip_idle )
klauss 82:f55d13babca0 674 {
klauss 78:1353744f01e1 675 ts_reset = false;
klauss 78:1353744f01e1 676 break;
klauss 78:1353744f01e1 677 }
klauss 78:1353744f01e1 678 }
klauss 78:1353744f01e1 679 if( ts_reset ){
klauss 81:3656f00ab3db 680 if( debug_invite ) debug_msg("Resetando TS");
klauss 78:1353744f01e1 681 ts->reset();
klauss 78:1353744f01e1 682 }
klauss 0:4d17cd9c8f9d 683 }
klauss 78:1353744f01e1 684
klauss 81:3656f00ab3db 685 //invite_pgk_retry_manager( v_call, v_cb, buffer, write_buffer );
klauss 81:3656f00ab3db 686
klauss 81:3656f00ab3db 687 /* escuta se existe algum procedimento de gravação de cbx */
klauss 67:cdedc64d9921 688 bl_handler();
klauss 78:1353744f01e1 689
klauss 81:3656f00ab3db 690 /* rotina que esvazia possiveis pacotes que não foram transmitidos para evitar conflito */
klauss 72:895ca792c647 691 tx_buffer_ring_buffer_handler();
klauss 33:735fd60e96d8 692
klauss 30:8dfb6d8de53d 693 type = __DO_NOTHING__;
klauss 81:3656f00ab3db 694
klauss 81:3656f00ab3db 695 if( eth_status == 0 ) eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 81:3656f00ab3db 696
klauss 83:b8a1d8fdeaeb 697 if( wdt_timer.read() >= 1 ){
klauss 83:b8a1d8fdeaeb 698 char wake_msg[ 48 ];
klauss 83:b8a1d8fdeaeb 699 uptime++;
klauss 82:f55d13babca0 700 int read = udp_wdt_client.receiveFrom( udp_wdt_server, wake_msg, sizeof( wake_msg ) );
klauss 82:f55d13babca0 701
klauss 82:f55d13babca0 702 if( read > 0 ){
klauss 82:f55d13babca0 703 if( !( strncmp( wake_msg, "alive", 5 ) ) ){
klauss 83:b8a1d8fdeaeb 704 // Just ckeck but not set 'alive?'
klauss 83:b8a1d8fdeaeb 705 // Ckecking and set 'alive'
klauss 84:b64f0e3b283e 706 bool question_alive = ( wake_msg[ 5 ] == '?' );
klauss 84:b64f0e3b283e 707
klauss 84:b64f0e3b283e 708 snprintf( wake_msg, 48,"wdt:%u,%u,%u,%c:", uptime, invite_counter, external_wdt, ( wdt.WatchdogCausedReset() ) ? '1' : '0' );
klauss 83:b8a1d8fdeaeb 709 wake_msg[ 48 - 1 ] = 0;
klauss 83:b8a1d8fdeaeb 710 int sent = 0;
klauss 84:b64f0e3b283e 711 sent = udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 83:b8a1d8fdeaeb 712
klauss 83:b8a1d8fdeaeb 713 if( wdt_show ) send_msg( "Sent %d bytes in response", sent );
klauss 84:b64f0e3b283e 714
klauss 84:b64f0e3b283e 715 if( !question_alive ) {
klauss 84:b64f0e3b283e 716 external_wdt = EXTERN_WDT_IDLE;
klauss 84:b64f0e3b283e 717 }
klauss 83:b8a1d8fdeaeb 718 }else if( !( strncmp( wake_msg, "reset", 5 ) ) ){
klauss 83:b8a1d8fdeaeb 719 external_wdt = 0;
klauss 83:b8a1d8fdeaeb 720
klauss 83:b8a1d8fdeaeb 721 sprintf( wake_msg, "rst:%u:", uptime );
klauss 83:b8a1d8fdeaeb 722 int sent = 0;
klauss 83:b8a1d8fdeaeb 723 sent = udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 83:b8a1d8fdeaeb 724
klauss 83:b8a1d8fdeaeb 725 if( wdt_show ) send_msg( "Sent %d bytes in response", sent );
klauss 82:f55d13babca0 726 }
klauss 82:f55d13babca0 727 }
klauss 83:b8a1d8fdeaeb 728 if( wdt_show ) if( read < 0 ) debug_msg( "some's wrong ... some's wrong" );
klauss 82:f55d13babca0 729
klauss 81:3656f00ab3db 730 wdt_timer.reset();
klauss 81:3656f00ab3db 731
klauss 81:3656f00ab3db 732 if( wdt_show ) debug_wdt = true;
klauss 81:3656f00ab3db 733
klauss 81:3656f00ab3db 734 if( external_wdt ) external_wdt--;
klauss 81:3656f00ab3db 735 if( pkg_wdt ) pkg_wdt--;
klauss 81:3656f00ab3db 736 if( eth_wdt ) eth_wdt--;
klauss 81:3656f00ab3db 737
klauss 81:3656f00ab3db 738 if( eth_wdt && external_wdt && pkg_wdt ){
klauss 81:3656f00ab3db 739 wdt.kick();
klauss 81:3656f00ab3db 740 }
klauss 81:3656f00ab3db 741 }
klauss 81:3656f00ab3db 742
klauss 81:3656f00ab3db 743 if( debug_wdt ){
klauss 81:3656f00ab3db 744 debug_wdt = false;
klauss 81:3656f00ab3db 745 if( eth_status == 0 ){
klauss 82:f55d13babca0 746 send_msg( "Wdt last reset: %s - status_eth :: Connected - Extern Wdt idle for :: %3d sec ( %3d ) - Rx from CBx idle for :: %3d sec ( %3d )",
klauss 81:3656f00ab3db 747 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 81:3656f00ab3db 748 EXTERN_WDT_IDLE - external_wdt,
klauss 82:f55d13babca0 749 EXTERN_WDT_IDLE,
klauss 82:f55d13babca0 750 RX_CB_IDLE - pkg_wdt,
klauss 82:f55d13babca0 751 RX_CB_IDLE
klauss 81:3656f00ab3db 752 );
klauss 81:3656f00ab3db 753 }else{
klauss 82:f55d13babca0 754 send_msg( "Wdt last reset: %s - status_eth :: Disconnected :: since %3d sec - Extern Wdt idle for :: %3d sec ( %3d ) - Rx from CBx idle for :: %3d sec ( %3d )",
klauss 81:3656f00ab3db 755 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 81:3656f00ab3db 756 ETH_CONNECT_TIMEOUT - eth_wdt,
klauss 82:f55d13babca0 757 EXTERN_WDT_IDLE - external_wdt,
klauss 82:f55d13babca0 758 EXTERN_WDT_IDLE,
klauss 82:f55d13babca0 759 RX_CB_IDLE - pkg_wdt,
klauss 82:f55d13babca0 760 RX_CB_IDLE
klauss 81:3656f00ab3db 761 );
klauss 81:3656f00ab3db 762 }
klauss 81:3656f00ab3db 763 }
klauss 0:4d17cd9c8f9d 764 }
klauss 0:4d17cd9c8f9d 765 }