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@108:18a3702650f3, 2015-03-18 (annotated)

Committer:
klauss
Date:
Wed Mar 18 13:33:54 2015 +0000
Revision:
108:18a3702650f3
Parent:
107:cf1e43414adb
Child:
109:a5b8264ffbbc
wip - bug udp porta, corrompendo v_cb->size () em ultima analise

Who changed what in which revision?

UserRevisionLine numberNew contents of line
klauss 105:a930035b6556 1 #include "main_includes.h"
klauss 0:4d17cd9c8f9d 2
klauss 105:a930035b6556 3 // Contador low-level de pacotes recebifos na interface eth da embarcada, extern de lpc17_emac.c
klauss 87:679ee0d594a9 4 volatile u16_t lpc_low_level_input_counter = 0;
klauss 85:b6f2dc1d0f4f 5
klauss 91:c2a86b1f8aaa 6 int main()
klauss 106:a34fcf9f0e02 7 {
klauss 105:a930035b6556 8 // configura e inicia o wdt
klauss 81:3656f00ab3db 9 init_wdt();
klauss 91:c2a86b1f8aaa 10
klauss 105:a930035b6556 11 // configs de sistema, irqs, I/O bounds
klauss 81:3656f00ab3db 12 config_lpc();
klauss 91:c2a86b1f8aaa 13
klauss 105:a930035b6556 14 // inicializa a comunicacao com a laser
klauss 0:4d17cd9c8f9d 15 start_cpld();
klauss 91:c2a86b1f8aaa 16
klauss 105:a930035b6556 17 // habilita a impressao de caracteres na interface UART3
klauss 100:09a23fcd3bdf 18 debug_uart3 = true;
klauss 105:a930035b6556 19
klauss 105:a930035b6556 20 // rotina de verificacao do uso do sistema de memoria
klauss 91:c2a86b1f8aaa 21 if( sdram_init() == 1 ) {
klauss 106:a34fcf9f0e02 22 pc.printf("\r\n******* Failed to initialize SDRAM *******\r\n");
klauss 87:679ee0d594a9 23 return 1;
klauss 89:0fe315117b00 24 } else {
klauss 106:a34fcf9f0e02 25 pc.printf("\r\n******* Success to initialize SDRAM *******\r\n");
klauss 87:679ee0d594a9 26 }
klauss 91:c2a86b1f8aaa 27
klauss 105:a930035b6556 28 // inicializa o sistema de arquivo para uso
klauss 43:455522f98de5 29 init_fsystem();
klauss 91:c2a86b1f8aaa 30
klauss 105:a930035b6556 31 // exibe endereco MAC da lpc
klauss 89:0fe315117b00 32 {
klauss 89:0fe315117b00 33 char s[ 32 ];
klauss 89:0fe315117b00 34 mbed_mac_address( s );
klauss 106:a34fcf9f0e02 35 pc.printf( "\r\n******* ::Mac::%02x:%02x:%02x:%02x:%02x:%02x:: *******\r\n", s[0],s[1],s[2],s[3],s[4],s[5] );
klauss 89:0fe315117b00 36 }
klauss 91:c2a86b1f8aaa 37
klauss 105:a930035b6556 38 // rotina de inicializacao da interface ETH
klauss 78:1353744f01e1 39 short int eth_status = __init_eth__();
klauss 91:c2a86b1f8aaa 40 if( eth_status ) {
klauss 105:a930035b6556 41 pc.printf("\r\n******* Cannot connect to eth *******\r\n");
klauss 91:c2a86b1f8aaa 42 } else {
klauss 106:a34fcf9f0e02 43 pc.printf("\r\n******* Connection eth - ok *******\r\n");
klauss 78:1353744f01e1 44 init_prompt_eth();
klauss 82:f55d13babca0 45 init_external_wdt()
klauss 8:e3bfe62a477e 46 }
klauss 91:c2a86b1f8aaa 47
klauss 105:a930035b6556 48 // sync_timer : usado para sincronizar eventos a cada x unidades de tempo, usualmente em debugs
klauss 105:a930035b6556 49 // led_sync_timer : usado para controlar a taxa de toggle do led de debug
klauss 78:1353744f01e1 50 Timer sync_timer, led_sync_timer;
klauss 105:a930035b6556 51
klauss 105:a930035b6556 52 sync_timer.start();
klauss 105:a930035b6556 53 led_sync_timer.start();
klauss 91:c2a86b1f8aaa 54
klauss 105:a930035b6556 55 // representa ramal do call box
klauss 0:4d17cd9c8f9d 56 int ext = 0;
klauss 91:c2a86b1f8aaa 57
klauss 105:a930035b6556 58 // representa porta do call box
klauss 78:1353744f01e1 59 int port = 0;
klauss 91:c2a86b1f8aaa 60
klauss 105:a930035b6556 61 // buffer para onde se copia os dados vindos do cb para tratameno interno
klauss 105:a930035b6556 62 uint8_t buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 63
klauss 105:a930035b6556 64 // buffer de escrita do pacote de saida que sera enviado pro cb / servidor
klauss 105:a930035b6556 65 uint8_t write_buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 66
klauss 105:a930035b6556 67 // ponteiro que aponta para os dados vindo do CPLD
klauss 0:4d17cd9c8f9d 68 uint8_t * buffer_from_cb_ptr = ( uint8_t * )RXBuffer;
klauss 91:c2a86b1f8aaa 69
klauss 105:a930035b6556 70 // Armazena o ultimo pacote recebido dos CBx
klauss 105:a930035b6556 71 uint8_t cb_rx_buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 72
klauss 105:a930035b6556 73 // referencia para os dados contidos no pacote, sem o header
klauss 0:4d17cd9c8f9d 74 uint8_t * data = NULL;
klauss 91:c2a86b1f8aaa 75
klauss 105:a930035b6556 76 // gerencia o tipo do pacote para providenciar tratamento adequado
klauss 0:4d17cd9c8f9d 77 volatile uint8_t type = __DO_NOTHING__;
klauss 91:c2a86b1f8aaa 78
klauss 105:a930035b6556 79 // representa a lista dos Call Boxes atualmente recfonhecidos pela cabeceira
klauss 0:4d17cd9c8f9d 80 Vector * v_cb = new Vector();
klauss 91:c2a86b1f8aaa 81
klauss 105:a930035b6556 82 // representa a lista de ligacoes ativas na cabeceira
klauss 0:4d17cd9c8f9d 83 Vector * v_call = new Vector();
klauss 91:c2a86b1f8aaa 84
klauss 105:a930035b6556 85 // gerencia a distribuicao de timeslice para os call boxes
klauss 0:4d17cd9c8f9d 86 Timeslice * ts = new Timeslice();
klauss 91:c2a86b1f8aaa 87 if( ts == NULL ) {
klauss 89:0fe315117b00 88 memory_is_over = true;
klauss 89:0fe315117b00 89 if( debug_memory ) debug_msg("TS allocation fail");
klauss 89:0fe315117b00 90 }
klauss 91:c2a86b1f8aaa 91
klauss 105:a930035b6556 92 // aloca o vetor de call boxes
klauss 91:c2a86b1f8aaa 93 if( v_cb == NULL ) {
klauss 91:c2a86b1f8aaa 94 while( v_cb == NULL ) {
klauss 0:4d17cd9c8f9d 95 Vector * v_cb = new Vector();
klauss 91:c2a86b1f8aaa 96 if( sync_timer.read() > 5 ) {
klauss 48:195c97f12e8e 97 send_msg("Erro ao alocar o vetor de CBx");
klauss 78:1353744f01e1 98 sync_timer.reset();
klauss 0:4d17cd9c8f9d 99 }
klauss 0:4d17cd9c8f9d 100 }
klauss 105:a930035b6556 101 }
klauss 105:a930035b6556 102
klauss 105:a930035b6556 103 // aloca o vetor de calls
klauss 105:a930035b6556 104 if( v_call == NULL ) {
klauss 91:c2a86b1f8aaa 105 while( v_call == NULL ) {
klauss 0:4d17cd9c8f9d 106 Vector * v_call = new Vector();
klauss 91:c2a86b1f8aaa 107 if( sync_timer.read() > 5 ) {
klauss 48:195c97f12e8e 108 send_msg("Erro ao alocar o vetor de Calls");
klauss 78:1353744f01e1 109 sync_timer.reset();
klauss 0:4d17cd9c8f9d 110 }
klauss 0:4d17cd9c8f9d 111 }
klauss 0:4d17cd9c8f9d 112 }
klauss 91:c2a86b1f8aaa 113
klauss 91:c2a86b1f8aaa 114 if( v_cb == NULL ) {
klauss 89:0fe315117b00 115 memory_is_over = true;
klauss 89:0fe315117b00 116 if( debug_memory ) debug_msg("Call_Box vector allocation fail");
klauss 89:0fe315117b00 117 }
klauss 91:c2a86b1f8aaa 118
klauss 91:c2a86b1f8aaa 119 if( v_call == NULL ) {
klauss 89:0fe315117b00 120 memory_is_over = true;
klauss 89:0fe315117b00 121 if( debug_memory ) debug_msg("Call vector allocation fail");
klauss 89:0fe315117b00 122 }
klauss 91:c2a86b1f8aaa 123
klauss 105:a930035b6556 124 // inicializa buffers de armazenamento temporario de I/O com o CBx
klauss 105:a930035b6556 125 for( register uint16_t i = 0; i < CB_BUFFER_SIZE; i++ ) {
klauss 63:0d95da692bb4 126 cb_rx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 127 cb_tx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 128 }
klauss 91:c2a86b1f8aaa 129
klauss 105:a930035b6556 130 // apagar os leds do lpc
klauss 0:4d17cd9c8f9d 131 reset_leds();
klauss 91:c2a86b1f8aaa 132
klauss 105:a930035b6556 133 //FIXME remover caso compravado desuso
klauss 33:735fd60e96d8 134 udp_timer.start();
klauss 99:e80850c51106 135
klauss 105:a930035b6556 136 // inicializa o sistema para envio de pacotes do tipo __FW?__ e __TELEMETRY__ para servidor ( ip, porta ) previamente configurado.
klauss 99:e80850c51106 137 init_fw_handler();
klauss 99:e80850c51106 138
klauss 99:e80850c51106 139 led2 = 0;
klauss 105:a930035b6556 140
klauss 105:a930035b6556 141 // le do sistema de arquivos valores previamente configurados de primeiro e ultimo ramal de um determinado ramo.
klauss 81:3656f00ab3db 142 init_ranges();
klauss 105:a930035b6556 143
klauss 105:a930035b6556 144 // inicializa o timer de refresh dos cbx
klauss 80:61d61c9eb75c 145 init_refresh();
klauss 91:c2a86b1f8aaa 146
klauss 105:a930035b6556 147 // inicializa o time de envelhecimento do CBx
klauss 78:1353744f01e1 148 init_aging();
klauss 91:c2a86b1f8aaa 149
klauss 105:a930035b6556 150 // inicislizs o yimrt para sincronizar as rotinas de wake_all_up e refresh
klauss 89:0fe315117b00 151 init_sync_refresh();
klauss 91:c2a86b1f8aaa 152
klauss 105:a930035b6556 153 // usada para delay na ativacao de algumas funcoes, wake_all_up e tentativa de eth reconnect
klauss 62:07e5bdc9f8f7 154 static uint8_t count = 0;
klauss 91:c2a86b1f8aaa 155
klauss 105:a930035b6556 156 // contador usado para indicar quantos cbx foram registrados na logica
klauss 78:1353744f01e1 157 uint8_t max_registered_cbx = 0;
klauss 91:c2a86b1f8aaa 158
klauss 105:a930035b6556 159 // inicia dizendo que a rotina nao deve rodar agora ( 35 sec. nas versoes originais )
klauss 81:3656f00ab3db 160 bool wake_all = false;
klauss 91:c2a86b1f8aaa 161
klauss 105:a930035b6556 162 // inico das variaveis controladoras do extern wdt
klauss 105:a930035b6556 163
klauss 105:a930035b6556 164 // atribui valor maximo ao countdown que verifica comunicao com os CBx
klauss 81:3656f00ab3db 165 uint16_t pkg_wdt = RX_CB_IDLE;
klauss 105:a930035b6556 166
klauss 105:a930035b6556 167 // atribi falor maximo ao countdown que verifica conexao eth
klauss 81:3656f00ab3db 168 uint16_t eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 105:a930035b6556 169
klauss 105:a930035b6556 170 // inicializa o contador de uptime da header
klauss 83:b8a1d8fdeaeb 171 uint32_t uptime = 0;
klauss 105:a930035b6556 172
klauss 99:e80850c51106 173 led1 = 0;
klauss 104:62646ef786a3 174
klauss 105:a930035b6556 175 send_msg("\r\nReady");
klauss 92:92df17f538a8 176
klauss 105:a930035b6556 177 // inicializa o timer de retry dos pacotes de invite, necessario para o comportamento "metralhadora" da header.
klauss 99:e80850c51106 178 Timer invite_retry_timer;
klauss 99:e80850c51106 179 invite_retry_timer.start();
klauss 105:a930035b6556 180
klauss 105:a930035b6556 181 // desabilita a impressao de caracteres na interface UART3
klauss 105:a930035b6556 182 //debug_uart3 = false;
klauss 106:a34fcf9f0e02 183
klauss 106:a34fcf9f0e02 184 reset_leds();
klauss 91:c2a86b1f8aaa 185
klauss 78:1353744f01e1 186 /*------------------------------------------ main loop ---------------------------------------------------------------*/
klauss 91:c2a86b1f8aaa 187 while( true ) {
klauss 105:a930035b6556 188 // inicializa o loop afirmando que nao existe comando externo para ser processado pelo prompt.
klauss 105:a930035b6556 189 udp_query = false;
klauss 105:a930035b6556 190 from_eth = false;
klauss 105:a930035b6556 191
klauss 106:a34fcf9f0e02 192 // chama rotina de processamento de entrada serial para o prompp
klauss 105:a930035b6556 193 prompt_process( NULL, 0 );
klauss 99:e80850c51106 194
klauss 105:a930035b6556 195 //begin verificacao e tratamento dos pacotes recebidos via UDP-ETH
klauss 105:a930035b6556 196 {
klauss 105:a930035b6556 197 fd_set fdSet;
klauss 105:a930035b6556 198 FD_ZERO(&fdSet);
klauss 105:a930035b6556 199
klauss 105:a930035b6556 200 // coloca o socket SIP de todos os CBx
klauss 105:a930035b6556 201 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 105:a930035b6556 202 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 105:a930035b6556 203 FD_SET( cb->get_sip_socket_fd(), &fdSet );
klauss 105:a930035b6556 204 }
klauss 105:a930035b6556 205
klauss 105:a930035b6556 206 // adiciona o socket do watchdog
klauss 105:a930035b6556 207 FD_SET( udp_wdt_client.get_fd(), &fdSet );
klauss 105:a930035b6556 208
klauss 105:a930035b6556 209 // adiciona o socket de comandos prompt-UDP-ETH
klauss 105:a930035b6556 210 FD_SET( udp_client.get_fd(), &fdSet );
klauss 105:a930035b6556 211
klauss 105:a930035b6556 212 struct timeval t;
klauss 105:a930035b6556 213 t.tv_sec = 0;
klauss 105:a930035b6556 214 t.tv_usec = 0;
klauss 105:a930035b6556 215 // verifica se existe algo pendente para ser tratado
klauss 105:a930035b6556 216 int ret = lwip_select( FD_SETSIZE, &fdSet, NULL, NULL, &t );
klauss 105:a930035b6556 217
klauss 105:a930035b6556 218 if(ret > 0 ) {
klauss 105:a930035b6556 219 // existe algo na fila UDP pendente.
klauss 105:a930035b6556 220 // verigica o socket SIP de cada CBx
klauss 105:a930035b6556 221 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 105:a930035b6556 222 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 105:a930035b6556 223 int fd = cb->get_sip_socket_fd();
klauss 105:a930035b6556 224 if( FD_ISSET( fd, &fdSet ) ) {
klauss 105:a930035b6556 225 int rcv = cb->sip_udp_incomming_pkg();
klauss 105:a930035b6556 226 }
klauss 105:a930035b6556 227 }
klauss 105:a930035b6556 228
klauss 105:a930035b6556 229 // verifica o socket do prompt-UDP-ETH
klauss 105:a930035b6556 230 if( FD_ISSET( udp_client.get_fd(), &fdSet ) ) {
klauss 105:a930035b6556 231 char to_prompt_process[ PROMPT_UDP_COMMAND_SIZE ];
klauss 108:18a3702650f3 232 for( register int i = 0; i < PROMPT_UDP_COMMAND_SIZE; i++ ) to_prompt_process[ i ] = 0;
klauss 105:a930035b6556 233
klauss 105:a930035b6556 234 int prompt_process_msg_rcv = udp_client.receiveFrom( udp_server, to_prompt_process, ( sizeof( to_prompt_process ) - 1 ) );
klauss 105:a930035b6556 235
klauss 105:a930035b6556 236 to_prompt_process[ prompt_process_msg_rcv ] = 0;
klauss 105:a930035b6556 237 if( prompt_process_msg_rcv == -1 )
klauss 105:a930035b6556 238 {
klauss 105:a930035b6556 239 if( debug_reconnect ) send_msg("Reconnect Prompt Process");
klauss 105:a930035b6556 240 reconnect_udp_prompt_process();
klauss 105:a930035b6556 241 miss_prompt_udp_rcv_pkg++;
klauss 105:a930035b6556 242 }
klauss 105:a930035b6556 243 else if( prompt_process_msg_rcv > 0 )
klauss 105:a930035b6556 244 {
klauss 105:a930035b6556 245 udp_query = true;
klauss 105:a930035b6556 246 prompt_process( to_prompt_process, prompt_process_msg_rcv );
klauss 105:a930035b6556 247 }
klauss 105:a930035b6556 248 }
klauss 105:a930035b6556 249
klauss 105:a930035b6556 250 // verifica o socket do watchdog
klauss 105:a930035b6556 251 if( FD_ISSET( udp_wdt_client.get_fd(), &fdSet ) ) {
klauss 105:a930035b6556 252 char wake_msg[ 768 ];
klauss 105:a930035b6556 253 Endpoint udp_wdt_server;
klauss 105:a930035b6556 254
klauss 105:a930035b6556 255 int wake_msg_rcv = udp_wdt_client.receiveFrom( udp_wdt_server, wake_msg, sizeof( wake_msg ) );
klauss 105:a930035b6556 256
klauss 105:a930035b6556 257 if( wake_msg_rcv == -1 )
klauss 105:a930035b6556 258 {
klauss 105:a930035b6556 259 if( debug_reconnect ) send_msg("Reconnect Extern wdt");
klauss 105:a930035b6556 260 reconnect_extern_wdt_socket();
klauss 105:a930035b6556 261 miss_wdt_send_pkg++;
klauss 105:a930035b6556 262 }
klauss 105:a930035b6556 263 else if( wake_msg_rcv > 0 )
klauss 105:a930035b6556 264 {
klauss 105:a930035b6556 265 if( !( strncmp( wake_msg, "alive", 5 ) ) ) {
klauss 105:a930035b6556 266 // Just ckeck but not set 'alive?'
klauss 105:a930035b6556 267 // 'alive*' - force wdt tick right now
klauss 105:a930035b6556 268 // Ckecking and set 'alive'
klauss 105:a930035b6556 269 bool question_alive = ( wake_msg[ 5 ] == '?' );
klauss 105:a930035b6556 270 if( wake_msg[ 5 ] == '*' ) wdt.kick();
klauss 105:a930035b6556 271
klauss 106:a34fcf9f0e02 272 snprintf( wake_msg, 48,"wdt:%u,%u,%u,%c,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u:",
klauss 105:a930035b6556 273 uptime,
klauss 105:a930035b6556 274 invite_counter,
klauss 105:a930035b6556 275 external_wdt,
klauss 105:a930035b6556 276 ( wdt.WatchdogCausedReset() ) ? '1' : '0',
klauss 105:a930035b6556 277 cb_new_counter,
klauss 105:a930035b6556 278 v_cb->size(),
klauss 105:a930035b6556 279 ts->remain_timeslices(),
klauss 105:a930035b6556 280 sip_socket_send_failure,
klauss 106:a34fcf9f0e02 281 v_call->size(),
klauss 106:a34fcf9f0e02 282 pkg_cksok,
klauss 106:a34fcf9f0e02 283 pkg_ckserr,
klauss 106:a34fcf9f0e02 284 pkg_zero,
klauss 106:a34fcf9f0e02 285 out_of_range,
klauss 106:a34fcf9f0e02 286 missed_pkg,
klauss 106:a34fcf9f0e02 287 delayed_pkg_to_cb,
klauss 106:a34fcf9f0e02 288 cpld_pkg_tx_counter,
klauss 106:a34fcf9f0e02 289 cpld_pkg_rx_counter,
klauss 106:a34fcf9f0e02 290 eth_wdt,
klauss 106:a34fcf9f0e02 291 pkg_wdt,
klauss 106:a34fcf9f0e02 292 miss_fw_send_pkg,
klauss 106:a34fcf9f0e02 293 miss_prompt_udp_send_pkg,
klauss 106:a34fcf9f0e02 294 miss_sip_registry_send_pkg,
klauss 106:a34fcf9f0e02 295 miss_sip_invite_send_pkg,
klauss 106:a34fcf9f0e02 296 miss_sip_bye_send_pkg,
klauss 106:a34fcf9f0e02 297 miss_sip_unregistry_send_pkg,
klauss 106:a34fcf9f0e02 298 miss_sip_ok_send_pkg,
klauss 106:a34fcf9f0e02 299 miss_sip_rcv_bye_send_pkg,
klauss 106:a34fcf9f0e02 300 miss_wdt_send_pkg,
klauss 106:a34fcf9f0e02 301 miss_prompt_udp_send_pkg,
klauss 106:a34fcf9f0e02 302 miss_ftp_udp_send_pkg,
klauss 106:a34fcf9f0e02 303 miss_prompt_udp_rcv_pkg
klauss 105:a930035b6556 304 );
klauss 106:a34fcf9f0e02 305
klauss 105:a930035b6556 306 wake_msg[ 768 - 1 ] = 0;
klauss 105:a930035b6556 307 int send = udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 105:a930035b6556 308 if( send != strlen( wake_msg ) )
klauss 105:a930035b6556 309 {
klauss 105:a930035b6556 310 if( debug_reconnect ) debug_msg("Reconnect Extern wdt (%d, %d)", send, strlen( wake_msg ) );
klauss 105:a930035b6556 311 reconnect_extern_wdt_socket();
klauss 105:a930035b6556 312 miss_wdt_send_pkg++;
klauss 105:a930035b6556 313 }
klauss 105:a930035b6556 314
klauss 105:a930035b6556 315 if( ( (!question_alive) && ( cb_new_counter <= __MAX_CB_IN_A_BRANCH__ ) && ( cb_new_counter >= 2 ) ) ) {
klauss 105:a930035b6556 316 external_wdt = EXTERN_WDT_IDLE;
klauss 105:a930035b6556 317 }
klauss 105:a930035b6556 318 } else if( !( strncmp( wake_msg, "reset", 5 ) ) ) {
klauss 105:a930035b6556 319 external_wdt = 0;
klauss 105:a930035b6556 320
klauss 105:a930035b6556 321 sprintf( wake_msg, "rst:%u:", uptime );
klauss 105:a930035b6556 322 int send = udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 105:a930035b6556 323 if( send != strlen( wake_msg ) )
klauss 105:a930035b6556 324 {
klauss 105:a930035b6556 325 if( debug_reconnect ) send_msg("Reconnect Extern wdt");
klauss 105:a930035b6556 326 reconnect_extern_wdt_socket();
klauss 105:a930035b6556 327 miss_wdt_send_pkg++;
klauss 105:a930035b6556 328 }
klauss 105:a930035b6556 329 }
klauss 105:a930035b6556 330 }
klauss 105:a930035b6556 331 }
klauss 105:a930035b6556 332 }
klauss 105:a930035b6556 333 }//end verificacao e tratamento dos pacotes recebidos via UDP-ETH
klauss 105:a930035b6556 334
klauss 108:18a3702650f3 335
klauss 105:a930035b6556 336 // atualiza o valor do contador max_registered_cbx
klauss 78:1353744f01e1 337 if( v_cb->size() > max_registered_cbx ) max_registered_cbx = v_cb->size();
klauss 91:c2a86b1f8aaa 338
klauss 105:a930035b6556 339 // executa a cada 5 segundos comandos e verificacoes ( principalmente debugs )
klauss 91:c2a86b1f8aaa 340 if( sync_timer.read() > 5 ) {
klauss 78:1353744f01e1 341 sync_timer.reset();
klauss 105:a930035b6556 342
klauss 105:a930035b6556 343 // atualiza valor da variavel de delay
klauss 105:a930035b6556 344 count++;
klauss 91:c2a86b1f8aaa 345
klauss 105:a930035b6556 346 // enable na variavel que exibe estatisticas de cks dos pacotes recebidos pela header
klauss 91:c2a86b1f8aaa 347 if( debug_cks == true ) {
klauss 81:3656f00ab3db 348 pcks_s = true;
klauss 78:1353744f01e1 349 }
klauss 91:c2a86b1f8aaa 350
klauss 105:a930035b6556 351 // enable na variavel que exibe uma lista ( por ordem de pedido de registro ) dos cbx
klauss 91:c2a86b1f8aaa 352 if( debug_alive == true ) {
klauss 81:3656f00ab3db 353 pshowcb = true;
klauss 78:1353744f01e1 354 }
klauss 100:09a23fcd3bdf 355
klauss 105:a930035b6556 356 // enable na variavel que exibe lista com estatisticas de pacotes que falharam ao serem enviados via interface eth
klauss 105:a930035b6556 357 if( debug_missed )
klauss 105:a930035b6556 358 {
klauss 105:a930035b6556 359 missed_send_udp_pkg = true;
klauss 105:a930035b6556 360 }
klauss 105:a930035b6556 361
klauss 105:a930035b6556 362 // verifica status da conexao eth, em caso de falha na inicializacao anterior, tenta conectar periodicamente a cada 75 sec.
klauss 105:a930035b6556 363 // nas implementacoes inicias
klauss 105:a930035b6556 364 if( !( count % 15 ) ) {
klauss 91:c2a86b1f8aaa 365 if( eth_status ) {
klauss 78:1353744f01e1 366 eth_status = __init_eth__();
klauss 91:c2a86b1f8aaa 367 if( eth_status ) {
klauss 105:a930035b6556 368 if( debug_main ) pc.printf("\r\nCannot connect to eth\r\n");
klauss 91:c2a86b1f8aaa 369 } else {
klauss 105:a930035b6556 370 if( debug_main ) pc.printf("\r\nConnection eth - ok");
klauss 78:1353744f01e1 371 init_prompt_eth();
klauss 82:f55d13babca0 372 init_external_wdt()
klauss 78:1353744f01e1 373 }
klauss 78:1353744f01e1 374 }
klauss 78:1353744f01e1 375 }
klauss 100:09a23fcd3bdf 376
klauss 105:a930035b6556 377 // inicializa rotina de verificacao de "pares" de CBx apos 35 sec. nas implementacoes iniciais
klauss 91:c2a86b1f8aaa 378 if( ( count > 7 ) && ( wake_all == false ) ) {
klauss 81:3656f00ab3db 379 wake_all = true;
klauss 78:1353744f01e1 380 if( debug_wake == true ) send_msg( "Time to wake" );
klauss 78:1353744f01e1 381 }
klauss 108:18a3702650f3 382 }
klauss 91:c2a86b1f8aaa 383
klauss 105:a930035b6556 384 // zera os contadores de pacotes recebidos na interface CBx->Header
klauss 91:c2a86b1f8aaa 385 if( r_stats ) {
klauss 91:c2a86b1f8aaa 386 boot_counter = 0;
klauss 91:c2a86b1f8aaa 387 registry_counter = 0;
klauss 91:c2a86b1f8aaa 388 invite_counter = 0;
klauss 91:c2a86b1f8aaa 389 audio_counter = 0;
klauss 91:c2a86b1f8aaa 390 telemetry_counter = 0;
klauss 91:c2a86b1f8aaa 391 cb_bye_counter = 0;
klauss 91:c2a86b1f8aaa 392 prompt_counter = 0;
klauss 91:c2a86b1f8aaa 393 flood_counter = 0;
klauss 67:cdedc64d9921 394 bootloader_cbx_counter = 0;
klauss 99:e80850c51106 395 cb_stats_counter = 0;
klauss 105:a930035b6556 396 fw_counter = 0;
klauss 63:0d95da692bb4 397 r_stats = false;
klauss 63:0d95da692bb4 398 stats = true;
klauss 63:0d95da692bb4 399 }
klauss 91:c2a86b1f8aaa 400
klauss 105:a930035b6556 401 // exibe o valor dos contadores de pacotes recebidos na interfacao CBx->ETH
klauss 91:c2a86b1f8aaa 402 if( stats ) {
klauss 63:0d95da692bb4 403 char str[ 200 ];
klauss 105:a930035b6556 404 snprintf( str, 200, "\n\r Received Pkgs ::\n\r Boot :: %u\n\r Registry :: %u\n\r Invite :: %u\n\r Audio :: %u\n\r Telemetry :: %u\n\r CB_stats :: %u\n\r CB_bye :: %u\n\r Prompt :: %u\n\r Flood :: %u\n\r Bootloader_cbx :: %u\n\r Fw :: %u\n\r",
klauss 105:a930035b6556 405 boot_counter, registry_counter, invite_counter, audio_counter, telemetry_counter, cb_stats_counter, cb_bye_counter, prompt_counter, flood_counter, bootloader_cbx_counter, fw_counter );
klauss 63:0d95da692bb4 406 send_msg( str );
klauss 63:0d95da692bb4 407 stats =false;
klauss 63:0d95da692bb4 408 }
klauss 106:a34fcf9f0e02 409
klauss 105:a930035b6556 410 // exibe uma lista ( em ordem crescente e por ramais ) dos cbx que ja se registraram ao menos uma vez
klauss 106:a34fcf9f0e02 411 if( list )
klauss 106:a34fcf9f0e02 412 {
klauss 78:1353744f01e1 413 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 91:c2a86b1f8aaa 414
klauss 78:1353744f01e1 415 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 91:c2a86b1f8aaa 416
klauss 78:1353744f01e1 417 if( min_ext % 2 ) missed_cb++;
klauss 91:c2a86b1f8aaa 418
klauss 78:1353744f01e1 419 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 91:c2a86b1f8aaa 420
klauss 78:1353744f01e1 421 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 91:c2a86b1f8aaa 422 if( v_cb->size() == 1 ) {
klauss 78:1353744f01e1 423 send_msg(" %d ", ( ( Call_Box * )v_cb->get_element( 0 ) )->get_ext() );
klauss 91:c2a86b1f8aaa 424 } else if( v_cb->size() > 1 ) {
klauss 62:07e5bdc9f8f7 425 char str[ 1024 ];
klauss 78:1353744f01e1 426 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 62:07e5bdc9f8f7 427 register int i = 0;
klauss 91:c2a86b1f8aaa 428 for( ; i < v_cb->size(); i++ ) {
klauss 78:1353744f01e1 429 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 62:07e5bdc9f8f7 430 }
klauss 91:c2a86b1f8aaa 431
klauss 62:07e5bdc9f8f7 432 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 91:c2a86b1f8aaa 433
klauss 62:07e5bdc9f8f7 434 char aux[ 16 ];
klauss 78:1353744f01e1 435 strcpy( str, "\r\n> " );
klauss 91:c2a86b1f8aaa 436 for( i = 0; i < v_cb->size() - 1; i++ ) {
klauss 62:07e5bdc9f8f7 437 sprintf( aux, "%i, ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 438 strcat( str, aux );
klauss 78:1353744f01e1 439 if( ( i != 0 ) && !( ( i + 1 ) % 16 ) ) strcat( str, "\r\n> " );
klauss 62:07e5bdc9f8f7 440 }
klauss 62:07e5bdc9f8f7 441 sprintf( aux, "%i ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 442 strcat( str, aux );
klauss 62:07e5bdc9f8f7 443 send_msg( "%s", str );
klauss 62:07e5bdc9f8f7 444 }
klauss 91:c2a86b1f8aaa 445 list = false;
klauss 108:18a3702650f3 446 }
klauss 106:a34fcf9f0e02 447
klauss 106:a34fcf9f0e02 448 // validar na proxima iteracao.
klauss 106:a34fcf9f0e02 449 if( long_list )
klauss 106:a34fcf9f0e02 450 {
klauss 106:a34fcf9f0e02 451 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 91:c2a86b1f8aaa 452
klauss 106:a34fcf9f0e02 453 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 106:a34fcf9f0e02 454
klauss 106:a34fcf9f0e02 455 if( min_ext % 2 ) missed_cb++;
klauss 106:a34fcf9f0e02 456
klauss 106:a34fcf9f0e02 457 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 106:a34fcf9f0e02 458
klauss 106:a34fcf9f0e02 459 {
klauss 106:a34fcf9f0e02 460 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 106:a34fcf9f0e02 461
klauss 106:a34fcf9f0e02 462 if( v_cb->size() >= 1 ) {
klauss 106:a34fcf9f0e02 463 for( register int i = 0; i < v_cb->size(); i++ )
klauss 106:a34fcf9f0e02 464 {
klauss 106:a34fcf9f0e02 465 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 106:a34fcf9f0e02 466 }
klauss 106:a34fcf9f0e02 467 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 106:a34fcf9f0e02 468 }
klauss 106:a34fcf9f0e02 469
klauss 106:a34fcf9f0e02 470 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 106:a34fcf9f0e02 471
klauss 106:a34fcf9f0e02 472 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 106:a34fcf9f0e02 473
klauss 106:a34fcf9f0e02 474 Call_Box * cb = __find_CB__( v_cb, ext_list[ i ] );
klauss 106:a34fcf9f0e02 475
klauss 106:a34fcf9f0e02 476 if( cb != NULL )
klauss 106:a34fcf9f0e02 477 {
klauss 106:a34fcf9f0e02 478 char cb_status[ 32 ];
klauss 106:a34fcf9f0e02 479 char cb_sip_status[ 32 ];
klauss 106:a34fcf9f0e02 480 switch( cb->status ) {
klauss 106:a34fcf9f0e02 481 case cb_idle : {
klauss 106:a34fcf9f0e02 482 strcpy( cb_status, "cb_idle" );
klauss 106:a34fcf9f0e02 483 break;
klauss 106:a34fcf9f0e02 484 }
klauss 106:a34fcf9f0e02 485 case cb_ringing : {
klauss 106:a34fcf9f0e02 486 strcpy( cb_status, "cb_ringing" );
klauss 106:a34fcf9f0e02 487 break;
klauss 106:a34fcf9f0e02 488 }
klauss 106:a34fcf9f0e02 489 case cb_trying : {
klauss 106:a34fcf9f0e02 490 strcpy( cb_status,"cb_trying" );
klauss 106:a34fcf9f0e02 491 break;
klauss 106:a34fcf9f0e02 492 }
klauss 106:a34fcf9f0e02 493 case cb_on_call : {
klauss 106:a34fcf9f0e02 494 strcpy( cb_status, "cb_on_call" );
klauss 106:a34fcf9f0e02 495 break;
klauss 106:a34fcf9f0e02 496 }
klauss 106:a34fcf9f0e02 497 case cb_busy : {
klauss 106:a34fcf9f0e02 498 strcpy( cb_status, "cb_busy" );
klauss 106:a34fcf9f0e02 499 break;
klauss 106:a34fcf9f0e02 500 }
klauss 106:a34fcf9f0e02 501 case cb_denied : {
klauss 106:a34fcf9f0e02 502 strcpy( cb_status, "cb_denied" );
klauss 106:a34fcf9f0e02 503 break;
klauss 106:a34fcf9f0e02 504 }
klauss 106:a34fcf9f0e02 505 }
klauss 106:a34fcf9f0e02 506 switch( cb->sip->status ) {
klauss 106:a34fcf9f0e02 507 case sip_idle : {
klauss 106:a34fcf9f0e02 508 strcpy( cb_sip_status, "sip_idle" );
klauss 106:a34fcf9f0e02 509 break;
klauss 106:a34fcf9f0e02 510 }
klauss 106:a34fcf9f0e02 511 case sip_waiting_trying : {
klauss 106:a34fcf9f0e02 512 strcpy( cb_sip_status, "sip_waiting_trying" );
klauss 106:a34fcf9f0e02 513 break;
klauss 106:a34fcf9f0e02 514 }
klauss 106:a34fcf9f0e02 515 case sip_trying : {
klauss 106:a34fcf9f0e02 516 strcpy( cb_sip_status, "sip_trying" );
klauss 106:a34fcf9f0e02 517 break;
klauss 106:a34fcf9f0e02 518 }
klauss 106:a34fcf9f0e02 519 case sip_ringing : {
klauss 106:a34fcf9f0e02 520 strcpy( cb_sip_status, "sip_ringing" );
klauss 106:a34fcf9f0e02 521 break;
klauss 106:a34fcf9f0e02 522 }
klauss 106:a34fcf9f0e02 523 case sip_busy : {
klauss 106:a34fcf9f0e02 524 strcpy( cb_sip_status, "sip_busy" );
klauss 106:a34fcf9f0e02 525 break;
klauss 106:a34fcf9f0e02 526 }
klauss 106:a34fcf9f0e02 527 case sip_ok : {
klauss 106:a34fcf9f0e02 528 strcpy( cb_sip_status, "sip_ok" );
klauss 106:a34fcf9f0e02 529 break;
klauss 106:a34fcf9f0e02 530 }
klauss 106:a34fcf9f0e02 531 case sip_on_call : {
klauss 106:a34fcf9f0e02 532 strcpy( cb_sip_status, "sip_on_call" );
klauss 106:a34fcf9f0e02 533 break;
klauss 106:a34fcf9f0e02 534 }
klauss 106:a34fcf9f0e02 535 case sip_denied : {
klauss 106:a34fcf9f0e02 536 strcpy( cb_sip_status, "sip_denied" );
klauss 106:a34fcf9f0e02 537 break;
klauss 106:a34fcf9f0e02 538 }
klauss 106:a34fcf9f0e02 539 }
klauss 106:a34fcf9f0e02 540 char cbx_to_string[ 254 ];
klauss 106:a34fcf9f0e02 541 char aux[ 16 ];
klauss 106:a34fcf9f0e02 542 strcpy( cbx_to_string, "Ext :: " );
klauss 106:a34fcf9f0e02 543 itoa( cb->get_ext(), aux , 10 );
klauss 106:a34fcf9f0e02 544 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 545 strcat( cbx_to_string, " :: Port :: " );
klauss 106:a34fcf9f0e02 546 itoa( cb->get_port(), aux , 10 );
klauss 106:a34fcf9f0e02 547 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 548 strcat( cbx_to_string, " :: Status -- " );
klauss 106:a34fcf9f0e02 549 strcat( cbx_to_string, cb_status );
klauss 106:a34fcf9f0e02 550 strcat( cbx_to_string, " - " );
klauss 106:a34fcf9f0e02 551 strcat( cbx_to_string, cb_sip_status );
klauss 106:a34fcf9f0e02 552 if( cb->get_timeslice() != 0 ) {
klauss 106:a34fcf9f0e02 553 strcat( cbx_to_string, " -- on TimeSlice :: " );
klauss 106:a34fcf9f0e02 554 itoa( cb->get_timeslice(), aux , 10 );
klauss 106:a34fcf9f0e02 555 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 556 }
klauss 106:a34fcf9f0e02 557 send_msg( cbx_to_string );
klauss 106:a34fcf9f0e02 558 }
klauss 106:a34fcf9f0e02 559 }
klauss 106:a34fcf9f0e02 560
klauss 106:a34fcf9f0e02 561 }
klauss 91:c2a86b1f8aaa 562 long_list = false;
klauss 52:12930cef17c4 563 }
klauss 106:a34fcf9f0e02 564
klauss 106:a34fcf9f0e02 565
klauss 91:c2a86b1f8aaa 566
klauss 105:a930035b6556 567 // exibe uma lista de cbx por ordem de registro contendo status do cbx e do sip vinculado nesse cbx
klauss 106:a34fcf9f0e02 568 if( pshowcb == true )
klauss 106:a34fcf9f0e02 569 {
klauss 78:1353744f01e1 570 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() );
klauss 91:c2a86b1f8aaa 571 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 30:8dfb6d8de53d 572 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 78:1353744f01e1 573 char cb_status[ 32 ];
klauss 78:1353744f01e1 574 char cb_sip_status[ 32 ];
klauss 91:c2a86b1f8aaa 575 switch( cb->status ) {
klauss 91:c2a86b1f8aaa 576 case cb_idle : {
klauss 91:c2a86b1f8aaa 577 strcpy( cb_status, "cb_idle" );
klauss 91:c2a86b1f8aaa 578 break;
klauss 91:c2a86b1f8aaa 579 }
klauss 91:c2a86b1f8aaa 580 case cb_ringing : {
klauss 91:c2a86b1f8aaa 581 strcpy( cb_status, "cb_ringing" );
klauss 91:c2a86b1f8aaa 582 break;
klauss 91:c2a86b1f8aaa 583 }
klauss 91:c2a86b1f8aaa 584 case cb_trying : {
klauss 91:c2a86b1f8aaa 585 strcpy( cb_status,"cb_trying" );
klauss 91:c2a86b1f8aaa 586 break;
klauss 91:c2a86b1f8aaa 587 }
klauss 91:c2a86b1f8aaa 588 case cb_on_call : {
klauss 91:c2a86b1f8aaa 589 strcpy( cb_status, "cb_on_call" );
klauss 91:c2a86b1f8aaa 590 break;
klauss 91:c2a86b1f8aaa 591 }
klauss 91:c2a86b1f8aaa 592 case cb_busy : {
klauss 91:c2a86b1f8aaa 593 strcpy( cb_status, "cb_busy" );
klauss 91:c2a86b1f8aaa 594 break;
klauss 91:c2a86b1f8aaa 595 }
klauss 91:c2a86b1f8aaa 596 case cb_denied : {
klauss 91:c2a86b1f8aaa 597 strcpy( cb_status, "cb_denied" );
klauss 91:c2a86b1f8aaa 598 break;
klauss 91:c2a86b1f8aaa 599 }
klauss 78:1353744f01e1 600 }
klauss 91:c2a86b1f8aaa 601 switch( cb->sip->status ) {
klauss 91:c2a86b1f8aaa 602 case sip_idle : {
klauss 91:c2a86b1f8aaa 603 strcpy( cb_sip_status, "sip_idle" );
klauss 91:c2a86b1f8aaa 604 break;
klauss 91:c2a86b1f8aaa 605 }
klauss 91:c2a86b1f8aaa 606 case sip_waiting_trying : {
klauss 91:c2a86b1f8aaa 607 strcpy( cb_sip_status, "sip_waiting_trying" );
klauss 91:c2a86b1f8aaa 608 break;
klauss 91:c2a86b1f8aaa 609 }
klauss 91:c2a86b1f8aaa 610 case sip_trying : {
klauss 91:c2a86b1f8aaa 611 strcpy( cb_sip_status, "sip_trying" );
klauss 91:c2a86b1f8aaa 612 break;
klauss 91:c2a86b1f8aaa 613 }
klauss 91:c2a86b1f8aaa 614 case sip_ringing : {
klauss 91:c2a86b1f8aaa 615 strcpy( cb_sip_status, "sip_ringing" );
klauss 91:c2a86b1f8aaa 616 break;
klauss 91:c2a86b1f8aaa 617 }
klauss 91:c2a86b1f8aaa 618 case sip_busy : {
klauss 91:c2a86b1f8aaa 619 strcpy( cb_sip_status, "sip_busy" );
klauss 91:c2a86b1f8aaa 620 break;
klauss 91:c2a86b1f8aaa 621 }
klauss 91:c2a86b1f8aaa 622 case sip_ok : {
klauss 91:c2a86b1f8aaa 623 strcpy( cb_sip_status, "sip_ok" );
klauss 91:c2a86b1f8aaa 624 break;
klauss 91:c2a86b1f8aaa 625 }
klauss 91:c2a86b1f8aaa 626 case sip_on_call : {
klauss 91:c2a86b1f8aaa 627 strcpy( cb_sip_status, "sip_on_call" );
klauss 91:c2a86b1f8aaa 628 break;
klauss 91:c2a86b1f8aaa 629 }
klauss 91:c2a86b1f8aaa 630 case sip_denied : {
klauss 91:c2a86b1f8aaa 631 strcpy( cb_sip_status, "sip_denied" );
klauss 91:c2a86b1f8aaa 632 break;
klauss 91:c2a86b1f8aaa 633 }
klauss 78:1353744f01e1 634 }
klauss 78:1353744f01e1 635 char cbx_to_string[ 254 ];
klauss 78:1353744f01e1 636 char aux[ 16 ];
klauss 78:1353744f01e1 637 strcpy( cbx_to_string, "Ext :: " );
klauss 78:1353744f01e1 638 itoa( cb->get_ext(), aux , 10 );
klauss 98:43b45f26b430 639 strcat( cbx_to_string, aux );
klauss 97:8985817e8847 640 strcat( cbx_to_string, " :: Port :: " );
klauss 97:8985817e8847 641 itoa( cb->get_port(), aux , 10 );
klauss 78:1353744f01e1 642 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 643 strcat( cbx_to_string, " :: Status -- " );
klauss 78:1353744f01e1 644 strcat( cbx_to_string, cb_status );
klauss 78:1353744f01e1 645 strcat( cbx_to_string, " - " );
klauss 78:1353744f01e1 646 strcat( cbx_to_string, cb_sip_status );
klauss 91:c2a86b1f8aaa 647 if( cb->get_timeslice() != 0 ) {
klauss 78:1353744f01e1 648 strcat( cbx_to_string, " -- on TimeSlice :: " );
klauss 78:1353744f01e1 649 itoa( cb->get_timeslice(), aux , 10 );
klauss 78:1353744f01e1 650 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 651 }
klauss 78:1353744f01e1 652 send_msg( cbx_to_string );
klauss 48:195c97f12e8e 653 }
klauss 78:1353744f01e1 654 pshowcb = false;
klauss 48:195c97f12e8e 655 }
klauss 97:8985817e8847 656
klauss 105:a930035b6556 657 // exibe Ramal e Porta do objeto SIP associado a cada cbx
klauss 105:a930035b6556 658 // assim como exibe um timer crescente em segundos, desde o ultimo pacote recebido deste cbx respondendo registro.
klauss 97:8985817e8847 659 if( show_sip == true ){
klauss 97:8985817e8847 660 show_sip = false;
klauss 99:e80850c51106 661 send_msg(":: Sip :: %u", v_cb->size() );
klauss 97:8985817e8847 662 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 97:8985817e8847 663 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 108:18a3702650f3 664 if( cb != NULL ) send_msg("ext :: %d -- port :: %d -- timer %d", cb->get_sip_ext(), cb->get_sip_port(), cb->get_timer() );
klauss 97:8985817e8847 665 }
klauss 97:8985817e8847 666 }
klauss 106:a34fcf9f0e02 667
klauss 108:18a3702650f3 668 if( dshow_rtp == true ){
klauss 108:18a3702650f3 669 dshow_rtp = false;
klauss 108:18a3702650f3 670 send_msg(":: RTP :: %u", v_cb->size() );
klauss 108:18a3702650f3 671
klauss 108:18a3702650f3 672 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 108:18a3702650f3 673
klauss 108:18a3702650f3 674 if( v_cb->size() >= 1 ) {
klauss 108:18a3702650f3 675 for( register int i = 0; i < v_cb->size(); i++ )
klauss 108:18a3702650f3 676 {
klauss 108:18a3702650f3 677 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 108:18a3702650f3 678 }
klauss 108:18a3702650f3 679 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 108:18a3702650f3 680 }
klauss 108:18a3702650f3 681
klauss 108:18a3702650f3 682 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 108:18a3702650f3 683 {
klauss 108:18a3702650f3 684 Call_Box * cb = __find_CB__( v_cb, ext_list[ i ] );
klauss 108:18a3702650f3 685 if( cb != NULL )
klauss 108:18a3702650f3 686 {
klauss 108:18a3702650f3 687 send_msg("CBX ( %d, %d ) - SIP ( %d, %d ) - RTP ( %d ) - Timer ( %d )",
klauss 108:18a3702650f3 688 cb -> get_ext (),
klauss 108:18a3702650f3 689 cb -> get_port (),
klauss 108:18a3702650f3 690 cb -> get_sip_ext (),
klauss 108:18a3702650f3 691 cb -> get_sip_port (),
klauss 108:18a3702650f3 692 cb -> get_rtp_port (),
klauss 108:18a3702650f3 693 cb -> get_rtp_timer ()
klauss 108:18a3702650f3 694 );
klauss 108:18a3702650f3 695 }
klauss 108:18a3702650f3 696 }
klauss 108:18a3702650f3 697 }
klauss 106:a34fcf9f0e02 698
klauss 108:18a3702650f3 699 if( dcallshow_rtp == true ){
klauss 108:18a3702650f3 700 dcallshow_rtp = false;
klauss 108:18a3702650f3 701 send_msg(":: CAll RTP :: %u", v_call->size() );
klauss 108:18a3702650f3 702 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 108:18a3702650f3 703 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 108:18a3702650f3 704 if( call != NULL )
klauss 108:18a3702650f3 705 {
klauss 108:18a3702650f3 706 send_msg("CBX ( %d, %d ) - Server ( %d, %d )",
klauss 108:18a3702650f3 707 call->get_cb_ext(),
klauss 108:18a3702650f3 708 call->get_cb_port(),
klauss 108:18a3702650f3 709 call->get_rtp_server_ext(),
klauss 108:18a3702650f3 710 call->get_rtp_server_port()
klauss 108:18a3702650f3 711 );
klauss 108:18a3702650f3 712 }
klauss 108:18a3702650f3 713 }
klauss 108:18a3702650f3 714 }
klauss 91:c2a86b1f8aaa 715
klauss 105:a930035b6556 716 // aciona rotina de envio de pacote de flood
klauss 81:3656f00ab3db 717 if( pflood == true ) flood();
klauss 106:a34fcf9f0e02 718
klauss 106:a34fcf9f0e02 719
klauss 91:c2a86b1f8aaa 720
klauss 105:a930035b6556 721 // exibe status de conexao ETH
klauss 91:c2a86b1f8aaa 722 if( debug_eth ) {
klauss 81:3656f00ab3db 723 debug_eth = false;
klauss 81:3656f00ab3db 724 send_msg("Eth status %s", ( eth_status == 0 ) ? "Connected" : "Disconnected" );
klauss 81:3656f00ab3db 725 }
klauss 106:a34fcf9f0e02 726
klauss 106:a34fcf9f0e02 727
klauss 91:c2a86b1f8aaa 728
klauss 105:a930035b6556 729 // testa se existe um pacote recebido pela interface CBx->Header pendente para ser processado.
klauss 91:c2a86b1f8aaa 730 if( status != __WAITING__ ) {
klauss 81:3656f00ab3db 731 pkg_wdt = RX_CB_IDLE;
klauss 105:a930035b6556 732 xmemcpy( cb_rx_buffer, buffer_from_cb_ptr, CB_BUFFER_SIZE );
klauss 0:4d17cd9c8f9d 733 status = __WAITING__;
klauss 81:3656f00ab3db 734 missed_pkg--;
klauss 105:a930035b6556 735 xmemcpy( buffer, cb_rx_buffer, CB_BUFFER_SIZE );
klauss 91:c2a86b1f8aaa 736
klauss 105:a930035b6556 737 // exibe esta pacote caso seja solicitado
klauss 105:a930035b6556 738 // TODO implementar um debug que exibe somente, todos os pacotes recebidos
klauss 91:c2a86b1f8aaa 739 if( rx ) {
klauss 81:3656f00ab3db 740 char str[ 1024 ];
klauss 81:3656f00ab3db 741 strcpy( str, "RX :: \n\r " );
klauss 105:a930035b6556 742 for( register uint16_t i = 0; i < CB_BUFFER_SIZE; i++ ) {
klauss 81:3656f00ab3db 743 char tmp[ 16 ];
klauss 81:3656f00ab3db 744 strcat( str, itoa( cb_rx_buffer[ i ], tmp, 16 ) );
klauss 81:3656f00ab3db 745 if( ( i != 0 ) && !( ( i + 1 ) % 50 ) ) strcat( str, "\n\r " );
klauss 91:c2a86b1f8aaa 746
klauss 81:3656f00ab3db 747 else strcat( str, " " );
klauss 81:3656f00ab3db 748 }
klauss 81:3656f00ab3db 749 send_msg( "%s", str );
klauss 91:c2a86b1f8aaa 750 rx = false;
klauss 81:3656f00ab3db 751 }
klauss 105:a930035b6556 752
klauss 105:a930035b6556 753 // chama rotina para interpretar e validar o pacote recebido
klauss 105:a930035b6556 754 data = parse_vz_pkg( &ext, &port, &type, buffer );
klauss 91:c2a86b1f8aaa 755
klauss 105:a930035b6556 756 // caso parse_vz_pkg tenha retorno diferente de NULL, trata-se de um pacote valido para ser processado
klauss 91:c2a86b1f8aaa 757 if( data != NULL ) {
klauss 105:a930035b6556 758 // atualiza referencias de menor e maior ramal conhecidos ate o momento
klauss 78:1353744f01e1 759 if( min_ext == 0 ) min_ext = ext;
klauss 91:c2a86b1f8aaa 760
klauss 78:1353744f01e1 761 if( ext > max_ext ) max_ext = ext;
klauss 91:c2a86b1f8aaa 762
klauss 78:1353744f01e1 763 if( ext < min_ext ) min_ext = ext;
klauss 99:e80850c51106 764
klauss 105:a930035b6556 765 // verifica se precisa "exportar" esse pacote para debug externo
klauss 99:e80850c51106 766 if( debug_fw ){
klauss 99:e80850c51106 767 fw_cbx_pkg( ext, port, ( char *)buffer );
klauss 99:e80850c51106 768 }
klauss 99:e80850c51106 769
klauss 105:a930035b6556 770 // por decisao de projeto, todos os pacote de telemetria sao exportados para parse no servidor
klauss 104:62646ef786a3 771 if( type == __TELEMETRY__ )
klauss 104:62646ef786a3 772 {
klauss 104:62646ef786a3 773 telemetry_counter++;
klauss 104:62646ef786a3 774 //FIXME colocar o dtelos aqui
klauss 104:62646ef786a3 775 }
klauss 105:a930035b6556 776
klauss 105:a930035b6556 777 // alguns tratamentos adicionais que sao pertinentes em caso de pacotes diferentes do tipo __AUDIO__
klauss 105:a930035b6556 778 if( type != __AUDIO__ )
klauss 105:a930035b6556 779 {
klauss 105:a930035b6556 780 // vefifica quais pacotes precisam ser exportados para o servidor e faz a substituicao do typo para __FW__ sem com isso
klauss 105:a930035b6556 781 // alterar o pacote de origem.
klauss 99:e80850c51106 782 if(
klauss 99:e80850c51106 783 type == __TELEMETRY__ ||
klauss 99:e80850c51106 784 type == __CB_STATS__ ||
klauss 99:e80850c51106 785 type == __FW1__ ||
klauss 99:e80850c51106 786 type == __FW2__ ||
klauss 99:e80850c51106 787 type == __FW3__ ||
klauss 99:e80850c51106 788 type == __FW4__ ||
klauss 99:e80850c51106 789 type == __FW5__ ||
klauss 99:e80850c51106 790 type == __FW6__
klauss 99:e80850c51106 791 ) type = __FW__;
klauss 99:e80850c51106 792
klauss 105:a930035b6556 793 // exibe que o pacote foi recebido porem sem exibir o conteudo do pacote, apenas ramal e porta do remetente e tipo do pkg
klauss 99:e80850c51106 794 if( debug_cb_rx == true ){
klauss 99:e80850c51106 795 send_msg("Pkg from CBx :: ( %d, %d ) -- Type :: %d", ext, port, type );
klauss 99:e80850c51106 796 }
klauss 105:a930035b6556 797
klauss 105:a930035b6556 798 // exibe o pacote recebido propriamente
klauss 105:a930035b6556 799 if( debug_show_cpld )
klauss 105:a930035b6556 800 {
klauss 105:a930035b6556 801 char str[ 1024 ];
klauss 105:a930035b6556 802 strcpy( str, "RX :: \n\r " );
klauss 105:a930035b6556 803 for( register uint16_t i = 0; i < CB_BUFFER_SIZE; i++ ) {
klauss 105:a930035b6556 804 char tmp[ 16 ];
klauss 105:a930035b6556 805 strcat( str, itoa( cb_rx_buffer[ i ], tmp, 16 ) );
klauss 105:a930035b6556 806 if( ( i != 0 ) && !( ( i + 1 ) % 50 ) ) strcat( str, "\n\r " );
klauss 105:a930035b6556 807
klauss 105:a930035b6556 808 else strcat( str, " " );
klauss 105:a930035b6556 809 }
klauss 105:a930035b6556 810 send_msg( "%s", str );
klauss 105:a930035b6556 811 }
klauss 99:e80850c51106 812
klauss 105:a930035b6556 813 // verificacoes de ACKS
klauss 0:4d17cd9c8f9d 814 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 815 if( cb != NULL ) {
klauss 92:92df17f538a8 816 if( data[ 0 ] & BIT7 ) {
klauss 91:c2a86b1f8aaa 817 if( type == __BOOT__ ) {
klauss 105:a930035b6556 818 send2callboxes( build_cb_package( ext, port, __REGISTRY__,
klauss 105:a930035b6556 819 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 92:92df17f538a8 820 } else {
klauss 81:3656f00ab3db 821 if( debug_main ) debug_msg("Received ack pkg with seq_num %d", data[ 0 ] );
klauss 91:c2a86b1f8aaa 822
klauss 91:c2a86b1f8aaa 823 switch( type ) {
klauss 81:3656f00ab3db 824 case __INVITE__ : {
klauss 81:3656f00ab3db 825 if( debug_main || debug_invite ) debug_msg("Invite Ack from %d on msg_id %d", ext, cb->get_msg_id() );
klauss 91:c2a86b1f8aaa 826 break;
klauss 81:3656f00ab3db 827 }
klauss 81:3656f00ab3db 828 case __CB_BYE__ : {
klauss 81:3656f00ab3db 829 if( debug_main || debug_invite ) debug_msg("BYE Ack from %d on msg_id %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 830 cb->set_bye_response_ok();
klauss 91:c2a86b1f8aaa 831 break;
klauss 81:3656f00ab3db 832 }
klauss 81:3656f00ab3db 833 case __REGISTRY__ : {
klauss 81:3656f00ab3db 834 if( debug_main || debug_aging ) debug_msg("Registry ACK from %d in pkg :: %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 835 break;
klauss 81:3656f00ab3db 836 }
klauss 81:3656f00ab3db 837 default : {
klauss 91:c2a86b1f8aaa 838 if( debug_main || debug_aging ) debug_msg("ACK from %d in pkg :: %d :: type %d", ext, cb->get_msg_id(), type );
klauss 91:c2a86b1f8aaa 839 }
klauss 81:3656f00ab3db 840 }
klauss 92:92df17f538a8 841 if( type != __REGISTRY__ && type != __CB_BYE__ ) type = __DO_NOTHING__;
klauss 92:92df17f538a8 842 if( type == __CB_BYE__ ){
klauss 92:92df17f538a8 843 VZ_call * call = __find_Call__( v_call, ext );
klauss 92:92df17f538a8 844 if( call != NULL ){
klauss 92:92df17f538a8 845 if( call->get_elapsed_time() < 120000 ){
klauss 105:a930035b6556 846 // devido a um bug na implementacao do protocolo, eventualmente o cbx envia
klauss 105:a930035b6556 847 // um pacote de bye nao intencional que encerrava ligacoes precocemente
klauss 105:a930035b6556 848 // solucao encontrada, colocado um timer de controle.
klauss 92:92df17f538a8 849 if( debug_invite ) debug_msg("%d ack bye ignored", ext );
klauss 92:92df17f538a8 850 type = __DO_NOTHING__;
klauss 92:92df17f538a8 851 }
klauss 92:92df17f538a8 852 }
klauss 92:92df17f538a8 853 }
klauss 0:4d17cd9c8f9d 854 }
klauss 0:4d17cd9c8f9d 855 }
klauss 0:4d17cd9c8f9d 856 }
klauss 0:4d17cd9c8f9d 857 }
klauss 91:c2a86b1f8aaa 858 } else type = __DO_NOTHING__;
klauss 0:4d17cd9c8f9d 859 }
klauss 105:a930035b6556 860
klauss 105:a930035b6556 861 // exibe uptime atual
klauss 105:a930035b6556 862 if( show_uptime )
klauss 105:a930035b6556 863 {
klauss 105:a930035b6556 864 show_uptime = false;
klauss 105:a930035b6556 865 send_msg("Uptime: %d", uptime );
klauss 108:18a3702650f3 866 }
klauss 91:c2a86b1f8aaa 867
klauss 105:a930035b6556 868 // exibe algumas informacoes pertinentes sobre quantidade de variaveis alocadas e tamanho de alguns objetos.
klauss 104:62646ef786a3 869 if( sizes == true ) {
klauss 104:62646ef786a3 870 sizes = false;
klauss 85:b6f2dc1d0f4f 871 send_msg("CB_New (%u) -- CB_Delete (%u)", cb_new_counter, cb_delete_counter );
klauss 85:b6f2dc1d0f4f 872 send_msg("SIP_New (%u) -- SIP_Delete (%u)", sip_new_counter, sip_delete_counter );
klauss 87:679ee0d594a9 873 send_msg("RTP_header_New (%u) -- RTP_header_Delete (%u)", rtp_header_new_counter, rtp_header_delete_counter );
klauss 87:679ee0d594a9 874 send_msg("RTP_body_New (%u) -- RTP_body_Delete (%u)", rtp_body_new_counter, rtp_body_delete_counter );
klauss 107:cf1e43414adb 875 send_msg("Call_New (%u) -- Call_Delete (%u)", call_new_counter, call_delete_counter );
klauss 87:679ee0d594a9 876 send_msg("lpc_low_level_input_counter :: %d", lpc_low_level_input_counter );
klauss 87:679ee0d594a9 877 send_msg("Memory is %s", ( memory_is_over ) ? "Over" : "Ok" );
klauss 81:3656f00ab3db 878 send_msg("Missed_Pkg :: %d ::", missed_pkg );
klauss 87:679ee0d594a9 879 send_msg("Sizeof Sip :: %u", sizeof( Sip ) );
klauss 87:679ee0d594a9 880 send_msg("Sizeof Call_Box :: %u", sizeof( Call_Box ) );
klauss 87:679ee0d594a9 881 send_msg("Sizeof VZ_call :: %u", sizeof( VZ_call ) );
klauss 87:679ee0d594a9 882 send_msg("Sizeof RTP :: %u", sizeof( RTP ) );
klauss 87:679ee0d594a9 883 send_msg("Sizeof RTP_Header :: %u", sizeof( RTP_Header ) );
klauss 87:679ee0d594a9 884 send_msg("Sizeof RTP_Body :: %u", sizeof( RTP_Body ) );
klauss 87:679ee0d594a9 885 send_msg("Sizeof Vector :: %u", sizeof( Vector ) );
klauss 87:679ee0d594a9 886 send_msg("Sizeof Timeslice :: %u", sizeof( Timeslice ) );
klauss 87:679ee0d594a9 887 send_msg("Sizeof Watchdog :: %u", sizeof( Watchdog ) );
klauss 81:3656f00ab3db 888 }
klauss 106:a34fcf9f0e02 889
klauss 106:a34fcf9f0e02 890
klauss 91:c2a86b1f8aaa 891
klauss 105:a930035b6556 892 // zera os contadores de cks de pacotes recebidos na interface CBx->Header, e outros contadores relacionados
klauss 91:c2a86b1f8aaa 893 if( reset_cks == true ) {
klauss 81:3656f00ab3db 894 pkg_cksok = 0;
klauss 81:3656f00ab3db 895 pkg_ckserr = 0;
klauss 99:e80850c51106 896 pkg_zero = 0;
klauss 81:3656f00ab3db 897 reset_cks = false;
klauss 99:e80850c51106 898 out_of_range = 0;
klauss 99:e80850c51106 899 missed_pkg = 0;
klauss 100:09a23fcd3bdf 900 delayed_pkg_to_cb = 0;
klauss 99:e80850c51106 901 cpld_pkg_tx_counter = 0;
klauss 99:e80850c51106 902 cpld_pkg_rx_counter = 0;
klauss 81:3656f00ab3db 903 pcks_s = true;
klauss 81:3656f00ab3db 904 }
klauss 91:c2a86b1f8aaa 905
klauss 105:a930035b6556 906 // exibe os contadores de cks de pacotes recebidos na interface CBx->Header, e outros contadores relacionados
klauss 91:c2a86b1f8aaa 907 if( pcks_s == true ) {
klauss 105:a930035b6556 908 send_msg(
klauss 105:a930035b6556 909 "\r\n"
klauss 105:a930035b6556 910 " PKG_CKS OK: %d ( %003.2f )\r\n"
klauss 105:a930035b6556 911 " PKG_CKS ERR: %d ( %003.2f )\r\n"
klauss 105:a930035b6556 912 " PKG_0: %d ( %003.2f )\r\n"
klauss 105:a930035b6556 913 " Out_of_range: %d ( %003.2f )\r\n"
klauss 105:a930035b6556 914 " Miss_Pkg: %d\r\n"
klauss 105:a930035b6556 915 " TX_delayed: %d\n\r"
klauss 105:a930035b6556 916 " TX_Counter: %d\n\r"
klauss 105:a930035b6556 917 " RX_Counter: %d\r\n",
klauss 105:a930035b6556 918 pkg_cksok, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_cksok / cpld_pkg_rx_counter ) * 100,
klauss 105:a930035b6556 919 pkg_ckserr, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_ckserr / cpld_pkg_rx_counter ) * 100,
klauss 105:a930035b6556 920 pkg_zero, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_zero / cpld_pkg_rx_counter ) * 100,
klauss 105:a930035b6556 921 out_of_range, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) out_of_range / cpld_pkg_rx_counter ) * 100,
klauss 105:a930035b6556 922 missed_pkg,
klauss 105:a930035b6556 923 delayed_pkg_to_cb,
klauss 105:a930035b6556 924 cpld_pkg_tx_counter,
klauss 105:a930035b6556 925 cpld_pkg_rx_counter
klauss 105:a930035b6556 926 );
klauss 81:3656f00ab3db 927 pcks_s = false;
klauss 81:3656f00ab3db 928 }
klauss 105:a930035b6556 929
klauss 105:a930035b6556 930 // zera os contadores de pacotes que resultaram em falha de envio vio ETH
klauss 105:a930035b6556 931 if( reset_missed_send_udp_pkg ){
klauss 105:a930035b6556 932 miss_fw_send_pkg = 0;
klauss 105:a930035b6556 933 miss_prompt_udp_send_pkg = 0;
klauss 105:a930035b6556 934 miss_sip_registry_send_pkg = 0;
klauss 105:a930035b6556 935 miss_sip_invite_send_pkg = 0;
klauss 105:a930035b6556 936 miss_sip_bye_send_pkg = 0;
klauss 105:a930035b6556 937 miss_sip_unregistry_send_pkg = 0;
klauss 105:a930035b6556 938 miss_sip_ok_send_pkg = 0;
klauss 105:a930035b6556 939 miss_sip_rcv_bye_send_pkg = 0;
klauss 105:a930035b6556 940 miss_wdt_send_pkg = 0;
klauss 105:a930035b6556 941 miss_prompt_udp_send_pkg = 0;
klauss 105:a930035b6556 942 miss_ftp_udp_send_pkg = 0;
klauss 105:a930035b6556 943 miss_prompt_udp_rcv_pkg = 0;
klauss 105:a930035b6556 944 reset_missed_send_udp_pkg = false;
klauss 105:a930035b6556 945 missed_send_udp_pkg = true;
klauss 105:a930035b6556 946 }
klauss 105:a930035b6556 947
klauss 106:a34fcf9f0e02 948
klauss 106:a34fcf9f0e02 949
klauss 105:a930035b6556 950 // exibe estatisticas de pacotes que resultaram em falha de envio na interface ETH
klauss 105:a930035b6556 951 if( missed_send_udp_pkg )
klauss 105:a930035b6556 952 {
klauss 105:a930035b6556 953 send_msg( "\r\nMissed pkgs ::\r\n "
klauss 105:a930035b6556 954 "FW: %d\r\n "
klauss 105:a930035b6556 955 "Prompt UDP %d\r\n "
klauss 105:a930035b6556 956 "Registry %d\r\n "
klauss 105:a930035b6556 957 "Invite %d\r\n "
klauss 105:a930035b6556 958 "Bye %d\r\n "
klauss 105:a930035b6556 959 "Unregistry %d\r\n "
klauss 105:a930035b6556 960 "UDP incoming ( invite ans ) %d\r\n "
klauss 105:a930035b6556 961 "UDP incoming ( bye from * ) %d\r\n "
klauss 105:a930035b6556 962 "Wdt [ alive | rst ] %d\r\n "
klauss 105:a930035b6556 963 "Rcv prompt %d\r\n "
klauss 105:a930035b6556 964 "[ debug | send ]_msg %d\r\n "
klauss 105:a930035b6556 965 "RTP %d\r\n",
klauss 105:a930035b6556 966 miss_fw_send_pkg,
klauss 105:a930035b6556 967 miss_prompt_udp_send_pkg,
klauss 105:a930035b6556 968 miss_sip_registry_send_pkg,
klauss 105:a930035b6556 969 miss_sip_invite_send_pkg,
klauss 105:a930035b6556 970 miss_sip_bye_send_pkg,
klauss 105:a930035b6556 971 miss_sip_unregistry_send_pkg,
klauss 105:a930035b6556 972 miss_sip_ok_send_pkg,
klauss 105:a930035b6556 973 miss_sip_rcv_bye_send_pkg,
klauss 105:a930035b6556 974 miss_wdt_send_pkg,
klauss 105:a930035b6556 975 miss_prompt_udp_send_pkg,
klauss 105:a930035b6556 976 miss_prompt_udp_rcv_pkg,
klauss 105:a930035b6556 977 miss_ftp_udp_send_pkg
klauss 105:a930035b6556 978 );
klauss 105:a930035b6556 979
klauss 105:a930035b6556 980 missed_send_udp_pkg = false;
klauss 105:a930035b6556 981 }
klauss 105:a930035b6556 982
klauss 106:a34fcf9f0e02 983
klauss 105:a930035b6556 984 // rotina de teste para sobrecarga do processamento do cbx.
klauss 100:09a23fcd3bdf 985 if( flood_bug_pkg ){
klauss 100:09a23fcd3bdf 986 static int id = 0x10;
klauss 100:09a23fcd3bdf 987 if( id < 10 ) id = 0x0b;
klauss 105:a930035b6556 988 send2callboxes( build_cb_package( 5828, 5123, __REGISTRY__,
klauss 105:a930035b6556 989 ( char * )buffer, id++, CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 100:09a23fcd3bdf 990 }
klauss 100:09a23fcd3bdf 991
klauss 105:a930035b6556 992 // toggle nos leds de debug da header.
klauss 104:62646ef786a3 993 if( led_sync_timer.read() >= 1 ) {
klauss 78:1353744f01e1 994 led_sync_timer.reset();
klauss 78:1353744f01e1 995 led3 = !led3;
klauss 78:1353744f01e1 996 CAB_LED = !CAB_LED;
klauss 78:1353744f01e1 997 }
klauss 106:a34fcf9f0e02 998
klauss 105:a930035b6556 999 // rotina de teste ( usados durante desenvolvimento
klauss 105:a930035b6556 1000 if( main_test )
klauss 105:a930035b6556 1001 {
klauss 108:18a3702650f3 1002 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 108:18a3702650f3 1003 {
klauss 108:18a3702650f3 1004 Call_Box * cb = (Call_Box *) v_cb->get_element (i);
klauss 108:18a3702650f3 1005 if( ( cb != NULL ) && ( cb -> get_ext () == 5000 ) )
klauss 108:18a3702650f3 1006 {
klauss 108:18a3702650f3 1007 main_test = false;
klauss 108:18a3702650f3 1008 cb -> init_rtp_timer ();
klauss 108:18a3702650f3 1009 }
klauss 108:18a3702650f3 1010 }
klauss 105:a930035b6556 1011 }
klauss 106:a34fcf9f0e02 1012
klauss 105:a930035b6556 1013 // begin switch para tratemento de pacote baseado no type
klauss 91:c2a86b1f8aaa 1014 switch( type ) {
klauss 91:c2a86b1f8aaa 1015 case __DO_NOTHING__ :
klauss 91:c2a86b1f8aaa 1016 {}
klauss 91:c2a86b1f8aaa 1017 break;
klauss 91:c2a86b1f8aaa 1018
klauss 0:4d17cd9c8f9d 1019 case __CB_BYE__ : {
klauss 105:a930035b6556 1020 /***
klauss 108:18a3702650f3 1021 end call
klauss 105:a930035b6556 1022 -- Fluxo --
klauss 105:a930035b6556 1023 [ Principio ]
klauss 105:a930035b6556 1024 -- Receber um pedido de bye
klauss 105:a930035b6556 1025 -- procurar e encerrar a ligacao
klauss 105:a930035b6556 1026
klauss 105:a930035b6556 1027 - Incrementa o contador de pacotes recebidos
klauss 105:a930035b6556 1028 - Procura por este cbx no vetor logico de CBx.
klauss 105:a930035b6556 1029 - Em caso de nao localizacao - Nao executa tratamento e exibe mensagem informando, caso seja habilitado degub
klauss 105:a930035b6556 1030 - Em caso de localizacao do cbx
klauss 105:a930035b6556 1031 - Seta o BIT7 para ACK
klauss 105:a930035b6556 1032 - assume que esta ligacao já foi removida
klauss 105:a930035b6556 1033 - procura por essa call no vetor logico de calls
klauss 105:a930035b6556 1034 - Em caso de nao localizacao
klauss 105:a930035b6556 1035 - Executa Busca no vetor logico de CBX
klauss 105:a930035b6556 1036 - Em caso de localizacao
klauss 105:a930035b6556 1037 - assume que esta ligacao já foi removida
klauss 105:a930035b6556 1038 - Confirma que a ligacao nao tinha sido removida
klauss 105:a930035b6556 1039 - Envia pacote de BYE para o servidor asterisk ( * )
klauss 105:a930035b6556 1040 - Recupera o TimeSlice ( ts ) usado nesta call
klauss 105:a930035b6556 1041 - Atribui o TS 0 neste cbx
klauss 105:a930035b6556 1042 - Preenche a posição do TS com 0
klauss 105:a930035b6556 1043 - Retorna o status do CBx e do SIP deste CBx para idle
klauss 105:a930035b6556 1044 - Remove a call do vetor
klauss 105:a930035b6556 1045 - Envia pacote de ack para o CBx
klauss 105:a930035b6556 1046 - Atualiza o id da próxima msg que sera enviada para este CBx
klauss 105:a930035b6556 1047 - Em caso de nao localizacao
klauss 105:a930035b6556 1048 Exibe mensagem informando que exta call ja tinha sido removida, caso habilitado debug
klauss 105:a930035b6556 1049 - Em caso de localizacao
klauss 105:a930035b6556 1050 - Confirma que a ligacao nao tinha sido removida
klauss 105:a930035b6556 1051 - Envia pacote de BYE para o servidor asterisk ( * )
klauss 105:a930035b6556 1052 - Recupera o TimeSlice ( ts ) usado nesta call
klauss 105:a930035b6556 1053 - Atribui o TS 0 neste cbx
klauss 105:a930035b6556 1054 - Preenche a posição do TS com 0
klauss 105:a930035b6556 1055 - Retorna o status do CBx e do SIP deste CBx para idle
klauss 105:a930035b6556 1056 - Remove a call do vetor
klauss 105:a930035b6556 1057 - Envia pacote de ack para o CBx
klauss 105:a930035b6556 1058 - Atualiza o id da próxima msg que sera enviada para este CBx
klauss 105:a930035b6556 1059 - Deleta o objeto call.
klauss 105:a930035b6556 1060 - Em caso de nao localizacao
klauss 105:a930035b6556 1061 Exibe mensagem informando que exta call ja tinha sido removida, caso habilitado debug
klauss 105:a930035b6556 1062 ***/
klauss 105:a930035b6556 1063
klauss 63:0d95da692bb4 1064 cb_bye_counter++;
klauss 0:4d17cd9c8f9d 1065 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1066 if( cb != NULL ) {
klauss 81:3656f00ab3db 1067 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 1068 data[ 0 ] |= BIT7;
klauss 0:4d17cd9c8f9d 1069 cb->set_msg_id( data[ 0 ] );
klauss 81:3656f00ab3db 1070 if( debug_main || debug_invite ) debug_msg( "Request bye from CBx " );
klauss 92:92df17f538a8 1071
klauss 81:3656f00ab3db 1072 bool already_removed = true;
klauss 91:c2a86b1f8aaa 1073 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 0:4d17cd9c8f9d 1074 VZ_call * call = (VZ_call *)v_call->get_element( i );
klauss 91:c2a86b1f8aaa 1075 if( call->get_cb_ext() == ext ) {
klauss 81:3656f00ab3db 1076 already_removed = false;
klauss 4:de46f0d9b14d 1077 cb->send_bye();
klauss 91:c2a86b1f8aaa 1078
klauss 0:4d17cd9c8f9d 1079 ts->return_timeslice( cb->get_timeslice() );
klauss 0:4d17cd9c8f9d 1080 cb->set_timeslice( 0x00 );
klauss 78:1353744f01e1 1081 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 91:c2a86b1f8aaa 1082
klauss 0:4d17cd9c8f9d 1083 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 1084 set_status( cb->sip->status, sip_idle );
klauss 91:c2a86b1f8aaa 1085
klauss 81:3656f00ab3db 1086 v_call->remove_element( i );
klauss 91:c2a86b1f8aaa 1087
klauss 105:a930035b6556 1088 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 105:a930035b6556 1089 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 92:92df17f538a8 1090
klauss 92:92df17f538a8 1091 // envia o ack bye depois atualiza o msg_id
klauss 92:92df17f538a8 1092 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 108:18a3702650f3 1093
klauss 108:18a3702650f3 1094 cb -> set_rtp_port ( 0 );
klauss 108:18a3702650f3 1095
klauss 108:18a3702650f3 1096 cb -> reset_rtp_timer ();
klauss 91:c2a86b1f8aaa 1097
klauss 3:cd9148672e25 1098 delete( call );
klauss 0:4d17cd9c8f9d 1099 }
klauss 0:4d17cd9c8f9d 1100 }
klauss 105:a930035b6556 1101
klauss 82:f55d13babca0 1102 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from vector call" );
klauss 105:a930035b6556 1103
klauss 105:a930035b6556 1104 // ok, mas nem sempre o cbx "entrou" em call
klauss 105:a930035b6556 1105 // Faz-se agora a busca no vetor logico de CBx e nao no de calls como acima
klauss 82:f55d13babca0 1106 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 82:f55d13babca0 1107 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 82:f55d13babca0 1108 if( cb->get_ext() == ext ) {
klauss 82:f55d13babca0 1109 already_removed = true;
klauss 105:a930035b6556 1110 // nao entra nesse if caso tenha sido removido no for de cima.
klauss 82:f55d13babca0 1111 if( cb->get_status() != cb_idle ) {
klauss 82:f55d13babca0 1112 already_removed = false;
klauss 82:f55d13babca0 1113 cb->send_bye();
klauss 82:f55d13babca0 1114
klauss 82:f55d13babca0 1115 ts->return_timeslice( cb->get_timeslice() );
klauss 82:f55d13babca0 1116 cb->set_timeslice( 0x00 );
klauss 82:f55d13babca0 1117 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 82:f55d13babca0 1118
klauss 82:f55d13babca0 1119 set_status( cb->status, cb_idle );
klauss 82:f55d13babca0 1120 set_status( cb->sip->status, sip_idle );
klauss 82:f55d13babca0 1121
klauss 105:a930035b6556 1122 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 105:a930035b6556 1123 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 82:f55d13babca0 1124
klauss 92:92df17f538a8 1125 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 82:f55d13babca0 1126 }
klauss 82:f55d13babca0 1127 }
klauss 82:f55d13babca0 1128 }
klauss 91:c2a86b1f8aaa 1129
klauss 82:f55d13babca0 1130 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from inviting queue" );
klauss 91:c2a86b1f8aaa 1131
klauss 78:1353744f01e1 1132 cb->registry();
klauss 108:18a3702650f3 1133 cb -> set_rtp_port ( 0 );
klauss 108:18a3702650f3 1134 cb -> reset_rtp_timer ();
klauss 91:c2a86b1f8aaa 1135 } else if( debug_invite || debug_main ) debug_msg("Bye from who ? %d", ext );
klauss 91:c2a86b1f8aaa 1136 }
klauss 91:c2a86b1f8aaa 1137 break;
klauss 91:c2a86b1f8aaa 1138
klauss 0:4d17cd9c8f9d 1139 case __INVITE__ : {
klauss 105:a930035b6556 1140 /***
klauss 108:18a3702650f3 1141 init call
klauss 105:a930035b6556 1142 [ Principio ]
klauss 105:a930035b6556 1143 -- Receber um pedido de chamada
klauss 105:a930035b6556 1144 -- tratar com o cbx o andamento da negociacao SIP ( informando disponibilidade de TS )
klauss 105:a930035b6556 1145 -- tratar com o * a negociacao SIP
klauss 105:a930035b6556 1146
klauss 105:a930035b6556 1147 -- Fluxo --
klauss 105:a930035b6556 1148 - Incrementa o contador de pacotes de pedido de chamada ( invite ) enviados.
klauss 105:a930035b6556 1149 - Procura por este CBx no vetor logico de CBX
klauss 105:a930035b6556 1150 - Em caso de nao localizacao
klauss 105:a930035b6556 1151 - Verifica se nao existem mais cbx criados do que o permitido por definicao de projeto
klauss 105:a930035b6556 1152 - Tenta criar o objeto CBx
klauss 105:a930035b6556 1153 - Caso consiga criar : adiciona o novo elemento no vetor logico de CBx
klauss 105:a930035b6556 1154 - Caso nao consiga criar : Exibe msg de erro condicionada a debuf e seta variavel indicando ausencia de memoria
klauss 105:a930035b6556 1155 - Em caso de localizacao ( ou tenha conseguido criar no caso acima )
klauss 105:a930035b6556 1156 - Atribui o valor recebido no pacote na posicao ID como sendo o id da proxima msg
klauss 105:a930035b6556 1157 - Verifica o status do CBx
klauss 105:a930035b6556 1158 - Caso status idle, inicia timer de tratamento de envio de ACK pro CBx
klauss 105:a930035b6556 1159 - Invoca rotina de tratamento SIP deste pedido de chamada.
klauss 105:a930035b6556 1160 ***/
klauss 105:a930035b6556 1161
klauss 63:0d95da692bb4 1162 invite_counter++;
klauss 78:1353744f01e1 1163 if( debug_invite ) debug_msg("Request Invite received from Cbx %i", ext);
klauss 0:4d17cd9c8f9d 1164 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1165 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1166 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 91:c2a86b1f8aaa 1167 if( debug_main ) debug_msg( "Adding CBx :: %i", ext );
klauss 91:c2a86b1f8aaa 1168 cb = new Call_Box( ext, port );
klauss 91:c2a86b1f8aaa 1169
klauss 91:c2a86b1f8aaa 1170 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1171 memory_is_over = true;
klauss 91:c2a86b1f8aaa 1172 if( debug_memory ) debug_msg("Invite allocation cb fail");
klauss 91:c2a86b1f8aaa 1173 } else {
klauss 91:c2a86b1f8aaa 1174 v_cb->add( cb );
klauss 91:c2a86b1f8aaa 1175 }
klauss 89:0fe315117b00 1176 }
klauss 0:4d17cd9c8f9d 1177 }
klauss 91:c2a86b1f8aaa 1178 if( cb != NULL ) {
klauss 91:c2a86b1f8aaa 1179 cb->set_msg_id( data[ 0 ] );
klauss 92:92df17f538a8 1180 if( cb->status == cb_idle ){
klauss 92:92df17f538a8 1181 cb->set_invite_response_ok();
klauss 92:92df17f538a8 1182 cb->invite_retry_count_reset();
klauss 108:18a3702650f3 1183 cb -> reset_rtp_timer ();
klauss 108:18a3702650f3 1184 cb -> init_rtp_timer ();
klauss 92:92df17f538a8 1185 }
klauss 87:679ee0d594a9 1186 invite_handler( v_call, v_cb, ts, cb );
klauss 87:679ee0d594a9 1187 }
klauss 91:c2a86b1f8aaa 1188 }
klauss 91:c2a86b1f8aaa 1189 break;
klauss 4:de46f0d9b14d 1190 case __REGISTRY__ : {
klauss 105:a930035b6556 1191 /***
klauss 105:a930035b6556 1192 [ Principio ]
klauss 105:a930035b6556 1193 -- Receber um pacote de registro
klauss 105:a930035b6556 1194 -- Encaminhar para o *
klauss 105:a930035b6556 1195
klauss 105:a930035b6556 1196 -- Fluxo --
klauss 105:a930035b6556 1197 - incrementa o contador de pacotes de registro recebidos
klauss 105:a930035b6556 1198 - Procura por este cbx no vetor logico de CBx.
klauss 105:a930035b6556 1199 - Verifica se nao existem mais cbx criados do que o permitido por definicao de projeto
klauss 105:a930035b6556 1200 - Caso nao exista
klauss 105:a930035b6556 1201 - Verifica se o CBx foi encontrado no vetor
klauss 105:a930035b6556 1202 - Caso nao tenha sido
klauss 105:a930035b6556 1203 - Tentar criar este elemento
klauss 105:a930035b6556 1204 - Verifica criacao bem sucedida
klauss 105:a930035b6556 1205 - Caso tenha criado o elemento
klauss 105:a930035b6556 1206 - Adiciona o mesmo no vetor logico de CBX
klauss 105:a930035b6556 1207 - Caso nao tenha criado o elemento
klauss 105:a930035b6556 1208 - seta variavel de erro
klauss 105:a930035b6556 1209 - exibe mensagem de erro condicionada a debug.
klauss 105:a930035b6556 1210 - Caso o CBx tenha sido encontrado ( ou criado acima )
klauss 105:a930035b6556 1211 - Envia pacote de registro para o *
klauss 105:a930035b6556 1212 ***/
klauss 63:0d95da692bb4 1213 registry_counter++;
klauss 78:1353744f01e1 1214 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1215 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 91:c2a86b1f8aaa 1216 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1217 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 91:c2a86b1f8aaa 1218 cb = new Call_Box( ext, port );
klauss 91:c2a86b1f8aaa 1219
klauss 91:c2a86b1f8aaa 1220 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1221 memory_is_over = true;
klauss 91:c2a86b1f8aaa 1222 if( debug_memory ) debug_msg("Registry cb allocation fail");
klauss 91:c2a86b1f8aaa 1223 } else {
klauss 91:c2a86b1f8aaa 1224 v_cb->add( cb );
klauss 91:c2a86b1f8aaa 1225 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 91:c2a86b1f8aaa 1226 }
klauss 87:679ee0d594a9 1227 }
klauss 0:4d17cd9c8f9d 1228 }
klauss 78:1353744f01e1 1229 if( debug_main ) debug_msg("Registered %d - %d", ext, port );
klauss 91:c2a86b1f8aaa 1230
klauss 87:679ee0d594a9 1231 if( cb != NULL ) cb->registry();
klauss 91:c2a86b1f8aaa 1232 }
klauss 91:c2a86b1f8aaa 1233 break;
klauss 4:de46f0d9b14d 1234 case __BOOT__ : {
klauss 105:a930035b6556 1235 /***
klauss 105:a930035b6556 1236 [ Principio ]
klauss 105:a930035b6556 1237 -- Receber um pacote de boot do CBx
klauss 105:a930035b6556 1238 -- Encaminhar um pacote do tipo "Registro" para o CBx
klauss 105:a930035b6556 1239 [ NOTA ] Por decisao de projeto, o CBx responde pacotes do tipo __REGISTRY__ pendindo pra se registrar.
klauss 105:a930035b6556 1240
klauss 105:a930035b6556 1241 -- Fluxo --
klauss 105:a930035b6556 1242 - Incrementa o contador de pacotes de boot recebidos
klauss 105:a930035b6556 1243 - Envia para o CBx remetendo o mesmo pacote, contendo o tipo __REGISTRY__ e o id como sendo o id recebido "OR" BIT7
klauss 105:a930035b6556 1244
klauss 105:a930035b6556 1245 ***/
klauss 63:0d95da692bb4 1246 boot_counter++;
klauss 99:e80850c51106 1247 if( debug_boot == true ){
klauss 99:e80850c51106 1248 send_msg("Rcv boot pkg from (%d, %d) pkg-id %d", ext, port, data[ 0 ] );
klauss 99:e80850c51106 1249 }
klauss 105:a930035b6556 1250 send2callboxes( build_cb_package( ext, port, __REGISTRY__,
klauss 105:a930035b6556 1251 ( char * )data, data[ 0 ] | BIT7, CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 91:c2a86b1f8aaa 1252 }
klauss 91:c2a86b1f8aaa 1253 break;
klauss 99:e80850c51106 1254
klauss 99:e80850c51106 1255 case __FW__ : {
klauss 105:a930035b6556 1256 /***
klauss 105:a930035b6556 1257 [ Principio ]
klauss 105:a930035b6556 1258 -- Encaminhar para o servidor predeterminado todo pacote do tipo __FW__
klauss 105:a930035b6556 1259
klauss 105:a930035b6556 1260 -- Fluxo --
klauss 105:a930035b6556 1261 - Incrementa o contador de pacotes de __FW__ recebidos
klauss 105:a930035b6556 1262 - invoca rotina que exporta este pacote para o servidor
klauss 105:a930035b6556 1263 ***/
klauss 105:a930035b6556 1264 fw_counter++;
klauss 99:e80850c51106 1265 if( debug_fw_print ) send_msg("::FW pkg from %d - %d::", ext, port );
klauss 99:e80850c51106 1266 fw_cbx_pkg( ext, port, ( char *)buffer );
klauss 99:e80850c51106 1267 }
klauss 99:e80850c51106 1268 break;
klauss 91:c2a86b1f8aaa 1269
klauss 67:cdedc64d9921 1270 case __BOOTLOADER_CBX__ : {
klauss 105:a930035b6556 1271 /***
klauss 105:a930035b6556 1272 [ Principio ]
klauss 105:a930035b6556 1273 -- A definir, a priori a header seria um bypass responsavel apenas por gerenciar um TS.
klauss 105:a930035b6556 1274 -- Fluxo --
klauss 105:a930035b6556 1275 - incrementa o contador de pacote de bootloader CBx recebidos
klauss 105:a930035b6556 1276 - ???
klauss 105:a930035b6556 1277 ***/
klauss 67:cdedc64d9921 1278 bootloader_cbx_counter++;
klauss 91:c2a86b1f8aaa 1279 }
klauss 91:c2a86b1f8aaa 1280 break;
klauss 91:c2a86b1f8aaa 1281
klauss 105:a930035b6556 1282 case __PROMPT__ : {
klauss 105:a930035b6556 1283 /***
klauss 105:a930035b6556 1284 [ Principio ]
klauss 105:a930035b6556 1285 -- Receber um pacote do CBx
klauss 105:a930035b6556 1286 -- Criar, adicionar e registrar o CBx remetente
klauss 105:a930035b6556 1287 -- Exibir na tela possiveis comandos/saidas do CBx de interesse.
klauss 105:a930035b6556 1288 -- Fluxo --
klauss 105:a930035b6556 1289 - Procura por este cbx no vetor logico de CBx.
klauss 105:a930035b6556 1290 - Verifica se o CBx foi encontrado no vetor
klauss 105:a930035b6556 1291 - Caso nao tenha sido encontrado
klauss 105:a930035b6556 1292 - Verifica se nao existem mais cbx criados do que o permitido por definicao de projeto
klauss 105:a930035b6556 1293 - Caso nao exista
klauss 105:a930035b6556 1294 - Tentar criar este elemento
klauss 105:a930035b6556 1295 - Verifica criacao bem sucedida
klauss 105:a930035b6556 1296 - Caso nao tenha criado o elemento
klauss 105:a930035b6556 1297 - seta variavel de erro
klauss 105:a930035b6556 1298 - Caso tenha criado o elemento
klauss 105:a930035b6556 1299 - Adiciona o mesmo no vetor logico de CBX
klauss 105:a930035b6556 1300 - Caso tenha sido encontrado ( ou criado no caso acima )
klauss 105:a930035b6556 1301 - Encaminha pedido de registro para o *
klauss 105:a930035b6556 1302 - Verifica se o pacote recebido possui como conteudo "ping"
klauss 105:a930035b6556 1303 - em caso positivo
klauss 105:a930035b6556 1304 - exibe msg indicativa condicionada a debug
klauss 105:a930035b6556 1305 - em caso negativo
klauss 105:a930035b6556 1306 - Incrementa o contador de pacotes recebidos
klauss 105:a930035b6556 1307 - Exibe conteudo de pacote ( 32 primeiros bytes ) condicionado a debug
klauss 105:a930035b6556 1308 ***/
klauss 105:a930035b6556 1309
klauss 78:1353744f01e1 1310 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1311
klauss 91:c2a86b1f8aaa 1312 if( cb == NULL ) {
klauss 105:a930035b6556 1313 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 105:a930035b6556 1314 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 105:a930035b6556 1315 cb = new Call_Box( ext, port );
klauss 105:a930035b6556 1316 if( cb == NULL ) {
klauss 105:a930035b6556 1317 memory_is_over = true;
klauss 105:a930035b6556 1318 } else {
klauss 105:a930035b6556 1319 v_cb->add( cb );
klauss 105:a930035b6556 1320 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 105:a930035b6556 1321 }
klauss 87:679ee0d594a9 1322 }
klauss 48:195c97f12e8e 1323 }
klauss 91:c2a86b1f8aaa 1324
klauss 92:92df17f538a8 1325 if( cb!= NULL ) cb->registry();
klauss 91:c2a86b1f8aaa 1326
klauss 91:c2a86b1f8aaa 1327 if( xstrmatch( ( uint8_t * )data, ( uint8_t * )"ping" ) ) {
klauss 78:1353744f01e1 1328 if( debug_ping ) send_msg( "Prompt pkg from ( %i, %i ) :: Ping", ext, port );
klauss 91:c2a86b1f8aaa 1329 } else {
klauss 78:1353744f01e1 1330 prompt_counter++;
klauss 105:a930035b6556 1331 //FIXME acumular a string e mandar via send_msg
klauss 78:1353744f01e1 1332 send_msg( "Prompt pkg from ( %i, %i ) ::", ext, port );
klauss 91:c2a86b1f8aaa 1333 for( register uint8_t i = 0; i < 32; i++ ) {
klauss 100:09a23fcd3bdf 1334 if( debug_uart3 ) pc.printf("%c", data[ i ] );
klauss 100:09a23fcd3bdf 1335 if( i == 15 ) if( debug_uart3 ) pc.printf( "\r\n" );
klauss 78:1353744f01e1 1336 }
klauss 100:09a23fcd3bdf 1337 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 91:c2a86b1f8aaa 1338
klauss 105:a930035b6556 1339 if( tcp_session && !udp_query ) {
klauss 105:a930035b6556 1340 char aux[ CB_BUFFER_SIZE + 3 ];
klauss 105:a930035b6556 1341 strncpy( aux, (char * )data, CB_BUFFER_SIZE );
klauss 78:1353744f01e1 1342 strcat( aux, "\n\r\0" );
klauss 78:1353744f01e1 1343 tcp_client.send_all( ( char *)data, strlen( (char * )data ) );
klauss 78:1353744f01e1 1344 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 78:1353744f01e1 1345 }
klauss 105:a930035b6556 1346 else if( udp_query )
klauss 105:a930035b6556 1347 {
klauss 105:a930035b6556 1348 char aux[ CB_BUFFER_SIZE + 3 ];
klauss 105:a930035b6556 1349 strncpy( aux, (char * )data, CB_BUFFER_SIZE );
klauss 105:a930035b6556 1350 strcat( aux, "\n\r\0" );
klauss 105:a930035b6556 1351 udp_query_send_msg( ( char *)data );
klauss 105:a930035b6556 1352 udp_query_send_msg( "\r\n> " );
klauss 105:a930035b6556 1353 }
klauss 48:195c97f12e8e 1354 }
klauss 91:c2a86b1f8aaa 1355 }
klauss 91:c2a86b1f8aaa 1356 break;
klauss 0:4d17cd9c8f9d 1357 case __AUDIO__ : {
klauss 105:a930035b6556 1358 /***
klauss 105:a930035b6556 1359 [ Principio ]
klauss 105:a930035b6556 1360 -- Receber pacote de audio do CBx
klauss 105:a930035b6556 1361 -- Encaminhar para o *
klauss 105:a930035b6556 1362 -- Fluxo --
klauss 105:a930035b6556 1363 - Incrementa o contador de pacotes recebidos
klauss 105:a930035b6556 1364 - Procura por este cbx no vetor logico de calls.
klauss 105:a930035b6556 1365 - Caso nao encontre
klauss 105:a930035b6556 1366 - Exibe mensagem de erro condicionada a debug
klauss 105:a930035b6556 1367 - Caso encontre
klauss 105:a930035b6556 1368 - Encaminha o pacote para o servidor
klauss 105:a930035b6556 1369 - Reseta o timer de idle desta ligacao
klauss 105:a930035b6556 1370 - Busca pelo CBX no vetor logico de CBx
klauss 105:a930035b6556 1371 - Caso encontre
klauss 105:a930035b6556 1372 - Informa que esta tendo comunicacao CBx->Header
klauss 105:a930035b6556 1373 ***/
klauss 63:0d95da692bb4 1374 audio_counter++;
klauss 78:1353744f01e1 1375 VZ_call * call = __find_Call__( v_call, ext );
klauss 91:c2a86b1f8aaa 1376 if( call != NULL ) {
klauss 105:a930035b6556 1377 // Por definicao de projeto, os dados de audio comecam no data + 2
klauss 105:a930035b6556 1378 // esses 2 bytes foram usados para id de debug durante o desenvolvimento
klauss 91:c2a86b1f8aaa 1379 char * pkg = call->build_eth_package( data + 2 );
klauss 0:4d17cd9c8f9d 1380 call->send_message( pkg );
klauss 92:92df17f538a8 1381 call->cbx_pkg_idle_timer_reset();
klauss 78:1353744f01e1 1382 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 105:a930035b6556 1383 if( cb != NULL ){
klauss 92:92df17f538a8 1384 cb->set_invite_response_ok();
klauss 92:92df17f538a8 1385 cb->invite_retry_count_reset();
klauss 92:92df17f538a8 1386 }
klauss 91:c2a86b1f8aaa 1387 } else {
klauss 78:1353744f01e1 1388 if( debug_main ) debug_msg("received missed package from CBx :: %i", ext );
klauss 0:4d17cd9c8f9d 1389 }
klauss 91:c2a86b1f8aaa 1390 }
klauss 91:c2a86b1f8aaa 1391 break;
klauss 105:a930035b6556 1392 }//end switch para tratemento de pacote baseado no type
klauss 105:a930035b6556 1393
klauss 99:e80850c51106 1394 { // rajada
klauss 105:a930035b6556 1395 /***
klauss 105:a930035b6556 1396 [ Principio ]
klauss 105:a930035b6556 1397 -- Verifica se existem CBx em ligaçao
klauss 105:a930035b6556 1398 -- Verifica se os mesmos estao enviando pacotes de audio
klauss 105:a930035b6556 1399 -- Re-envio o pacote avisando que o CBx pode entrar no status "on_call"
klauss 105:a930035b6556 1400 ***/
klauss 99:e80850c51106 1401 if( invite_retry_timer.read_ms() > 30 ) {
klauss 99:e80850c51106 1402 invite_retry_timer.reset();
klauss 92:92df17f538a8 1403 static int retry_invite_pkg = 0;
klauss 99:e80850c51106 1404
klauss 92:92df17f538a8 1405 if( retry_invite_pkg >= v_cb->size() ) retry_invite_pkg = 0;
klauss 99:e80850c51106 1406
klauss 105:a930035b6556 1407 // procura por CBx em ligaçao sequencialmente
klauss 108:18a3702650f3 1408 int i = 0;
klauss 108:18a3702650f3 1409
klauss 108:18a3702650f3 1410 led4 = 1;
klauss 106:a34fcf9f0e02 1411
klauss 108:18a3702650f3 1412 /*
klauss 108:18a3702650f3 1413 // por hipótese esse valor esta sendo corrompido quando recebido UDP
klauss 108:18a3702650f3 1414 for ( ; i < v_cb->size(); i++ )
klauss 108:18a3702650f3 1415 {
klauss 108:18a3702650f3 1416 {
klauss 108:18a3702650f3 1417 led4 = 0;
klauss 108:18a3702650f3 1418 }
klauss 108:18a3702650f3 1419
klauss 99:e80850c51106 1420 Call_Box * cb = (Call_Box * )v_cb->get_element( i );
klauss 99:e80850c51106 1421 if( ( cb->status == cb_ringing ) || ( cb->status == cb_trying ) || ( cb->status == cb_on_call ) ) {
klauss 99:e80850c51106 1422 if( i > retry_invite_pkg ) {
klauss 99:e80850c51106 1423 retry_invite_pkg = i;
klauss 99:e80850c51106 1424 break;
klauss 99:e80850c51106 1425 }
klauss 92:92df17f538a8 1426 }
klauss 99:e80850c51106 1427 }
klauss 108:18a3702650f3 1428
klauss 99:e80850c51106 1429 if( i != v_cb->size() ){
klauss 99:e80850c51106 1430 Call_Box * cb = (Call_Box *)v_cb->get_element( retry_invite_pkg++ );
klauss 105:a930035b6556 1431
klauss 99:e80850c51106 1432 if( ( cb->status == cb_ringing ) || ( cb->status == cb_trying ) || ( cb->status == cb_on_call ) ) {
klauss 99:e80850c51106 1433 if( cb->get_invite_response() == false ) {
klauss 99:e80850c51106 1434 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 99:e80850c51106 1435
klauss 99:e80850c51106 1436 buffer[ __TIMESLICE_PLACE__ ] = cb->get_timeslice();
klauss 105:a930035b6556 1437
klauss 105:a930035b6556 1438 // re-envia pacote confirmando que ligacao esta ok, CBx pode ligar o mic. e o speaker
klauss 105:a930035b6556 1439 send2callboxes( build_cb_package( cb->get_ext(), cb->get_port(), __INVITE__, ( char * )buffer,
klauss 105:a930035b6556 1440 cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 105:a930035b6556 1441
klauss 99:e80850c51106 1442 if( debug_invite ) debug_msg("resend invite OK to Cbx : ( %d, %d )", cb->get_ext(), cb->get_port() );
klauss 99:e80850c51106 1443 }
klauss 105:a930035b6556 1444
klauss 105:a930035b6556 1445 // fim das tentativas
klauss 99:e80850c51106 1446 if( cb->get_invite_retry_count() == 0 ) {
klauss 99:e80850c51106 1447 cb->send_bye();
klauss 92:92df17f538a8 1448
klauss 99:e80850c51106 1449 ts->return_timeslice( cb->get_timeslice() );
klauss 99:e80850c51106 1450 cb->set_timeslice( 0x00 );
klauss 99:e80850c51106 1451
klauss 99:e80850c51106 1452 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 99:e80850c51106 1453
klauss 99:e80850c51106 1454 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 99:e80850c51106 1455 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 99:e80850c51106 1456 if( call->get_cb_ext() == cb->get_ext() ) {
klauss 99:e80850c51106 1457 v_call->remove_element( i );
klauss 99:e80850c51106 1458 if( call != NULL ) delete( call );
klauss 99:e80850c51106 1459 break;
klauss 99:e80850c51106 1460 }
klauss 92:92df17f538a8 1461 }
klauss 99:e80850c51106 1462
klauss 99:e80850c51106 1463 if( debug_invite ) debug_msg( "-- No audio pkgs --" );
klauss 99:e80850c51106 1464 set_status( cb->status, cb_idle );
klauss 99:e80850c51106 1465 set_status( cb->sip->status, sip_idle );
klauss 92:92df17f538a8 1466 }
klauss 92:92df17f538a8 1467 }
klauss 92:92df17f538a8 1468 }
klauss 108:18a3702650f3 1469 */
klauss 92:92df17f538a8 1470 }
klauss 92:92df17f538a8 1471 }
klauss 108:18a3702650f3 1472
klauss 105:a930035b6556 1473 /***
klauss 105:a930035b6556 1474 [ Principio ]
klauss 105:a930035b6556 1475 -- Para cada CBx em ligaçao
klauss 105:a930035b6556 1476 -- Verificar e encaminhar pacotes recebidos da interface ETH-Header-CBx
klauss 105:a930035b6556 1477 -- Fluxo --
klauss 105:a930035b6556 1478 - Para cada elemento do vetor call
klauss 105:a930035b6556 1479 - Verificar se consta algo pendente para processamento no sentido ETH->Header->Cbx
klauss 105:a930035b6556 1480 - Caso existe
klauss 105:a930035b6556 1481 - Procurar por este CBx no vetor lógico de CBx
klauss 105:a930035b6556 1482 - Caso seja encontrado
klauss 105:a930035b6556 1483 - Enviar pacote recebido para este CBx
klauss 105:a930035b6556 1484 - Caso nao seja encontrado
klauss 105:a930035b6556 1485 - Exibe msg de erro condicionado a debug
klauss 105:a930035b6556 1486 ***/
klauss 108:18a3702650f3 1487
klauss 91:c2a86b1f8aaa 1488 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 0:4d17cd9c8f9d 1489 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 108:18a3702650f3 1490 if ( call != NULL )
klauss 108:18a3702650f3 1491 {
klauss 108:18a3702650f3 1492 int length = 0;
klauss 108:18a3702650f3 1493 char * tmp = call->get_eth_message( &length );
klauss 108:18a3702650f3 1494 if( tmp != NULL ) {
klauss 108:18a3702650f3 1495 int cb_port = 0xffff;
klauss 108:18a3702650f3 1496 Call_Box * cb = __find_CB__( v_cb, call->get_cb_ext() );
klauss 108:18a3702650f3 1497 if( cb != NULL ) {
klauss 108:18a3702650f3 1498 cb_port = cb->get_port();
klauss 108:18a3702650f3 1499
klauss 108:18a3702650f3 1500 uint8_t * pkg2cb = build_cb_package( call->get_cb_ext(), cb_port, __AUDIO__,
klauss 108:18a3702650f3 1501 tmp, __AUDIO__, length, write_buffer );
klauss 108:18a3702650f3 1502
klauss 108:18a3702650f3 1503 send2callboxes( pkg2cb );
klauss 108:18a3702650f3 1504
klauss 108:18a3702650f3 1505 } else if( debug_main ) debug_msg("received missed package from CBx :: %i -- Type :: %i", ext, type );
klauss 108:18a3702650f3 1506 }
klauss 0:4d17cd9c8f9d 1507 }
klauss 14:22a35f575502 1508 }
klauss 108:18a3702650f3 1509
klauss 105:a930035b6556 1510 /***
klauss 105:a930035b6556 1511 [ Principio ]
klauss 105:a930035b6556 1512 -- Verificar se já se passou determinada unidade de tempo
klauss 105:a930035b6556 1513 -- Baseado nisso, chamar a funcao [ 1 ] refresh ou [ 2 ] wake_all_up
klauss 105:a930035b6556 1514 [ 1 ] -- Encaminha periodicamente um pacote de __REGISTRY__ para cada CBx, um por vez.
klauss 105:a930035b6556 1515 [ 2 ] -- Busca por elementos que constem sem seus pares registrados e manda um __PROMPT__ ping para cada um, um por vez.
klauss 105:a930035b6556 1516 ***/
klauss 106:a34fcf9f0e02 1517
klauss 106:a34fcf9f0e02 1518 if( timer_sync_refresh.read_ms() > 250 )
klauss 106:a34fcf9f0e02 1519 {
klauss 89:0fe315117b00 1520 timer_sync_refresh.reset();
klauss 108:18a3702650f3 1521 static uint8_t time_to_mode = TIME_TO_REFRESH;
klauss 108:18a3702650f3 1522 if( time_to_mode == TIME_TO_REFRESH )
klauss 106:a34fcf9f0e02 1523 {
klauss 108:18a3702650f3 1524 time_to_mode = TIME_TO_WAKE_UP;
klauss 106:a34fcf9f0e02 1525 refresh( v_cb );
klauss 106:a34fcf9f0e02 1526 }
klauss 106:a34fcf9f0e02 1527 else
klauss 106:a34fcf9f0e02 1528 {
klauss 108:18a3702650f3 1529 time_to_mode = TIME_TO_REFRESH;
klauss 106:a34fcf9f0e02 1530 if( wake_all ) if( v_call->size() == 0 ) wake_all_up( v_cb );
klauss 89:0fe315117b00 1531 }
klauss 89:0fe315117b00 1532 }
klauss 108:18a3702650f3 1533
klauss 78:1353744f01e1 1534 // check sip messages only for cbx in call ?
klauss 108:18a3702650f3 1535 // end call
klauss 78:1353744f01e1 1536 int ext_to__be_removed = sip_manager( v_cb );
klauss 91:c2a86b1f8aaa 1537 if( ext_to__be_removed > 0x00 ) {
klauss 78:1353744f01e1 1538 Call_Box * cb = __find_CB__( v_cb, ext_to__be_removed );
klauss 91:c2a86b1f8aaa 1539 if( cb != NULL ) {
klauss 91:c2a86b1f8aaa 1540 if( cb->status == cb_on_call ) {
klauss 4:de46f0d9b14d 1541 ts->return_timeslice( cb->get_timeslice() );
klauss 4:de46f0d9b14d 1542 cb->set_timeslice( 0x00 );
klauss 4:de46f0d9b14d 1543 buffer[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 91:c2a86b1f8aaa 1544
klauss 78:1353744f01e1 1545 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 1546 set_status( cb->sip->status, sip_idle );
klauss 91:c2a86b1f8aaa 1547
klauss 91:c2a86b1f8aaa 1548 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 4:de46f0d9b14d 1549 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 91:c2a86b1f8aaa 1550 if( call->get_cb_ext() == ext_to__be_removed ) {
klauss 4:de46f0d9b14d 1551 v_call->remove_element( i );
klauss 4:de46f0d9b14d 1552 delete( call );
klauss 4:de46f0d9b14d 1553 }
klauss 2:93bec7313ccc 1554 }
klauss 91:c2a86b1f8aaa 1555
klauss 92:92df17f538a8 1556 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 108:18a3702650f3 1557
klauss 108:18a3702650f3 1558 cb -> set_rtp_port ( 0 );
klauss 108:18a3702650f3 1559
klauss 108:18a3702650f3 1560 cb -> reset_rtp_timer ();
klauss 91:c2a86b1f8aaa 1561
klauss 105:a930035b6556 1562 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 105:a930035b6556 1563 ( char * )buffer, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 91:c2a86b1f8aaa 1564
klauss 91:c2a86b1f8aaa 1565 if( debug_invite ) debug_msg("Received Bye from *");
klauss 0:4d17cd9c8f9d 1566 }
klauss 91:c2a86b1f8aaa 1567 } else if( debug_main ) debug_msg("Missed bye request from * CBx :: %d", ext );
klauss 108:18a3702650f3 1568 }
klauss 91:c2a86b1f8aaa 1569
klauss 81:3656f00ab3db 1570 /* Verifica andamento de ligações para eventualmente encerra-las por timeout */
klauss 108:18a3702650f3 1571 call_manager( v_call, v_cb, ts );
klauss 91:c2a86b1f8aaa 1572
klauss 105:a930035b6556 1573 /* tratamento de pedidos de ligação já em andamento com o * */
klauss 81:3656f00ab3db 1574 invite_handler( v_call, v_cb, ts, NULL );
klauss 108:18a3702650f3 1575
klauss 81:3656f00ab3db 1576 /* rotina de verificação de TS's perdidos */
klauss 91:c2a86b1f8aaa 1577 if( ( v_call->size() == 0 ) && ( ts->remain_timeslices() != __MAX_TIMESLICES__ ) ) {
klauss 91:c2a86b1f8aaa 1578 bool ts_reset = true;
klauss 91:c2a86b1f8aaa 1579 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 82:f55d13babca0 1580 if ( ( ( Call_Box * )v_cb->get_element( i ) )->get_status() != cb_idle &&
klauss 91:c2a86b1f8aaa 1581 ( ( Call_Box * )v_cb->get_element( i ) )->get_sip_status() != sip_idle ) {
klauss 78:1353744f01e1 1582 ts_reset = false;
klauss 78:1353744f01e1 1583 break;
klauss 78:1353744f01e1 1584 }
klauss 91:c2a86b1f8aaa 1585 }
klauss 108:18a3702650f3 1586 if ( ts_reset )
klauss 108:18a3702650f3 1587 {
klauss 108:18a3702650f3 1588 if ( debug_invite ) debug_msg ("Resetando TS");
klauss 108:18a3702650f3 1589 ts -> reset ();
klauss 78:1353744f01e1 1590 }
klauss 0:4d17cd9c8f9d 1591 }
klauss 108:18a3702650f3 1592
klauss 108:18a3702650f3 1593 /* rotina "zeradora" de portas RTP */
klauss 108:18a3702650f3 1594 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 108:18a3702650f3 1595 {
klauss 108:18a3702650f3 1596 Call_Box * cb = (Call_Box *) v_cb->get_element (i);
klauss 108:18a3702650f3 1597 if ( cb != NULL )
klauss 108:18a3702650f3 1598 {
klauss 108:18a3702650f3 1599 if ( ( cb->get_status () == cb_idle ) && ( cb->get_sip_status () == sip_idle ) && ( cb -> is_rtp_timer_timeout () ) )
klauss 108:18a3702650f3 1600 {
klauss 108:18a3702650f3 1601 if ( debug_reset_rtp ) debug_msg( "%d rtp reset", cb -> get_ext () );
klauss 108:18a3702650f3 1602 set_status ( cb -> status, cb_idle );
klauss 108:18a3702650f3 1603 set_status ( cb->sip->status, sip_idle );
klauss 108:18a3702650f3 1604 cb -> reset_rtp_timer ();
klauss 108:18a3702650f3 1605 cb -> set_rtp_port ( 0 );
klauss 108:18a3702650f3 1606 }
klauss 108:18a3702650f3 1607 }
klauss 108:18a3702650f3 1608 }
klauss 106:a34fcf9f0e02 1609
klauss 81:3656f00ab3db 1610 /* rotina que esvazia possiveis pacotes que não foram transmitidos para evitar conflito */
klauss 72:895ca792c647 1611 tx_buffer_ring_buffer_handler();
klauss 91:c2a86b1f8aaa 1612
klauss 105:a930035b6556 1613 // atribui o valor default para a variavel type
klauss 30:8dfb6d8de53d 1614 type = __DO_NOTHING__;
klauss 106:a34fcf9f0e02 1615
klauss 105:a930035b6556 1616 // verifica o status da conexao ETH, caso exteja conectado ( == 0 ) atribui o valor maximo ao contador de controle
klauss 81:3656f00ab3db 1617 if( eth_status == 0 ) eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 106:a34fcf9f0e02 1618
klauss 105:a930035b6556 1619 // responsavel por atualizar os contadores de controle utilizados para tickar o wdt
klauss 105:a930035b6556 1620 // e tickar o wdt
klauss 91:c2a86b1f8aaa 1621 if( wdt_timer.read() >= 1 ) {
klauss 106:a34fcf9f0e02 1622
klauss 91:c2a86b1f8aaa 1623 //FIXME remove myself
klauss 83:b8a1d8fdeaeb 1624 uptime++;
klauss 91:c2a86b1f8aaa 1625
klauss 81:3656f00ab3db 1626 wdt_timer.reset();
klauss 91:c2a86b1f8aaa 1627
klauss 81:3656f00ab3db 1628 if( wdt_show ) debug_wdt = true;
klauss 91:c2a86b1f8aaa 1629
klauss 81:3656f00ab3db 1630 if( external_wdt ) external_wdt--;
klauss 81:3656f00ab3db 1631 if( pkg_wdt ) pkg_wdt--;
klauss 81:3656f00ab3db 1632 if( eth_wdt ) eth_wdt--;
klauss 91:c2a86b1f8aaa 1633
klauss 91:c2a86b1f8aaa 1634 if( eth_wdt && external_wdt && pkg_wdt ){
klauss 81:3656f00ab3db 1635 wdt.kick();
klauss 81:3656f00ab3db 1636 }
klauss 108:18a3702650f3 1637 }
klauss 106:a34fcf9f0e02 1638
klauss 105:a930035b6556 1639 // exibe informacoes referentes ao wdt, ultimo reset, status da eth, tempo em segundos desde o ultimo tick dowdt externo,
klauss 105:a930035b6556 1640 // tempo em segundos desde o ultimo pacote recebido da interface fibra
klauss 91:c2a86b1f8aaa 1641 if( debug_wdt ) {
klauss 87:679ee0d594a9 1642 send_msg("lpc_low_level_input_counter :: %d", lpc_low_level_input_counter );
klauss 87:679ee0d594a9 1643 lpc_low_level_input_counter = 0;
klauss 91:c2a86b1f8aaa 1644
klauss 81:3656f00ab3db 1645 debug_wdt = false;
klauss 91:c2a86b1f8aaa 1646 if( eth_status == 0 ) {
klauss 91:c2a86b1f8aaa 1647 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 91:c2a86b1f8aaa 1648 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 91:c2a86b1f8aaa 1649 EXTERN_WDT_IDLE - external_wdt,
klauss 91:c2a86b1f8aaa 1650 EXTERN_WDT_IDLE,
klauss 91:c2a86b1f8aaa 1651 RX_CB_IDLE - pkg_wdt,
klauss 91:c2a86b1f8aaa 1652 RX_CB_IDLE
klauss 91:c2a86b1f8aaa 1653 );
klauss 91:c2a86b1f8aaa 1654 } else {
klauss 91:c2a86b1f8aaa 1655 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 91:c2a86b1f8aaa 1656 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 91:c2a86b1f8aaa 1657 ETH_CONNECT_TIMEOUT - eth_wdt,
klauss 91:c2a86b1f8aaa 1658 EXTERN_WDT_IDLE - external_wdt,
klauss 91:c2a86b1f8aaa 1659 EXTERN_WDT_IDLE,
klauss 91:c2a86b1f8aaa 1660 RX_CB_IDLE - pkg_wdt,
klauss 91:c2a86b1f8aaa 1661 RX_CB_IDLE
klauss 91:c2a86b1f8aaa 1662 );
klauss 81:3656f00ab3db 1663 }
klauss 108:18a3702650f3 1664 }
klauss 105:a930035b6556 1665 }//fim while ( main loop )
klauss 0:4d17cd9c8f9d 1666 }