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@116:39a41ebb675c, 2015-04-23 (annotated)

Committer:
klauss
Date:
Thu Apr 23 20:24:09 2015 +0000
Revision:
116:39a41ebb675c
Parent:
115:a1e1e2e60a2c
Child:
117:e9facba9db27
inicio do merge da vers?o da ultima vistoria com a da sprint 0

Who changed what in which revision?

UserRevisionLine numberNew contents of line
klauss 114:472502b31a12 1 #include "eth.h"
klauss 114:472502b31a12 2 #include "bits.h"
klauss 116:39a41ebb675c 3 #include "UART3Interrupt.h" // for RXBuffer[ CB_BUFFER_SIZE ];
klauss 114:472502b31a12 4 #include "utils.h"
klauss 114:472502b31a12 5 #include "parallelcpld.h"
klauss 114:472502b31a12 6 #include "debug.h"
klauss 114:472502b31a12 7 #include "flood.h"
klauss 114:472502b31a12 8 #include "call_manager.h"
klauss 114:472502b31a12 9 #include "call_box_manager.h"
klauss 114:472502b31a12 10 #include "sip_manager.h"
klauss 114:472502b31a12 11 #include "shared_variables.h"
klauss 114:472502b31a12 12 #include "prompt.h"
klauss 114:472502b31a12 13 #include "configs.h"
klauss 114:472502b31a12 14 #include "sdram.h"
klauss 114:472502b31a12 15 #include "fw.h"
klauss 87:679ee0d594a9 16 volatile u16_t lpc_low_level_input_counter = 0;
klauss 85:b6f2dc1d0f4f 17
klauss 91:c2a86b1f8aaa 18 int main()
klauss 114:472502b31a12 19 {
klauss 81:3656f00ab3db 20 init_wdt();
klauss 91:c2a86b1f8aaa 21
klauss 81:3656f00ab3db 22 config_lpc();
klauss 91:c2a86b1f8aaa 23
klauss 0:4d17cd9c8f9d 24 start_cpld();
klauss 91:c2a86b1f8aaa 25
klauss 100:09a23fcd3bdf 26 debug_uart3 = true;
klauss 91:c2a86b1f8aaa 27 if( sdram_init() == 1 ) {
klauss 114:472502b31a12 28 send_msg("******* Failed to initialize SDRAM *******");
klauss 87:679ee0d594a9 29 return 1;
klauss 89:0fe315117b00 30 } else {
klauss 114:472502b31a12 31 send_msg("******* Success to initialize SDRAM *******");
klauss 87:679ee0d594a9 32 }
klauss 91:c2a86b1f8aaa 33
klauss 43:455522f98de5 34 init_fsystem();
klauss 91:c2a86b1f8aaa 35
klauss 89:0fe315117b00 36 {
klauss 89:0fe315117b00 37 char s[ 32 ];
klauss 89:0fe315117b00 38 mbed_mac_address( s );
klauss 114:472502b31a12 39 send_msg( "::Mac::%02x:%02x:%02x:%02x:%02x:%02x:: ", s[0],s[1],s[2],s[3],s[4],s[5] );
klauss 89:0fe315117b00 40 }
klauss 91:c2a86b1f8aaa 41
klauss 78:1353744f01e1 42 short int eth_status = __init_eth__();
klauss 91:c2a86b1f8aaa 43 if( eth_status ) {
klauss 114:472502b31a12 44 send_msg("******* Cannot connect to eth *******");
klauss 91:c2a86b1f8aaa 45 } else {
klauss 114:472502b31a12 46 send_msg("******* Connection eth - ok *******");
klauss 78:1353744f01e1 47 init_prompt_eth();
klauss 111:c0833f2455ed 48 init_external_wdt();
klauss 8:e3bfe62a477e 49 }
klauss 91:c2a86b1f8aaa 50
klauss 78:1353744f01e1 51 Timer sync_timer, led_sync_timer;
klauss 114:472502b31a12 52 sync_timer.start(), led_sync_timer.start();
klauss 91:c2a86b1f8aaa 53
klauss 114:472502b31a12 54 /* representa ramal do call box */
klauss 0:4d17cd9c8f9d 55 int ext = 0;
klauss 91:c2a86b1f8aaa 56
klauss 114:472502b31a12 57 /* representa porta do call box */
klauss 78:1353744f01e1 58 int port = 0;
klauss 91:c2a86b1f8aaa 59
klauss 114:472502b31a12 60 /* buffer para onde se copia os dados vindos do cb para tratameno interno */
klauss 116:39a41ebb675c 61 uint8_t buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 62
klauss 114:472502b31a12 63 /* buffer de escrita do pacote de saida que sera enviado pro cb / servidor */
klauss 116:39a41ebb675c 64 uint8_t write_buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 65
klauss 114:472502b31a12 66 /* ponteiro que aponta para os dados vindo do CPLD */
klauss 0:4d17cd9c8f9d 67 uint8_t * buffer_from_cb_ptr = ( uint8_t * )RXBuffer;
klauss 91:c2a86b1f8aaa 68
klauss 114:472502b31a12 69 /* Armazena o ultimo pacote recebido dos CBx */
klauss 116:39a41ebb675c 70 uint8_t cb_rx_buffer[ CB_BUFFER_SIZE ];
klauss 91:c2a86b1f8aaa 71
klauss 114:472502b31a12 72 /* referencia para os dados contidos no pacote, sem o header */
klauss 0:4d17cd9c8f9d 73 uint8_t * data = NULL;
klauss 91:c2a86b1f8aaa 74
klauss 114:472502b31a12 75 /* gerencia o tipo do pacote para providenciar tratamento adequado */
klauss 0:4d17cd9c8f9d 76 volatile uint8_t type = __DO_NOTHING__;
klauss 91:c2a86b1f8aaa 77
klauss 114:472502b31a12 78 /* representa a lista dos Call Boxes atualmente recfonhecidos pela cabeceira */
klauss 0:4d17cd9c8f9d 79 Vector * v_cb = new Vector();
klauss 91:c2a86b1f8aaa 80
klauss 114:472502b31a12 81 /* representa a lista de ligacoes ativas na cabeceira */
klauss 0:4d17cd9c8f9d 82 Vector * v_call = new Vector();
klauss 91:c2a86b1f8aaa 83
klauss 114:472502b31a12 84 /* gerencia a distribuicao de timeslice para os call boxes */
klauss 0:4d17cd9c8f9d 85 Timeslice * ts = new Timeslice();
klauss 91:c2a86b1f8aaa 86 if( ts == NULL ) {
klauss 89:0fe315117b00 87 memory_is_over = true;
klauss 89:0fe315117b00 88 if( debug_memory ) debug_msg("TS allocation fail");
klauss 89:0fe315117b00 89 }
klauss 91:c2a86b1f8aaa 90
klauss 114:472502b31a12 91 /* instancia o vetor de call boxes // calls */
klauss 91:c2a86b1f8aaa 92 if( v_cb == NULL ) {
klauss 91:c2a86b1f8aaa 93 while( v_cb == NULL ) {
klauss 0:4d17cd9c8f9d 94 Vector * v_cb = new Vector();
klauss 91:c2a86b1f8aaa 95 if( sync_timer.read() > 5 ) {
klauss 48:195c97f12e8e 96 send_msg("Erro ao alocar o vetor de CBx");
klauss 78:1353744f01e1 97 sync_timer.reset();
klauss 0:4d17cd9c8f9d 98 }
klauss 0:4d17cd9c8f9d 99 }
klauss 116:39a41ebb675c 100 }
klauss 116:39a41ebb675c 101
klauss 116:39a41ebb675c 102 // aloca o vetor de calls
klauss 116:39a41ebb675c 103 if( v_call == NULL ) {
klauss 91:c2a86b1f8aaa 104 while( v_call == NULL ) {
klauss 0:4d17cd9c8f9d 105 Vector * v_call = new Vector();
klauss 91:c2a86b1f8aaa 106 if( sync_timer.read() > 5 ) {
klauss 48:195c97f12e8e 107 send_msg("Erro ao alocar o vetor de Calls");
klauss 78:1353744f01e1 108 sync_timer.reset();
klauss 0:4d17cd9c8f9d 109 }
klauss 0:4d17cd9c8f9d 110 }
klauss 0:4d17cd9c8f9d 111 }
klauss 91:c2a86b1f8aaa 112
klauss 91:c2a86b1f8aaa 113 if( v_cb == NULL ) {
klauss 89:0fe315117b00 114 memory_is_over = true;
klauss 89:0fe315117b00 115 if( debug_memory ) debug_msg("Call_Box vector allocation fail");
klauss 89:0fe315117b00 116 }
klauss 91:c2a86b1f8aaa 117
klauss 91:c2a86b1f8aaa 118 if( v_call == NULL ) {
klauss 89:0fe315117b00 119 memory_is_over = true;
klauss 89:0fe315117b00 120 if( debug_memory ) debug_msg("Call vector allocation fail");
klauss 89:0fe315117b00 121 }
klauss 91:c2a86b1f8aaa 122
klauss 116:39a41ebb675c 123 for( register uint16_t i = 0; i < CB_BUFFER_SIZE; i++ ) {
klauss 63:0d95da692bb4 124 cb_rx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 125 cb_tx_buffer[ i ] = 0;
klauss 63:0d95da692bb4 126 }
klauss 91:c2a86b1f8aaa 127
klauss 0:4d17cd9c8f9d 128 reset_leds();
klauss 91:c2a86b1f8aaa 129
klauss 33:735fd60e96d8 130 udp_timer.start();
klauss 114:472502b31a12 131
klauss 99:e80850c51106 132 init_fw_handler();
klauss 99:e80850c51106 133
klauss 99:e80850c51106 134 led2 = 0;
klauss 81:3656f00ab3db 135 init_ranges();
klauss 114:472502b31a12 136
klauss 80:61d61c9eb75c 137 init_refresh();
klauss 91:c2a86b1f8aaa 138
klauss 89:0fe315117b00 139 init_sync_refresh();
klauss 91:c2a86b1f8aaa 140
klauss 114:472502b31a12 141 //init_invite_pgk_retry_manager();
klauss 114:472502b31a12 142
klauss 114:472502b31a12 143 //void init_bye_pgk_retry_manager();
klauss 114:472502b31a12 144
klauss 62:07e5bdc9f8f7 145 static uint8_t count = 0;
klauss 91:c2a86b1f8aaa 146
klauss 114:472502b31a12 147 //short int bl_ret = init_bl_handler();
klauss 114:472502b31a12 148 //if( dbl ) send_msg("Valor de retorno do bl_habdler = %d", bl_ret );
klauss 114:472502b31a12 149
klauss 78:1353744f01e1 150 uint8_t max_registered_cbx = 0;
klauss 91:c2a86b1f8aaa 151
klauss 81:3656f00ab3db 152 bool wake_all = false;
klauss 91:c2a86b1f8aaa 153
klauss 81:3656f00ab3db 154 uint16_t pkg_wdt = RX_CB_IDLE;
klauss 81:3656f00ab3db 155 uint16_t eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 109:a5b8264ffbbc 156 led1 = 0;
klauss 114:472502b31a12 157 send_msg("Ready");
klauss 114:472502b31a12 158
klauss 114:472502b31a12 159 //bool registry_test = false;
klauss 114:472502b31a12 160 //static int next_value = 5002;
klauss 114:472502b31a12 161 //static int nex_test_registry = next_value;
klauss 105:a930035b6556 162
klauss 114:472502b31a12 163 //bool invite_retry_time = false;
klauss 99:e80850c51106 164 Timer invite_retry_timer;
klauss 99:e80850c51106 165 invite_retry_timer.start();
klauss 114:472502b31a12 166 debug_uart3 = false;
klauss 105:a930035b6556 167
klauss 114:472502b31a12 168 Timer test_timer;
klauss 115:a1e1e2e60a2c 169
klauss 115:a1e1e2e60a2c 170 reset_leds();
klauss 91:c2a86b1f8aaa 171
klauss 78:1353744f01e1 172 /*------------------------------------------ main loop ---------------------------------------------------------------*/
klauss 115:a1e1e2e60a2c 173 while( true )
klauss 115:a1e1e2e60a2c 174 {
klauss 78:1353744f01e1 175 if( v_cb->size() > max_registered_cbx ) max_registered_cbx = v_cb->size();
klauss 91:c2a86b1f8aaa 176
klauss 115:a1e1e2e60a2c 177 if( sync_timer.read() > 5 )
klauss 115:a1e1e2e60a2c 178 {
klauss 78:1353744f01e1 179 sync_timer.reset();
klauss 91:c2a86b1f8aaa 180
klauss 115:a1e1e2e60a2c 181 if( debug_cks == true ) { pcks_s = true; }
klauss 91:c2a86b1f8aaa 182
klauss 115:a1e1e2e60a2c 183 if( debug_alive == true ) { pshowcb = true; }
klauss 105:a930035b6556 184
klauss 114:472502b31a12 185 if( !( ++count % 15 ) ) {
klauss 91:c2a86b1f8aaa 186 if( eth_status ) {
klauss 78:1353744f01e1 187 eth_status = __init_eth__();
klauss 91:c2a86b1f8aaa 188 if( eth_status ) {
klauss 114:472502b31a12 189 if( debug_main ) debug_msg("Cannot connect to eth");
klauss 91:c2a86b1f8aaa 190 } else {
klauss 114:472502b31a12 191 if( debug_main ) debug_msg("Connection eth - ok");
klauss 78:1353744f01e1 192 init_prompt_eth();
klauss 114:472502b31a12 193 init_external_wdt();
klauss 78:1353744f01e1 194 }
klauss 78:1353744f01e1 195 }
klauss 78:1353744f01e1 196 }
klauss 100:09a23fcd3bdf 197
klauss 114:472502b31a12 198 //35 sec.
klauss 91:c2a86b1f8aaa 199 if( ( count > 7 ) && ( wake_all == false ) ) {
klauss 81:3656f00ab3db 200 wake_all = true;
klauss 78:1353744f01e1 201 if( debug_wake == true ) send_msg( "Time to wake" );
klauss 78:1353744f01e1 202 }
klauss 116:39a41ebb675c 203
klauss 116:39a41ebb675c 204 // enable na variavel que exibe lista com estatisticas de pacotes que falharam ao serem enviados via interface eth
klauss 116:39a41ebb675c 205 if( debug_missed )
klauss 116:39a41ebb675c 206 {
klauss 116:39a41ebb675c 207 missed_send_udp_pkg = true;
klauss 116:39a41ebb675c 208 }
klauss 116:39a41ebb675c 209
klauss 114:472502b31a12 210 }
klauss 91:c2a86b1f8aaa 211
klauss 114:472502b31a12 212 //FIXMEj colocar uma condicao aqui caso necessario pra nao comprometer ligacoes ...
klauss 116:39a41ebb675c 213 prompt_process( NULL, 0 );
klauss 114:472502b31a12 214
klauss 91:c2a86b1f8aaa 215 if( r_stats ) {
klauss 91:c2a86b1f8aaa 216 boot_counter = 0;
klauss 91:c2a86b1f8aaa 217 registry_counter = 0;
klauss 91:c2a86b1f8aaa 218 invite_counter = 0;
klauss 91:c2a86b1f8aaa 219 audio_counter = 0;
klauss 91:c2a86b1f8aaa 220 telemetry_counter = 0;
klauss 91:c2a86b1f8aaa 221 cb_bye_counter = 0;
klauss 91:c2a86b1f8aaa 222 prompt_counter = 0;
klauss 91:c2a86b1f8aaa 223 flood_counter = 0;
klauss 67:cdedc64d9921 224 bootloader_cbx_counter = 0;
klauss 99:e80850c51106 225 cb_stats_counter = 0;
klauss 116:39a41ebb675c 226 fw_counter = 0;
klauss 63:0d95da692bb4 227 r_stats = false;
klauss 63:0d95da692bb4 228 stats = true;
klauss 63:0d95da692bb4 229 }
klauss 91:c2a86b1f8aaa 230
klauss 115:a1e1e2e60a2c 231 if( stats )
klauss 115:a1e1e2e60a2c 232 {
klauss 63:0d95da692bb4 233 char str[ 200 ];
klauss 115:a1e1e2e60a2c 234 snprintf( str, 200, ""
klauss 115:a1e1e2e60a2c 235 "\n\rReceived Pkgs::\n\r "
klauss 115:a1e1e2e60a2c 236 "Boot :: %u\n\r "
klauss 115:a1e1e2e60a2c 237 "Registry :: %u\n\r "
klauss 115:a1e1e2e60a2c 238 "Invite :: %u\n\r "
klauss 115:a1e1e2e60a2c 239 "Audio :: %u\n\r "
klauss 115:a1e1e2e60a2c 240 "Telemetry :: %u\n\r "
klauss 115:a1e1e2e60a2c 241 "CB_stats :: %u\n\r "
klauss 115:a1e1e2e60a2c 242 "CB_bye :: %u\n\r "
klauss 115:a1e1e2e60a2c 243 "Prompt :: %u\n\r "
klauss 115:a1e1e2e60a2c 244 "Flood :: %u\n\r "
klauss 116:39a41ebb675c 245 "Flood :: %u\n\r "
klauss 115:a1e1e2e60a2c 246 "Bootloader_cbx :: %u\n\r",
klauss 115:a1e1e2e60a2c 247 boot_counter,
klauss 115:a1e1e2e60a2c 248 registry_counter,
klauss 115:a1e1e2e60a2c 249 invite_counter,
klauss 115:a1e1e2e60a2c 250 audio_counter,
klauss 115:a1e1e2e60a2c 251 telemetry_counter,
klauss 115:a1e1e2e60a2c 252 cb_stats_counter,
klauss 115:a1e1e2e60a2c 253 cb_bye_counter,
klauss 115:a1e1e2e60a2c 254 prompt_counter,
klauss 116:39a41ebb675c 255 flood_counter,
klauss 116:39a41ebb675c 256 flood_counter,
klauss 115:a1e1e2e60a2c 257 bootloader_cbx_counter
klauss 115:a1e1e2e60a2c 258 );
klauss 63:0d95da692bb4 259 send_msg( str );
klauss 63:0d95da692bb4 260 stats =false;
klauss 63:0d95da692bb4 261 }
klauss 114:472502b31a12 262
klauss 115:a1e1e2e60a2c 263 if( list )
klauss 115:a1e1e2e60a2c 264 {
klauss 78:1353744f01e1 265 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 91:c2a86b1f8aaa 266
klauss 78:1353744f01e1 267 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 91:c2a86b1f8aaa 268
klauss 78:1353744f01e1 269 if( min_ext % 2 ) missed_cb++;
klauss 91:c2a86b1f8aaa 270
klauss 78:1353744f01e1 271 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 91:c2a86b1f8aaa 272
klauss 78:1353744f01e1 273 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 274 if( v_cb->size() == 1 ) {
klauss 78:1353744f01e1 275 send_msg(" %d ", ( ( Call_Box * )v_cb->get_element( 0 ) )->get_ext() );
klauss 91:c2a86b1f8aaa 276 } else if( v_cb->size() > 1 ) {
klauss 62:07e5bdc9f8f7 277 char str[ 1024 ];
klauss 78:1353744f01e1 278 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 62:07e5bdc9f8f7 279 register int i = 0;
klauss 91:c2a86b1f8aaa 280 for( ; i < v_cb->size(); i++ ) {
klauss 78:1353744f01e1 281 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 62:07e5bdc9f8f7 282 }
klauss 91:c2a86b1f8aaa 283
klauss 62:07e5bdc9f8f7 284 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 91:c2a86b1f8aaa 285
klauss 62:07e5bdc9f8f7 286 char aux[ 16 ];
klauss 78:1353744f01e1 287 strcpy( str, "\r\n> " );
klauss 91:c2a86b1f8aaa 288 for( i = 0; i < v_cb->size() - 1; i++ ) {
klauss 62:07e5bdc9f8f7 289 sprintf( aux, "%i, ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 290 strcat( str, aux );
klauss 78:1353744f01e1 291 if( ( i != 0 ) && !( ( i + 1 ) % 16 ) ) strcat( str, "\r\n> " );
klauss 62:07e5bdc9f8f7 292 }
klauss 62:07e5bdc9f8f7 293 sprintf( aux, "%i ", ext_list[ i ] );
klauss 62:07e5bdc9f8f7 294 strcat( str, aux );
klauss 62:07e5bdc9f8f7 295 send_msg( "%s", str );
klauss 62:07e5bdc9f8f7 296 }
klauss 91:c2a86b1f8aaa 297 list = false;
klauss 114:472502b31a12 298 }
klauss 114:472502b31a12 299
klauss 106:a34fcf9f0e02 300 if( long_list )
klauss 106:a34fcf9f0e02 301 {
klauss 106:a34fcf9f0e02 302 uint8_t missed_cb = ( ( max_ext - min_ext ) + 1 ) - v_cb->size();
klauss 91:c2a86b1f8aaa 303
klauss 106:a34fcf9f0e02 304 if( ( max_ext % 2 ) == 0 ) missed_cb++;
klauss 106:a34fcf9f0e02 305
klauss 106:a34fcf9f0e02 306 if( min_ext % 2 ) missed_cb++;
klauss 106:a34fcf9f0e02 307
klauss 106:a34fcf9f0e02 308 if( min_ext == 0 && max_ext == 0 ) missed_cb = 0;
klauss 106:a34fcf9f0e02 309
klauss 106:a34fcf9f0e02 310 {
klauss 106:a34fcf9f0e02 311 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 106:a34fcf9f0e02 312
klauss 106:a34fcf9f0e02 313 if( v_cb->size() >= 1 ) {
klauss 106:a34fcf9f0e02 314 for( register int i = 0; i < v_cb->size(); i++ )
klauss 106:a34fcf9f0e02 315 {
klauss 106:a34fcf9f0e02 316 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 106:a34fcf9f0e02 317 }
klauss 106:a34fcf9f0e02 318 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 106:a34fcf9f0e02 319 }
klauss 106:a34fcf9f0e02 320
klauss 106:a34fcf9f0e02 321 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 322
klauss 106:a34fcf9f0e02 323 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 106:a34fcf9f0e02 324
klauss 106:a34fcf9f0e02 325 Call_Box * cb = __find_CB__( v_cb, ext_list[ i ] );
klauss 106:a34fcf9f0e02 326
klauss 106:a34fcf9f0e02 327 if( cb != NULL )
klauss 106:a34fcf9f0e02 328 {
klauss 106:a34fcf9f0e02 329 char cb_status[ 32 ];
klauss 106:a34fcf9f0e02 330 char cb_sip_status[ 32 ];
klauss 106:a34fcf9f0e02 331 switch( cb->status ) {
klauss 106:a34fcf9f0e02 332 case cb_idle : {
klauss 106:a34fcf9f0e02 333 strcpy( cb_status, "cb_idle" );
klauss 106:a34fcf9f0e02 334 break;
klauss 106:a34fcf9f0e02 335 }
klauss 106:a34fcf9f0e02 336 case cb_ringing : {
klauss 106:a34fcf9f0e02 337 strcpy( cb_status, "cb_ringing" );
klauss 106:a34fcf9f0e02 338 break;
klauss 106:a34fcf9f0e02 339 }
klauss 106:a34fcf9f0e02 340 case cb_trying : {
klauss 106:a34fcf9f0e02 341 strcpy( cb_status,"cb_trying" );
klauss 106:a34fcf9f0e02 342 break;
klauss 106:a34fcf9f0e02 343 }
klauss 106:a34fcf9f0e02 344 case cb_on_call : {
klauss 106:a34fcf9f0e02 345 strcpy( cb_status, "cb_on_call" );
klauss 106:a34fcf9f0e02 346 break;
klauss 106:a34fcf9f0e02 347 }
klauss 106:a34fcf9f0e02 348 case cb_busy : {
klauss 106:a34fcf9f0e02 349 strcpy( cb_status, "cb_busy" );
klauss 106:a34fcf9f0e02 350 break;
klauss 106:a34fcf9f0e02 351 }
klauss 106:a34fcf9f0e02 352 case cb_denied : {
klauss 106:a34fcf9f0e02 353 strcpy( cb_status, "cb_denied" );
klauss 106:a34fcf9f0e02 354 break;
klauss 106:a34fcf9f0e02 355 }
klauss 106:a34fcf9f0e02 356 }
klauss 106:a34fcf9f0e02 357 switch( cb->sip->status ) {
klauss 106:a34fcf9f0e02 358 case sip_idle : {
klauss 106:a34fcf9f0e02 359 strcpy( cb_sip_status, "sip_idle" );
klauss 106:a34fcf9f0e02 360 break;
klauss 106:a34fcf9f0e02 361 }
klauss 106:a34fcf9f0e02 362 case sip_waiting_trying : {
klauss 106:a34fcf9f0e02 363 strcpy( cb_sip_status, "sip_waiting_trying" );
klauss 106:a34fcf9f0e02 364 break;
klauss 106:a34fcf9f0e02 365 }
klauss 106:a34fcf9f0e02 366 case sip_trying : {
klauss 106:a34fcf9f0e02 367 strcpy( cb_sip_status, "sip_trying" );
klauss 106:a34fcf9f0e02 368 break;
klauss 106:a34fcf9f0e02 369 }
klauss 106:a34fcf9f0e02 370 case sip_ringing : {
klauss 106:a34fcf9f0e02 371 strcpy( cb_sip_status, "sip_ringing" );
klauss 106:a34fcf9f0e02 372 break;
klauss 106:a34fcf9f0e02 373 }
klauss 106:a34fcf9f0e02 374 case sip_busy : {
klauss 106:a34fcf9f0e02 375 strcpy( cb_sip_status, "sip_busy" );
klauss 106:a34fcf9f0e02 376 break;
klauss 106:a34fcf9f0e02 377 }
klauss 106:a34fcf9f0e02 378 case sip_ok : {
klauss 106:a34fcf9f0e02 379 strcpy( cb_sip_status, "sip_ok" );
klauss 106:a34fcf9f0e02 380 break;
klauss 106:a34fcf9f0e02 381 }
klauss 106:a34fcf9f0e02 382 case sip_on_call : {
klauss 106:a34fcf9f0e02 383 strcpy( cb_sip_status, "sip_on_call" );
klauss 106:a34fcf9f0e02 384 break;
klauss 106:a34fcf9f0e02 385 }
klauss 106:a34fcf9f0e02 386 case sip_denied : {
klauss 106:a34fcf9f0e02 387 strcpy( cb_sip_status, "sip_denied" );
klauss 106:a34fcf9f0e02 388 break;
klauss 106:a34fcf9f0e02 389 }
klauss 106:a34fcf9f0e02 390 }
klauss 106:a34fcf9f0e02 391 char cbx_to_string[ 254 ];
klauss 106:a34fcf9f0e02 392 char aux[ 16 ];
klauss 106:a34fcf9f0e02 393 strcpy( cbx_to_string, "Ext :: " );
klauss 106:a34fcf9f0e02 394 itoa( cb->get_ext(), aux , 10 );
klauss 106:a34fcf9f0e02 395 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 396 strcat( cbx_to_string, " :: Port :: " );
klauss 106:a34fcf9f0e02 397 itoa( cb->get_port(), aux , 10 );
klauss 106:a34fcf9f0e02 398 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 399 strcat( cbx_to_string, " :: Status -- " );
klauss 106:a34fcf9f0e02 400 strcat( cbx_to_string, cb_status );
klauss 106:a34fcf9f0e02 401 strcat( cbx_to_string, " - " );
klauss 106:a34fcf9f0e02 402 strcat( cbx_to_string, cb_sip_status );
klauss 106:a34fcf9f0e02 403 if( cb->get_timeslice() != 0 ) {
klauss 106:a34fcf9f0e02 404 strcat( cbx_to_string, " -- on TimeSlice :: " );
klauss 106:a34fcf9f0e02 405 itoa( cb->get_timeslice(), aux , 10 );
klauss 106:a34fcf9f0e02 406 strcat( cbx_to_string, aux );
klauss 106:a34fcf9f0e02 407 }
klauss 106:a34fcf9f0e02 408 send_msg( cbx_to_string );
klauss 106:a34fcf9f0e02 409 }
klauss 106:a34fcf9f0e02 410 }
klauss 106:a34fcf9f0e02 411
klauss 106:a34fcf9f0e02 412 }
klauss 91:c2a86b1f8aaa 413 long_list = false;
klauss 52:12930cef17c4 414 }
klauss 114:472502b31a12 415
klauss 115:a1e1e2e60a2c 416 if( pshowcb == true )
klauss 115:a1e1e2e60a2c 417 {
klauss 78:1353744f01e1 418 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 419 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 30:8dfb6d8de53d 420 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 78:1353744f01e1 421 char cb_status[ 32 ];
klauss 78:1353744f01e1 422 char cb_sip_status[ 32 ];
klauss 91:c2a86b1f8aaa 423 switch( cb->status ) {
klauss 91:c2a86b1f8aaa 424 case cb_idle : {
klauss 91:c2a86b1f8aaa 425 strcpy( cb_status, "cb_idle" );
klauss 91:c2a86b1f8aaa 426 break;
klauss 91:c2a86b1f8aaa 427 }
klauss 91:c2a86b1f8aaa 428 case cb_ringing : {
klauss 91:c2a86b1f8aaa 429 strcpy( cb_status, "cb_ringing" );
klauss 91:c2a86b1f8aaa 430 break;
klauss 91:c2a86b1f8aaa 431 }
klauss 91:c2a86b1f8aaa 432 case cb_trying : {
klauss 91:c2a86b1f8aaa 433 strcpy( cb_status,"cb_trying" );
klauss 91:c2a86b1f8aaa 434 break;
klauss 91:c2a86b1f8aaa 435 }
klauss 91:c2a86b1f8aaa 436 case cb_on_call : {
klauss 91:c2a86b1f8aaa 437 strcpy( cb_status, "cb_on_call" );
klauss 91:c2a86b1f8aaa 438 break;
klauss 91:c2a86b1f8aaa 439 }
klauss 91:c2a86b1f8aaa 440 case cb_busy : {
klauss 91:c2a86b1f8aaa 441 strcpy( cb_status, "cb_busy" );
klauss 91:c2a86b1f8aaa 442 break;
klauss 91:c2a86b1f8aaa 443 }
klauss 91:c2a86b1f8aaa 444 case cb_denied : {
klauss 91:c2a86b1f8aaa 445 strcpy( cb_status, "cb_denied" );
klauss 91:c2a86b1f8aaa 446 break;
klauss 91:c2a86b1f8aaa 447 }
klauss 78:1353744f01e1 448 }
klauss 91:c2a86b1f8aaa 449 switch( cb->sip->status ) {
klauss 91:c2a86b1f8aaa 450 case sip_idle : {
klauss 91:c2a86b1f8aaa 451 strcpy( cb_sip_status, "sip_idle" );
klauss 91:c2a86b1f8aaa 452 break;
klauss 91:c2a86b1f8aaa 453 }
klauss 91:c2a86b1f8aaa 454 case sip_waiting_trying : {
klauss 91:c2a86b1f8aaa 455 strcpy( cb_sip_status, "sip_waiting_trying" );
klauss 91:c2a86b1f8aaa 456 break;
klauss 91:c2a86b1f8aaa 457 }
klauss 91:c2a86b1f8aaa 458 case sip_trying : {
klauss 91:c2a86b1f8aaa 459 strcpy( cb_sip_status, "sip_trying" );
klauss 91:c2a86b1f8aaa 460 break;
klauss 91:c2a86b1f8aaa 461 }
klauss 91:c2a86b1f8aaa 462 case sip_ringing : {
klauss 91:c2a86b1f8aaa 463 strcpy( cb_sip_status, "sip_ringing" );
klauss 91:c2a86b1f8aaa 464 break;
klauss 91:c2a86b1f8aaa 465 }
klauss 91:c2a86b1f8aaa 466 case sip_busy : {
klauss 91:c2a86b1f8aaa 467 strcpy( cb_sip_status, "sip_busy" );
klauss 91:c2a86b1f8aaa 468 break;
klauss 91:c2a86b1f8aaa 469 }
klauss 91:c2a86b1f8aaa 470 case sip_ok : {
klauss 91:c2a86b1f8aaa 471 strcpy( cb_sip_status, "sip_ok" );
klauss 91:c2a86b1f8aaa 472 break;
klauss 91:c2a86b1f8aaa 473 }
klauss 91:c2a86b1f8aaa 474 case sip_on_call : {
klauss 91:c2a86b1f8aaa 475 strcpy( cb_sip_status, "sip_on_call" );
klauss 91:c2a86b1f8aaa 476 break;
klauss 91:c2a86b1f8aaa 477 }
klauss 91:c2a86b1f8aaa 478 case sip_denied : {
klauss 91:c2a86b1f8aaa 479 strcpy( cb_sip_status, "sip_denied" );
klauss 91:c2a86b1f8aaa 480 break;
klauss 91:c2a86b1f8aaa 481 }
klauss 78:1353744f01e1 482 }
klauss 78:1353744f01e1 483 char cbx_to_string[ 254 ];
klauss 78:1353744f01e1 484 char aux[ 16 ];
klauss 78:1353744f01e1 485 strcpy( cbx_to_string, "Ext :: " );
klauss 78:1353744f01e1 486 itoa( cb->get_ext(), aux , 10 );
klauss 98:43b45f26b430 487 strcat( cbx_to_string, aux );
klauss 97:8985817e8847 488 strcat( cbx_to_string, " :: Port :: " );
klauss 97:8985817e8847 489 itoa( cb->get_port(), aux , 10 );
klauss 78:1353744f01e1 490 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 491 strcat( cbx_to_string, " :: Status -- " );
klauss 78:1353744f01e1 492 strcat( cbx_to_string, cb_status );
klauss 78:1353744f01e1 493 strcat( cbx_to_string, " - " );
klauss 78:1353744f01e1 494 strcat( cbx_to_string, cb_sip_status );
klauss 91:c2a86b1f8aaa 495 if( cb->get_timeslice() != 0 ) {
klauss 78:1353744f01e1 496 strcat( cbx_to_string, " -- on TimeSlice :: " );
klauss 78:1353744f01e1 497 itoa( cb->get_timeslice(), aux , 10 );
klauss 78:1353744f01e1 498 strcat( cbx_to_string, aux );
klauss 78:1353744f01e1 499 }
klauss 78:1353744f01e1 500 send_msg( cbx_to_string );
klauss 48:195c97f12e8e 501 }
klauss 78:1353744f01e1 502 pshowcb = false;
klauss 48:195c97f12e8e 503 }
klauss 97:8985817e8847 504
klauss 97:8985817e8847 505 if( show_sip == true ){
klauss 97:8985817e8847 506 show_sip = false;
klauss 99:e80850c51106 507 send_msg(":: Sip :: %u", v_cb->size() );
klauss 97:8985817e8847 508 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 97:8985817e8847 509 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 114:472502b31a12 510 send_msg("ext :: %d -- port :: %d -- timer %d", cb->get_sip_ext(), cb->get_sip_port(), cb->get_timer() );
klauss 97:8985817e8847 511 }
klauss 97:8985817e8847 512 }
klauss 91:c2a86b1f8aaa 513
klauss 81:3656f00ab3db 514 if( pflood == true ) flood();
klauss 91:c2a86b1f8aaa 515
klauss 91:c2a86b1f8aaa 516 if( debug_eth ) {
klauss 81:3656f00ab3db 517 debug_eth = false;
klauss 81:3656f00ab3db 518 send_msg("Eth status %s", ( eth_status == 0 ) ? "Connected" : "Disconnected" );
klauss 81:3656f00ab3db 519 }
klauss 91:c2a86b1f8aaa 520
klauss 91:c2a86b1f8aaa 521 if( status != __WAITING__ ) {
klauss 81:3656f00ab3db 522 pkg_wdt = RX_CB_IDLE;
klauss 116:39a41ebb675c 523 xmemcpy( cb_rx_buffer, buffer_from_cb_ptr, CB_BUFFER_SIZE );
klauss 0:4d17cd9c8f9d 524 status = __WAITING__;
klauss 81:3656f00ab3db 525 missed_pkg--;
klauss 116:39a41ebb675c 526 xmemcpy( buffer, cb_rx_buffer, CB_BUFFER_SIZE );
klauss 91:c2a86b1f8aaa 527
klauss 91:c2a86b1f8aaa 528 if( rx ) {
klauss 81:3656f00ab3db 529 char str[ 1024 ];
klauss 81:3656f00ab3db 530 strcpy( str, "RX :: \n\r " );
klauss 116:39a41ebb675c 531 for( register uint16_t i = 0; i < CB_BUFFER_SIZE; i++ ) {
klauss 81:3656f00ab3db 532 char tmp[ 16 ];
klauss 81:3656f00ab3db 533 strcat( str, itoa( cb_rx_buffer[ i ], tmp, 16 ) );
klauss 81:3656f00ab3db 534 if( ( i != 0 ) && !( ( i + 1 ) % 50 ) ) strcat( str, "\n\r " );
klauss 91:c2a86b1f8aaa 535
klauss 81:3656f00ab3db 536 else strcat( str, " " );
klauss 81:3656f00ab3db 537 }
klauss 81:3656f00ab3db 538 send_msg( "%s", str );
klauss 91:c2a86b1f8aaa 539 rx = false;
klauss 81:3656f00ab3db 540 }
klauss 91:c2a86b1f8aaa 541
klauss 116:39a41ebb675c 542 data = parse_vz_pkg ( &ext, &port, &type, buffer );
klauss 114:472502b31a12 543
klauss 115:a1e1e2e60a2c 544 if( data != NULL )
klauss 115:a1e1e2e60a2c 545 {
klauss 78:1353744f01e1 546 if( min_ext == 0 ) min_ext = ext;
klauss 91:c2a86b1f8aaa 547
klauss 78:1353744f01e1 548 if( ext > max_ext ) max_ext = ext;
klauss 91:c2a86b1f8aaa 549
klauss 78:1353744f01e1 550 if( ext < min_ext ) min_ext = ext;
klauss 99:e80850c51106 551
klauss 115:a1e1e2e60a2c 552 if( debug_fw ){ fw_cbx_pkg( ext, port, ( char *)buffer ); }
klauss 99:e80850c51106 553
klauss 114:472502b31a12 554 if( type == __TELEMETRY__ ) telemetry_counter++;
klauss 114:472502b31a12 555
klauss 114:472502b31a12 556 if( type != __AUDIO__ ) {
klauss 99:e80850c51106 557 if(
klauss 99:e80850c51106 558 type == __TELEMETRY__ ||
klauss 99:e80850c51106 559 type == __CB_STATS__ ||
klauss 99:e80850c51106 560 type == __FW1__ ||
klauss 99:e80850c51106 561 type == __FW2__ ||
klauss 99:e80850c51106 562 type == __FW3__ ||
klauss 99:e80850c51106 563 type == __FW4__ ||
klauss 99:e80850c51106 564 type == __FW5__ ||
klauss 99:e80850c51106 565 type == __FW6__
klauss 99:e80850c51106 566 ) type = __FW__;
klauss 99:e80850c51106 567
klauss 99:e80850c51106 568 if( debug_cb_rx == true ){
klauss 99:e80850c51106 569 send_msg("Pkg from CBx :: ( %d, %d ) -- Type :: %d", ext, port, type );
klauss 99:e80850c51106 570 }
klauss 99:e80850c51106 571
klauss 0:4d17cd9c8f9d 572 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 573 if( cb != NULL ) {
klauss 92:92df17f538a8 574 if( data[ 0 ] & BIT7 ) {
klauss 91:c2a86b1f8aaa 575 if( type == __BOOT__ ) {
klauss 116:39a41ebb675c 576 send2callboxes( build_cb_package( ext, port, __REGISTRY__,
klauss 116:39a41ebb675c 577 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 92:92df17f538a8 578 } else {
klauss 81:3656f00ab3db 579 if( debug_main ) debug_msg("Received ack pkg with seq_num %d", data[ 0 ] );
klauss 91:c2a86b1f8aaa 580
klauss 91:c2a86b1f8aaa 581 switch( type ) {
klauss 81:3656f00ab3db 582 case __INVITE__ : {
klauss 115:a1e1e2e60a2c 583 if( debug_main || debug_invite ) debug_msg("Invite Ack from %d on msg_id %d -- Cbx seqNum %d", ext, cb->get_msg_id(), data[ 0 ] );
klauss 91:c2a86b1f8aaa 584 break;
klauss 81:3656f00ab3db 585 }
klauss 81:3656f00ab3db 586 case __CB_BYE__ : {
klauss 81:3656f00ab3db 587 if( debug_main || debug_invite ) debug_msg("BYE Ack from %d on msg_id %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 588 cb->set_bye_response_ok();
klauss 91:c2a86b1f8aaa 589 break;
klauss 81:3656f00ab3db 590 }
klauss 81:3656f00ab3db 591 case __REGISTRY__ : {
klauss 81:3656f00ab3db 592 if( debug_main || debug_aging ) debug_msg("Registry ACK from %d in pkg :: %d", ext, cb->get_msg_id() );
klauss 81:3656f00ab3db 593 break;
klauss 81:3656f00ab3db 594 }
klauss 81:3656f00ab3db 595 default : {
klauss 91:c2a86b1f8aaa 596 if( debug_main || debug_aging ) debug_msg("ACK from %d in pkg :: %d :: type %d", ext, cb->get_msg_id(), type );
klauss 91:c2a86b1f8aaa 597 }
klauss 81:3656f00ab3db 598 }
klauss 115:a1e1e2e60a2c 599 if( type != __REGISTRY__ && type != __CB_BYE__ && type != __INVITE__ ) type = __DO_NOTHING__;
klauss 92:92df17f538a8 600 if( type == __CB_BYE__ ){
klauss 92:92df17f538a8 601 VZ_call * call = __find_Call__( v_call, ext );
klauss 92:92df17f538a8 602 if( call != NULL ){
klauss 92:92df17f538a8 603 if( call->get_elapsed_time() < 120000 ){
klauss 92:92df17f538a8 604 if( debug_invite ) debug_msg("%d ack bye ignored", ext );
klauss 92:92df17f538a8 605 type = __DO_NOTHING__;
klauss 92:92df17f538a8 606 }
klauss 92:92df17f538a8 607 }
klauss 92:92df17f538a8 608 }
klauss 0:4d17cd9c8f9d 609 }
klauss 0:4d17cd9c8f9d 610 }
klauss 0:4d17cd9c8f9d 611 }
klauss 0:4d17cd9c8f9d 612 }
klauss 91:c2a86b1f8aaa 613 } else type = __DO_NOTHING__;
klauss 0:4d17cd9c8f9d 614 }
klauss 91:c2a86b1f8aaa 615
klauss 116:39a41ebb675c 616 if( sizes == true )
klauss 115:a1e1e2e60a2c 617 {
klauss 116:39a41ebb675c 618 sizes = false;
klauss 85:b6f2dc1d0f4f 619 send_msg("CB_New (%u) -- CB_Delete (%u)", cb_new_counter, cb_delete_counter );
klauss 85:b6f2dc1d0f4f 620 send_msg("SIP_New (%u) -- SIP_Delete (%u)", sip_new_counter, sip_delete_counter );
klauss 87:679ee0d594a9 621 send_msg("RTP_header_New (%u) -- RTP_header_Delete (%u)", rtp_header_new_counter, rtp_header_delete_counter );
klauss 87:679ee0d594a9 622 send_msg("RTP_body_New (%u) -- RTP_body_Delete (%u)", rtp_body_new_counter, rtp_body_delete_counter );
klauss 109:a5b8264ffbbc 623 send_msg("Call_New (%u) -- Call_Delete (%u)", call_new_counter, call_delete_counter );
klauss 87:679ee0d594a9 624 send_msg("lpc_low_level_input_counter :: %d", lpc_low_level_input_counter );
klauss 87:679ee0d594a9 625 send_msg("Memory is %s", ( memory_is_over ) ? "Over" : "Ok" );
klauss 81:3656f00ab3db 626 send_msg("Missed_Pkg :: %d ::", missed_pkg );
klauss 87:679ee0d594a9 627 send_msg("Sizeof Sip :: %u", sizeof( Sip ) );
klauss 116:39a41ebb675c 628 send_msg("Sizeof Call_Box :: %u", sizeof ( Call_Box ) );
klauss 87:679ee0d594a9 629 send_msg("Sizeof VZ_call :: %u", sizeof( VZ_call ) );
klauss 87:679ee0d594a9 630 send_msg("Sizeof RTP :: %u", sizeof( RTP ) );
klauss 87:679ee0d594a9 631 send_msg("Sizeof RTP_Header :: %u", sizeof( RTP_Header ) );
klauss 87:679ee0d594a9 632 send_msg("Sizeof RTP_Body :: %u", sizeof( RTP_Body ) );
klauss 87:679ee0d594a9 633 send_msg("Sizeof Vector :: %u", sizeof( Vector ) );
klauss 87:679ee0d594a9 634 send_msg("Sizeof Timeslice :: %u", sizeof( Timeslice ) );
klauss 87:679ee0d594a9 635 send_msg("Sizeof Watchdog :: %u", sizeof( Watchdog ) );
klauss 109:a5b8264ffbbc 636 }
klauss 109:a5b8264ffbbc 637
klauss 114:472502b31a12 638 if ( registra )
klauss 112:6ae726539ab9 639 {
klauss 112:6ae726539ab9 640 int internal_ext = 8000;
klauss 112:6ae726539ab9 641 registra = false;
klauss 112:6ae726539ab9 642 for( register uint8_t i = 0; i < 4; i++ ) {
klauss 112:6ae726539ab9 643 v_cb -> add ( new Call_Box ( internal_ext, internal_ext++ ) );
klauss 112:6ae726539ab9 644 }
klauss 112:6ae726539ab9 645 }
klauss 112:6ae726539ab9 646
klauss 109:a5b8264ffbbc 647 {
klauss 109:a5b8264ffbbc 648 fd_set fdSet;
klauss 109:a5b8264ffbbc 649 FD_ZERO(&fdSet);
klauss 109:a5b8264ffbbc 650
klauss 109:a5b8264ffbbc 651 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 109:a5b8264ffbbc 652 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 109:a5b8264ffbbc 653 FD_SET( cb->get_sip_socket_fd(), &fdSet);
klauss 109:a5b8264ffbbc 654 }
klauss 109:a5b8264ffbbc 655
klauss 109:a5b8264ffbbc 656 FD_SET( udp_wdt_client.get_fd(), &fdSet);
klauss 109:a5b8264ffbbc 657
klauss 109:a5b8264ffbbc 658 struct timeval t;
klauss 109:a5b8264ffbbc 659 t.tv_sec = 0;
klauss 109:a5b8264ffbbc 660 t.tv_usec = 0;
klauss 109:a5b8264ffbbc 661 int ret = lwip_select( FD_SETSIZE, &fdSet, NULL, NULL, &t );
klauss 109:a5b8264ffbbc 662
klauss 109:a5b8264ffbbc 663 if(ret > 0 ) {
klauss 109:a5b8264ffbbc 664 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 109:a5b8264ffbbc 665 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 109:a5b8264ffbbc 666 int fd = cb->get_sip_socket_fd();
klauss 109:a5b8264ffbbc 667 if( FD_ISSET( fd, &fdSet ) ) {
klauss 109:a5b8264ffbbc 668 int rcv = cb->sip_udp_incomming_pkg();
klauss 109:a5b8264ffbbc 669 }
klauss 109:a5b8264ffbbc 670 }
klauss 109:a5b8264ffbbc 671 if( FD_ISSET( udp_wdt_client.get_fd(), &fdSet ) ) {
klauss 109:a5b8264ffbbc 672 char wake_msg[ 768 ];
klauss 109:a5b8264ffbbc 673 Endpoint udp_wdt_server;
klauss 109:a5b8264ffbbc 674
klauss 109:a5b8264ffbbc 675 if( udp_wdt_client.receiveFrom( udp_wdt_server, wake_msg, sizeof( wake_msg ) ) > 0 ){
klauss 109:a5b8264ffbbc 676 if( !( strncmp( wake_msg, "alive", 5 ) ) ) {
klauss 109:a5b8264ffbbc 677 // Just ckeck but not set 'alive?'
klauss 109:a5b8264ffbbc 678 // 'alive*' - force wdt tick right now
klauss 109:a5b8264ffbbc 679 // Ckecking and set 'alive'
klauss 109:a5b8264ffbbc 680 bool question_alive = ( wake_msg[ 5 ] == '?' );
klauss 109:a5b8264ffbbc 681 if( wake_msg[ 5 ] == '*' ) wdt.kick();
klauss 109:a5b8264ffbbc 682
klauss 109:a5b8264ffbbc 683 /*
klauss 109:a5b8264ffbbc 684 uint8_t registered_cbx = v_cb->size();
klauss 109:a5b8264ffbbc 685 for( register int i = 0; i < v_cb->size(); i++ ){
klauss 109:a5b8264ffbbc 686 Call_Box * cb = (Call_Box * )v_cb->get_element( i );
klauss 109:a5b8264ffbbc 687 if( cb->is_timeout() ){ if( registered_cbx ) registered_cbx--; }
klauss 109:a5b8264ffbbc 688 }
klauss 109:a5b8264ffbbc 689 */
klauss 109:a5b8264ffbbc 690
klauss 109:a5b8264ffbbc 691 snprintf( wake_msg, 48,"wdt:%u,%u,%u,%c,%u,%u,%u,%u,%u:",
klauss 109:a5b8264ffbbc 692 uptime,
klauss 109:a5b8264ffbbc 693 invite_counter,
klauss 109:a5b8264ffbbc 694 external_wdt,
klauss 109:a5b8264ffbbc 695 ( wdt.WatchdogCausedReset() ) ? '1' : '0',
klauss 109:a5b8264ffbbc 696 cb_new_counter,
klauss 109:a5b8264ffbbc 697 v_cb->size(),
klauss 109:a5b8264ffbbc 698 ts->remain_timeslices(),
klauss 109:a5b8264ffbbc 699 sip_socket_send_failure,
klauss 109:a5b8264ffbbc 700 v_call->size()
klauss 109:a5b8264ffbbc 701 // registered_cbx
klauss 109:a5b8264ffbbc 702 );
klauss 109:a5b8264ffbbc 703 wake_msg[ 768 - 1 ] = 0;
klauss 109:a5b8264ffbbc 704 udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 109:a5b8264ffbbc 705
klauss 109:a5b8264ffbbc 706 if( ( (!question_alive) && ( cb_new_counter <= __MAX_CB_IN_A_BRANCH__ ) && ( cb_new_counter >= 2 ) ) ) {
klauss 109:a5b8264ffbbc 707 external_wdt = EXTERN_WDT_IDLE;
klauss 109:a5b8264ffbbc 708 }
klauss 109:a5b8264ffbbc 709 } else if( !( strncmp( wake_msg, "reset", 5 ) ) ) {
klauss 109:a5b8264ffbbc 710 external_wdt = 0;
klauss 109:a5b8264ffbbc 711
klauss 109:a5b8264ffbbc 712 sprintf( wake_msg, "rst:%u:", uptime );
klauss 109:a5b8264ffbbc 713 udp_wdt_client.sendTo( udp_wdt_server, wake_msg, strlen( wake_msg ) );
klauss 109:a5b8264ffbbc 714 }
klauss 109:a5b8264ffbbc 715 }
klauss 109:a5b8264ffbbc 716 }
klauss 109:a5b8264ffbbc 717 }
klauss 109:a5b8264ffbbc 718 }
klauss 109:a5b8264ffbbc 719
klauss 112:6ae726539ab9 720 if ( cogumelo )
klauss 112:6ae726539ab9 721 {
klauss 112:6ae726539ab9 722 cogumelo = false;
klauss 112:6ae726539ab9 723 for( register int i = 0; i < v_cb->size(); i++ )
klauss 112:6ae726539ab9 724 {
klauss 112:6ae726539ab9 725 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 112:6ae726539ab9 726 if ( cb )
klauss 112:6ae726539ab9 727 {
klauss 112:6ae726539ab9 728 set_status( cb->status, cb_on_call );
klauss 112:6ae726539ab9 729 set_status( cb->sip->status, sip_on_call );
klauss 112:6ae726539ab9 730 }
klauss 112:6ae726539ab9 731 else
klauss 112:6ae726539ab9 732 {
klauss 112:6ae726539ab9 733 debug_msg("%d congumelo missed", i );
klauss 112:6ae726539ab9 734 }
klauss 112:6ae726539ab9 735 }
klauss 112:6ae726539ab9 736
klauss 112:6ae726539ab9 737 }
klauss 112:6ae726539ab9 738
klauss 112:6ae726539ab9 739 if ( gnomo )
klauss 112:6ae726539ab9 740 {
klauss 112:6ae726539ab9 741 gnomo = false;
klauss 112:6ae726539ab9 742 for( register int i = 0; i < v_cb->size(); i++ )
klauss 112:6ae726539ab9 743 {
klauss 112:6ae726539ab9 744 Call_Box * cb = ( Call_Box * )v_cb->get_element( i );
klauss 112:6ae726539ab9 745 if ( cb )
klauss 112:6ae726539ab9 746 {
klauss 112:6ae726539ab9 747 set_status( cb->status, cb_idle );
klauss 112:6ae726539ab9 748 set_status( cb->sip->status, sip_idle );
klauss 112:6ae726539ab9 749 }
klauss 112:6ae726539ab9 750 else
klauss 112:6ae726539ab9 751 {
klauss 112:6ae726539ab9 752 debug_msg("%d gnomo missed", i );
klauss 112:6ae726539ab9 753 }
klauss 112:6ae726539ab9 754 }
klauss 112:6ae726539ab9 755
klauss 112:6ae726539ab9 756 }
klauss 112:6ae726539ab9 757
klauss 112:6ae726539ab9 758
klauss 109:a5b8264ffbbc 759 if( dshow_rtp == true ){
klauss 109:a5b8264ffbbc 760 dshow_rtp = false;
klauss 109:a5b8264ffbbc 761 send_msg(":: RTP :: %u", v_cb->size() );
klauss 109:a5b8264ffbbc 762
klauss 109:a5b8264ffbbc 763 int ext_list[ __MAX_CB_IN_A_BRANCH__ ];
klauss 109:a5b8264ffbbc 764
klauss 109:a5b8264ffbbc 765 if( v_cb->size() >= 1 ) {
klauss 109:a5b8264ffbbc 766 for( register int i = 0; i < v_cb->size(); i++ )
klauss 109:a5b8264ffbbc 767 {
klauss 109:a5b8264ffbbc 768 ext_list[ i ] = ( ( Call_Box * )v_cb->get_element( i ) )->get_ext();
klauss 109:a5b8264ffbbc 769 }
klauss 109:a5b8264ffbbc 770 qsort( ext_list, v_cb->size(), sizeof( int ), ls_comp );
klauss 109:a5b8264ffbbc 771 }
klauss 109:a5b8264ffbbc 772
klauss 109:a5b8264ffbbc 773 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 109:a5b8264ffbbc 774 {
klauss 109:a5b8264ffbbc 775 Call_Box * cb = __find_CB__( v_cb, ext_list[ i ] );
klauss 109:a5b8264ffbbc 776 if( cb != NULL )
klauss 109:a5b8264ffbbc 777 {
klauss 109:a5b8264ffbbc 778 send_msg("CBX ( %d, %d ) - SIP ( %d, %d ) - RTP ( %d )",
klauss 109:a5b8264ffbbc 779 cb -> get_ext (),
klauss 109:a5b8264ffbbc 780 cb -> get_port (),
klauss 109:a5b8264ffbbc 781 cb -> get_sip_ext (),
klauss 109:a5b8264ffbbc 782 cb -> get_sip_port (),
klauss 109:a5b8264ffbbc 783 cb -> get_rtp_port ()
klauss 109:a5b8264ffbbc 784 );
klauss 109:a5b8264ffbbc 785 }
klauss 109:a5b8264ffbbc 786 }
klauss 109:a5b8264ffbbc 787 }
klauss 109:a5b8264ffbbc 788
klauss 109:a5b8264ffbbc 789 if( malasia )
klauss 109:a5b8264ffbbc 790 {
klauss 109:a5b8264ffbbc 791 malasia = false;
klauss 109:a5b8264ffbbc 792 // conclusao, mudar o nro nao impala, talvez mudar o nro no pacote ...
klauss 109:a5b8264ffbbc 793 Call_Box * cb = __find_CB__( v_cb, 5016 );
klauss 109:a5b8264ffbbc 794 if( cb != NULL )
klauss 109:a5b8264ffbbc 795 {
klauss 109:a5b8264ffbbc 796 cb -> set_rtp_port ( cb -> get_rtp_port () * 10 + 1 );
klauss 109:a5b8264ffbbc 797 send_msg("CBX ( %d, %d ) - SIP ( %d, %d ) - RTP ( %d )",
klauss 109:a5b8264ffbbc 798 cb -> get_ext (),
klauss 109:a5b8264ffbbc 799 cb -> get_port (),
klauss 109:a5b8264ffbbc 800 cb -> get_sip_ext (),
klauss 109:a5b8264ffbbc 801 cb -> get_sip_port (),
klauss 109:a5b8264ffbbc 802 cb -> get_rtp_port ()
klauss 109:a5b8264ffbbc 803 );
klauss 109:a5b8264ffbbc 804 }
klauss 109:a5b8264ffbbc 805 }
klauss 109:a5b8264ffbbc 806
klauss 109:a5b8264ffbbc 807 if( york )
klauss 109:a5b8264ffbbc 808 {
klauss 109:a5b8264ffbbc 809 york = false;
klauss 109:a5b8264ffbbc 810 Call_Box * cb = __find_CB__( v_cb, 5016 );
klauss 109:a5b8264ffbbc 811 if( cb != NULL )
klauss 109:a5b8264ffbbc 812 {
klauss 109:a5b8264ffbbc 813 cb -> set_rtp_port ( 80 );
klauss 109:a5b8264ffbbc 814 send_msg("CBX ( %d, %d ) - SIP ( %d, %d ) - RTP ( %d )",
klauss 109:a5b8264ffbbc 815 cb -> get_ext (),
klauss 109:a5b8264ffbbc 816 cb -> get_port (),
klauss 109:a5b8264ffbbc 817 cb -> get_sip_ext (),
klauss 109:a5b8264ffbbc 818 cb -> get_sip_port (),
klauss 109:a5b8264ffbbc 819 cb -> get_rtp_port ()
klauss 109:a5b8264ffbbc 820 );
klauss 109:a5b8264ffbbc 821 }
klauss 109:a5b8264ffbbc 822 }
klauss 109:a5b8264ffbbc 823
klauss 109:a5b8264ffbbc 824 if ( frtp )
klauss 109:a5b8264ffbbc 825 {
klauss 109:a5b8264ffbbc 826 frtp = false;
klauss 109:a5b8264ffbbc 827 Call_Box * cb = __find_CB__( v_cb, frtp_target );
klauss 109:a5b8264ffbbc 828 if ( cb != NULL )
klauss 109:a5b8264ffbbc 829 {
klauss 109:a5b8264ffbbc 830 cb -> set_rtp_port ( -1008789032 );
klauss 109:a5b8264ffbbc 831 }
klauss 109:a5b8264ffbbc 832 else
klauss 109:a5b8264ffbbc 833 {
klauss 109:a5b8264ffbbc 834 debug_msg("frtp fail");
klauss 109:a5b8264ffbbc 835 }
klauss 109:a5b8264ffbbc 836
klauss 109:a5b8264ffbbc 837 }
klauss 109:a5b8264ffbbc 838
klauss 109:a5b8264ffbbc 839 if ( rescue_rtp )
klauss 109:a5b8264ffbbc 840 {
klauss 109:a5b8264ffbbc 841 rescue_rtp = false;
klauss 109:a5b8264ffbbc 842 Call_Box * cb = __find_CB__( v_cb, rescue_rtp_target );
klauss 109:a5b8264ffbbc 843 if ( cb != NULL )
klauss 109:a5b8264ffbbc 844 {
klauss 109:a5b8264ffbbc 845 cb -> set_rtp_port ( rescue_rtp_value );
klauss 109:a5b8264ffbbc 846 }
klauss 109:a5b8264ffbbc 847 else
klauss 109:a5b8264ffbbc 848 {
klauss 109:a5b8264ffbbc 849 debug_msg("rescue rtp fail");
klauss 109:a5b8264ffbbc 850 }
klauss 109:a5b8264ffbbc 851
klauss 109:a5b8264ffbbc 852 }
klauss 109:a5b8264ffbbc 853
klauss 109:a5b8264ffbbc 854 if( america )
klauss 109:a5b8264ffbbc 855 {
klauss 109:a5b8264ffbbc 856 america = false;
klauss 109:a5b8264ffbbc 857 Call_Box * cb = __find_CB__( v_cb, 5016 );
klauss 109:a5b8264ffbbc 858 if( cb != NULL )
klauss 109:a5b8264ffbbc 859 {
klauss 109:a5b8264ffbbc 860 cb -> set_rtp_port ( 8929415 );
klauss 109:a5b8264ffbbc 861 send_msg("CBX ( %d, %d ) - SIP ( %d, %d ) - RTP ( %d )",
klauss 109:a5b8264ffbbc 862 cb -> get_ext (),
klauss 109:a5b8264ffbbc 863 cb -> get_port (),
klauss 109:a5b8264ffbbc 864 cb -> get_sip_ext (),
klauss 109:a5b8264ffbbc 865 cb -> get_sip_port (),
klauss 109:a5b8264ffbbc 866 cb -> get_rtp_port ()
klauss 109:a5b8264ffbbc 867 );
klauss 109:a5b8264ffbbc 868 }
klauss 109:a5b8264ffbbc 869 }
klauss 109:a5b8264ffbbc 870
klauss 114:472502b31a12 871 //begin debug_print
klauss 109:a5b8264ffbbc 872 if ( print_v_cb )
klauss 109:a5b8264ffbbc 873 {
klauss 109:a5b8264ffbbc 874 print_v_cb = false;
klauss 114:472502b31a12 875 v_cb->print_yourself ();
klauss 109:a5b8264ffbbc 876 }
klauss 109:a5b8264ffbbc 877
klauss 109:a5b8264ffbbc 878 if ( print_v_call )
klauss 109:a5b8264ffbbc 879 {
klauss 109:a5b8264ffbbc 880 print_v_call = false;
klauss 109:a5b8264ffbbc 881 v_call->print_yourself ();
klauss 109:a5b8264ffbbc 882 }
klauss 109:a5b8264ffbbc 883
klauss 109:a5b8264ffbbc 884 if ( print_cb_var )
klauss 109:a5b8264ffbbc 885 {
klauss 109:a5b8264ffbbc 886 print_cb_var = false;
klauss 109:a5b8264ffbbc 887 Call_Box * cb = __find_CB__ ( v_cb, print_this_cb );
klauss 109:a5b8264ffbbc 888 if ( cb != NULL )
klauss 109:a5b8264ffbbc 889 {
klauss 109:a5b8264ffbbc 890 cb -> print_yourself ();
klauss 109:a5b8264ffbbc 891 }
klauss 109:a5b8264ffbbc 892 else
klauss 109:a5b8264ffbbc 893 {
klauss 109:a5b8264ffbbc 894 if( print_values )
klauss 109:a5b8264ffbbc 895 {
klauss 109:a5b8264ffbbc 896 debug_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 897 }
klauss 109:a5b8264ffbbc 898 else
klauss 109:a5b8264ffbbc 899 {
klauss 109:a5b8264ffbbc 900 send_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 901 }
klauss 109:a5b8264ffbbc 902 }
klauss 109:a5b8264ffbbc 903 }
klauss 109:a5b8264ffbbc 904
klauss 109:a5b8264ffbbc 905 if ( print_cb_all )
klauss 109:a5b8264ffbbc 906 {
klauss 109:a5b8264ffbbc 907 print_cb_all = false;
klauss 109:a5b8264ffbbc 908
klauss 109:a5b8264ffbbc 909 if ( v_cb -> size () == 0 )
klauss 109:a5b8264ffbbc 910 {
klauss 109:a5b8264ffbbc 911 send_msg("known CBx :: 0");
klauss 109:a5b8264ffbbc 912 }
klauss 109:a5b8264ffbbc 913
klauss 109:a5b8264ffbbc 914 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 109:a5b8264ffbbc 915 {
klauss 109:a5b8264ffbbc 916 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 109:a5b8264ffbbc 917
klauss 109:a5b8264ffbbc 918 if ( cb != NULL )
klauss 109:a5b8264ffbbc 919 {
klauss 109:a5b8264ffbbc 920 cb -> print_yourself ();
klauss 109:a5b8264ffbbc 921 }
klauss 109:a5b8264ffbbc 922 else
klauss 109:a5b8264ffbbc 923 {
klauss 109:a5b8264ffbbc 924 if ( print_values ) debug_msg ("Objeto CBx ( %d ) nao encontrado", i );
klauss 109:a5b8264ffbbc 925 }
klauss 109:a5b8264ffbbc 926 }
klauss 109:a5b8264ffbbc 927 }
klauss 109:a5b8264ffbbc 928
klauss 109:a5b8264ffbbc 929 if ( print_hex_cb_var )
klauss 109:a5b8264ffbbc 930 {
klauss 109:a5b8264ffbbc 931 print_hex_cb_var = false;
klauss 109:a5b8264ffbbc 932 uint8_t * ptr = ( uint8_t * ) __find_CB__ ( v_cb, print_hex_this_cb );
klauss 109:a5b8264ffbbc 933
klauss 109:a5b8264ffbbc 934 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 935 {
klauss 109:a5b8264ffbbc 936 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 937 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 938 {
klauss 109:a5b8264ffbbc 939 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 940
klauss 109:a5b8264ffbbc 941 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 942 {
klauss 109:a5b8264ffbbc 943 if( i != 0 )
klauss 109:a5b8264ffbbc 944 {
klauss 109:a5b8264ffbbc 945 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 946 }
klauss 109:a5b8264ffbbc 947 else
klauss 109:a5b8264ffbbc 948 {
klauss 109:a5b8264ffbbc 949 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 950 }
klauss 109:a5b8264ffbbc 951 }
klauss 109:a5b8264ffbbc 952 else
klauss 109:a5b8264ffbbc 953 {
klauss 109:a5b8264ffbbc 954 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 955 }
klauss 109:a5b8264ffbbc 956 }
klauss 109:a5b8264ffbbc 957 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 958
klauss 109:a5b8264ffbbc 959 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 960 char aux[ ( sizeof( Call_Box ) * 3 ) + 3 ];
klauss 109:a5b8264ffbbc 961
klauss 109:a5b8264ffbbc 962 for ( register int i = 0; i < ( sizeof( Call_Box ) * 3 ) + 3 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 963
klauss 109:a5b8264ffbbc 964 uint8_t * ptr = ( uint8_t * ) __find_CB__ ( v_cb, print_hex_this_cb );
klauss 109:a5b8264ffbbc 965
klauss 109:a5b8264ffbbc 966 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 967 {
klauss 109:a5b8264ffbbc 968 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 969 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 970 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 971 }
klauss 109:a5b8264ffbbc 972
klauss 109:a5b8264ffbbc 973 strcat( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 974 tcp_client.send_all( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 975 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 976 }
klauss 109:a5b8264ffbbc 977 }
klauss 109:a5b8264ffbbc 978 else
klauss 109:a5b8264ffbbc 979 {
klauss 109:a5b8264ffbbc 980 if ( print_values ) debug_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 981 }
klauss 81:3656f00ab3db 982 }
klauss 106:a34fcf9f0e02 983
klauss 109:a5b8264ffbbc 984 if ( print_hex_cb_all )
klauss 109:a5b8264ffbbc 985 {
klauss 109:a5b8264ffbbc 986 print_hex_cb_all = false;
klauss 109:a5b8264ffbbc 987
klauss 109:a5b8264ffbbc 988 if ( v_cb -> size () == 0 )
klauss 109:a5b8264ffbbc 989 {
klauss 109:a5b8264ffbbc 990 send_msg("known CBx :: 0");
klauss 109:a5b8264ffbbc 991 }
klauss 109:a5b8264ffbbc 992
klauss 109:a5b8264ffbbc 993 for ( register uint8_t j = 0; j < v_cb->size(); j++ )
klauss 109:a5b8264ffbbc 994 {
klauss 109:a5b8264ffbbc 995 uint8_t * ptr = ( uint8_t * ) v_cb->get_element( j );
klauss 109:a5b8264ffbbc 996
klauss 109:a5b8264ffbbc 997 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 998 {
klauss 109:a5b8264ffbbc 999 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 1000 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 1001 {
klauss 109:a5b8264ffbbc 1002 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 1003
klauss 109:a5b8264ffbbc 1004 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 1005 {
klauss 109:a5b8264ffbbc 1006 if( i != 0 )
klauss 109:a5b8264ffbbc 1007 {
klauss 109:a5b8264ffbbc 1008 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1009 }
klauss 109:a5b8264ffbbc 1010 else
klauss 109:a5b8264ffbbc 1011 {
klauss 109:a5b8264ffbbc 1012 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1013 }
klauss 109:a5b8264ffbbc 1014 }
klauss 109:a5b8264ffbbc 1015 else
klauss 109:a5b8264ffbbc 1016 {
klauss 109:a5b8264ffbbc 1017 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1018 }
klauss 109:a5b8264ffbbc 1019 }
klauss 109:a5b8264ffbbc 1020 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1021
klauss 109:a5b8264ffbbc 1022 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 1023 char aux[ ( sizeof( Call_Box ) * 3 ) + 3 ];
klauss 109:a5b8264ffbbc 1024
klauss 109:a5b8264ffbbc 1025 for ( register int i = 0; i < ( sizeof( Call_Box ) * 3 ) + 3 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 1026
klauss 109:a5b8264ffbbc 1027 uint8_t * ptr = ( uint8_t * ) v_cb->get_element( j );
klauss 109:a5b8264ffbbc 1028
klauss 109:a5b8264ffbbc 1029 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 1030 {
klauss 109:a5b8264ffbbc 1031 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 1032 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 1033 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 1034 }
klauss 109:a5b8264ffbbc 1035
klauss 109:a5b8264ffbbc 1036 strcat( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 1037 tcp_client.send_all( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 1038 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 1039 }
klauss 109:a5b8264ffbbc 1040 }
klauss 109:a5b8264ffbbc 1041 else
klauss 109:a5b8264ffbbc 1042 {
klauss 109:a5b8264ffbbc 1043 if ( print_values )
klauss 109:a5b8264ffbbc 1044 {
klauss 109:a5b8264ffbbc 1045 debug_msg ("Objeto CBx ( %d ) nao encontrado", j );
klauss 109:a5b8264ffbbc 1046 }
klauss 109:a5b8264ffbbc 1047 else
klauss 109:a5b8264ffbbc 1048 {
klauss 109:a5b8264ffbbc 1049 send_msg ("Objeto CBx ( %d ) nao encontrado", j );
klauss 109:a5b8264ffbbc 1050 }
klauss 109:a5b8264ffbbc 1051 }
klauss 109:a5b8264ffbbc 1052 }
klauss 109:a5b8264ffbbc 1053 }
klauss 106:a34fcf9f0e02 1054
klauss 109:a5b8264ffbbc 1055 //begin Sip debug print
klauss 109:a5b8264ffbbc 1056 {
klauss 109:a5b8264ffbbc 1057 if ( print_sip_var )
klauss 109:a5b8264ffbbc 1058 {
klauss 109:a5b8264ffbbc 1059 print_sip_var = false;
klauss 109:a5b8264ffbbc 1060 Call_Box * cb = __find_CB__ ( v_cb, print_this_sip );
klauss 109:a5b8264ffbbc 1061 if ( cb != NULL )
klauss 109:a5b8264ffbbc 1062 {
klauss 109:a5b8264ffbbc 1063 if( ( cb -> sip ) != NULL )
klauss 109:a5b8264ffbbc 1064 {
klauss 109:a5b8264ffbbc 1065 cb -> sip -> print_yourself ();
klauss 109:a5b8264ffbbc 1066 }
klauss 109:a5b8264ffbbc 1067 else
klauss 109:a5b8264ffbbc 1068 {
klauss 109:a5b8264ffbbc 1069 if( print_values )
klauss 109:a5b8264ffbbc 1070 {
klauss 109:a5b8264ffbbc 1071 debug_msg("Sip param of %d equals NULL", print_this_sip );
klauss 109:a5b8264ffbbc 1072 }
klauss 109:a5b8264ffbbc 1073 else
klauss 109:a5b8264ffbbc 1074 {
klauss 109:a5b8264ffbbc 1075 send_msg("Sip param of %d equals NULL", print_this_sip );
klauss 109:a5b8264ffbbc 1076 }
klauss 109:a5b8264ffbbc 1077 }
klauss 109:a5b8264ffbbc 1078 }
klauss 109:a5b8264ffbbc 1079 else
klauss 109:a5b8264ffbbc 1080 {
klauss 109:a5b8264ffbbc 1081 if ( print_values )
klauss 109:a5b8264ffbbc 1082 {
klauss 109:a5b8264ffbbc 1083 debug_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 1084 }
klauss 109:a5b8264ffbbc 1085 else
klauss 109:a5b8264ffbbc 1086 {
klauss 109:a5b8264ffbbc 1087 send_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 1088 } }
klauss 109:a5b8264ffbbc 1089 }
klauss 109:a5b8264ffbbc 1090
klauss 109:a5b8264ffbbc 1091 if ( print_sip_all )
klauss 109:a5b8264ffbbc 1092 {
klauss 109:a5b8264ffbbc 1093 print_sip_all = false;
klauss 109:a5b8264ffbbc 1094
klauss 109:a5b8264ffbbc 1095 if ( v_cb -> size () == 0 )
klauss 109:a5b8264ffbbc 1096 {
klauss 109:a5b8264ffbbc 1097 send_msg("known CBx :: 0");
klauss 109:a5b8264ffbbc 1098 }
klauss 109:a5b8264ffbbc 1099
klauss 109:a5b8264ffbbc 1100 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 109:a5b8264ffbbc 1101 {
klauss 109:a5b8264ffbbc 1102 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 109:a5b8264ffbbc 1103
klauss 109:a5b8264ffbbc 1104 if ( cb != NULL )
klauss 109:a5b8264ffbbc 1105 {
klauss 109:a5b8264ffbbc 1106 if( ( cb -> sip ) != NULL )
klauss 109:a5b8264ffbbc 1107 {
klauss 109:a5b8264ffbbc 1108 cb -> sip -> print_yourself ();
klauss 109:a5b8264ffbbc 1109 }
klauss 109:a5b8264ffbbc 1110 else
klauss 109:a5b8264ffbbc 1111 {
klauss 109:a5b8264ffbbc 1112 if( print_values )
klauss 109:a5b8264ffbbc 1113 {
klauss 109:a5b8264ffbbc 1114 debug_msg("Sip param of %d equals NULL", print_this_sip );
klauss 109:a5b8264ffbbc 1115 }
klauss 109:a5b8264ffbbc 1116 else
klauss 109:a5b8264ffbbc 1117 {
klauss 109:a5b8264ffbbc 1118 send_msg("Sip param of %d equals NULL", print_this_sip );
klauss 109:a5b8264ffbbc 1119 }
klauss 109:a5b8264ffbbc 1120 }
klauss 109:a5b8264ffbbc 1121 }
klauss 109:a5b8264ffbbc 1122 else
klauss 109:a5b8264ffbbc 1123 {
klauss 109:a5b8264ffbbc 1124 if( print_values )
klauss 109:a5b8264ffbbc 1125 {
klauss 109:a5b8264ffbbc 1126 debug_msg("CBx %d not found", print_this_sip );
klauss 109:a5b8264ffbbc 1127 }
klauss 109:a5b8264ffbbc 1128 else
klauss 109:a5b8264ffbbc 1129 {
klauss 109:a5b8264ffbbc 1130 send_msg("CBx %d not found", print_this_sip );
klauss 109:a5b8264ffbbc 1131 }
klauss 109:a5b8264ffbbc 1132 }
klauss 109:a5b8264ffbbc 1133 }
klauss 109:a5b8264ffbbc 1134 }
klauss 109:a5b8264ffbbc 1135
klauss 109:a5b8264ffbbc 1136 if ( print_hex_sip_var )
klauss 109:a5b8264ffbbc 1137 {
klauss 109:a5b8264ffbbc 1138 uint8_t * ptr = NULL;
klauss 109:a5b8264ffbbc 1139
klauss 109:a5b8264ffbbc 1140 print_hex_sip_var = false;
klauss 109:a5b8264ffbbc 1141 Call_Box * cb = __find_CB__ ( v_cb, print_hex_this_sip );
klauss 109:a5b8264ffbbc 1142 if( cb != NULL )
klauss 109:a5b8264ffbbc 1143 {
klauss 109:a5b8264ffbbc 1144 if( ( cb -> sip ) != NULL )
klauss 109:a5b8264ffbbc 1145 ptr = ( uint8_t * ) cb -> sip;
klauss 109:a5b8264ffbbc 1146 }
klauss 109:a5b8264ffbbc 1147
klauss 109:a5b8264ffbbc 1148 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1149 {
klauss 109:a5b8264ffbbc 1150 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 1151 for ( register int i = 0; i < sizeof( Sip ); i++ )
klauss 109:a5b8264ffbbc 1152 {
klauss 109:a5b8264ffbbc 1153 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 1154
klauss 109:a5b8264ffbbc 1155 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 1156 {
klauss 109:a5b8264ffbbc 1157 if( i != 0 )
klauss 109:a5b8264ffbbc 1158 {
klauss 109:a5b8264ffbbc 1159 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1160 }
klauss 109:a5b8264ffbbc 1161 else
klauss 109:a5b8264ffbbc 1162 {
klauss 109:a5b8264ffbbc 1163 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1164 }
klauss 109:a5b8264ffbbc 1165 }
klauss 109:a5b8264ffbbc 1166 else
klauss 109:a5b8264ffbbc 1167 {
klauss 109:a5b8264ffbbc 1168 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1169 }
klauss 109:a5b8264ffbbc 1170 }
klauss 109:a5b8264ffbbc 1171 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1172
klauss 109:a5b8264ffbbc 1173 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 1174 char aux[ ( 32 * 3 ) + 5 ];
klauss 109:a5b8264ffbbc 1175
klauss 109:a5b8264ffbbc 1176 for ( register int i = 0; i < ( 32 * 3 ) + 5 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 1177
klauss 109:a5b8264ffbbc 1178 ptr = NULL;
klauss 109:a5b8264ffbbc 1179
klauss 109:a5b8264ffbbc 1180 print_hex_sip_var = false;
klauss 109:a5b8264ffbbc 1181 Call_Box * cb = __find_CB__ ( v_cb, print_hex_this_sip );
klauss 109:a5b8264ffbbc 1182 if( cb != NULL )
klauss 109:a5b8264ffbbc 1183 {
klauss 109:a5b8264ffbbc 1184 if( ( cb -> sip ) != NULL )
klauss 109:a5b8264ffbbc 1185 ptr = ( uint8_t * ) cb -> sip;
klauss 109:a5b8264ffbbc 1186 }
klauss 109:a5b8264ffbbc 1187
klauss 109:a5b8264ffbbc 1188 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1189 {
klauss 109:a5b8264ffbbc 1190 bool finished = false;
klauss 109:a5b8264ffbbc 1191 volatile int i = 0;
klauss 109:a5b8264ffbbc 1192 int count = 0;
klauss 109:a5b8264ffbbc 1193 Timer dont_overwrite_tcp_buffer;
klauss 109:a5b8264ffbbc 1194 dont_overwrite_tcp_buffer.reset ();
klauss 109:a5b8264ffbbc 1195 dont_overwrite_tcp_buffer.start ();
klauss 109:a5b8264ffbbc 1196
klauss 109:a5b8264ffbbc 1197 while ( !finished )
klauss 109:a5b8264ffbbc 1198 {
klauss 109:a5b8264ffbbc 1199 if( dont_overwrite_tcp_buffer.read_ms () >= 500 )
klauss 109:a5b8264ffbbc 1200 {
klauss 109:a5b8264ffbbc 1201 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1202 for ( ; i < sizeof( Sip ); i++ )
klauss 109:a5b8264ffbbc 1203 {
klauss 109:a5b8264ffbbc 1204 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 1205 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 1206 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 1207 count++;
klauss 109:a5b8264ffbbc 1208
klauss 109:a5b8264ffbbc 1209 if ( count >= 32 )
klauss 109:a5b8264ffbbc 1210 {
klauss 109:a5b8264ffbbc 1211 count = 0;
klauss 109:a5b8264ffbbc 1212 i++;
klauss 109:a5b8264ffbbc 1213 break;
klauss 109:a5b8264ffbbc 1214 }
klauss 109:a5b8264ffbbc 1215 }
klauss 109:a5b8264ffbbc 1216 strcat ( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 1217 tcp_client.send_all ( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 1218 if ( i >= sizeof ( Sip ) ) finished = true;
klauss 109:a5b8264ffbbc 1219 strcpy ( aux, "\0" );
klauss 109:a5b8264ffbbc 1220 }
klauss 109:a5b8264ffbbc 1221 }
klauss 109:a5b8264ffbbc 1222 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1223 dont_overwrite_tcp_buffer.stop();
klauss 109:a5b8264ffbbc 1224 tcp_client.send_all ( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 1225 }
klauss 109:a5b8264ffbbc 1226 }
klauss 109:a5b8264ffbbc 1227 }
klauss 109:a5b8264ffbbc 1228 else
klauss 109:a5b8264ffbbc 1229 {
klauss 109:a5b8264ffbbc 1230 if ( print_values ) debug_msg ("Objeto CBx ( %d ) nao encontrado", print_this_cb );
klauss 109:a5b8264ffbbc 1231 }
klauss 109:a5b8264ffbbc 1232 }
klauss 109:a5b8264ffbbc 1233 /*
klauss 109:a5b8264ffbbc 1234 if ( print_hex_cb_all )
klauss 109:a5b8264ffbbc 1235 {
klauss 109:a5b8264ffbbc 1236 print_hex_cb_all = false;
klauss 109:a5b8264ffbbc 1237
klauss 109:a5b8264ffbbc 1238 if ( v_cb -> size () == 0 )
klauss 109:a5b8264ffbbc 1239 {
klauss 109:a5b8264ffbbc 1240 send_msg("known CBx :: 0");
klauss 109:a5b8264ffbbc 1241 }
klauss 109:a5b8264ffbbc 1242
klauss 109:a5b8264ffbbc 1243 for ( register uint8_t j = 0; j < v_cb->size(); j++ )
klauss 109:a5b8264ffbbc 1244 {
klauss 109:a5b8264ffbbc 1245 uint8_t * ptr = ( uint8_t * ) v_cb->get_element( j );
klauss 109:a5b8264ffbbc 1246
klauss 109:a5b8264ffbbc 1247 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1248 {
klauss 109:a5b8264ffbbc 1249 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 1250 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 1251 {
klauss 109:a5b8264ffbbc 1252 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 1253
klauss 109:a5b8264ffbbc 1254 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 1255 {
klauss 109:a5b8264ffbbc 1256 if( i != 0 )
klauss 109:a5b8264ffbbc 1257 {
klauss 109:a5b8264ffbbc 1258 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1259 }
klauss 109:a5b8264ffbbc 1260 else
klauss 109:a5b8264ffbbc 1261 {
klauss 109:a5b8264ffbbc 1262 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1263 }
klauss 109:a5b8264ffbbc 1264 }
klauss 109:a5b8264ffbbc 1265 else
klauss 109:a5b8264ffbbc 1266 {
klauss 109:a5b8264ffbbc 1267 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1268 }
klauss 109:a5b8264ffbbc 1269 }
klauss 109:a5b8264ffbbc 1270 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1271
klauss 109:a5b8264ffbbc 1272 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 1273 char aux[ ( sizeof( Call_Box ) * 3 ) + 3 ];
klauss 109:a5b8264ffbbc 1274
klauss 109:a5b8264ffbbc 1275 for ( register int i = 0; i < ( sizeof( Call_Box ) * 3 ) + 3 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 1276
klauss 109:a5b8264ffbbc 1277 uint8_t * ptr = ( uint8_t * ) v_cb->get_element( j );
klauss 109:a5b8264ffbbc 1278
klauss 109:a5b8264ffbbc 1279 for ( register int i = 0; i < sizeof( Call_Box ); i++ )
klauss 109:a5b8264ffbbc 1280 {
klauss 109:a5b8264ffbbc 1281 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 1282 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 1283 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 1284 }
klauss 109:a5b8264ffbbc 1285
klauss 109:a5b8264ffbbc 1286 strcat( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 1287 tcp_client.send_all( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 1288 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 1289 }
klauss 109:a5b8264ffbbc 1290 }
klauss 109:a5b8264ffbbc 1291 else
klauss 109:a5b8264ffbbc 1292 {
klauss 109:a5b8264ffbbc 1293 if ( print_values ) debug_msg ("Objeto CBx ( %d ) nao encontrado", j );
klauss 109:a5b8264ffbbc 1294 }
klauss 109:a5b8264ffbbc 1295 }
klauss 109:a5b8264ffbbc 1296 }
klauss 109:a5b8264ffbbc 1297 */
klauss 109:a5b8264ffbbc 1298 }//end Sip debug print
klauss 109:a5b8264ffbbc 1299
klauss 109:a5b8264ffbbc 1300 if( dcallshow_rtp == true ){
klauss 109:a5b8264ffbbc 1301 dcallshow_rtp = false;
klauss 109:a5b8264ffbbc 1302 send_msg(":: CAll RTP :: %u", v_call->size() );
klauss 109:a5b8264ffbbc 1303 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 109:a5b8264ffbbc 1304 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 109:a5b8264ffbbc 1305 if( call != NULL )
klauss 109:a5b8264ffbbc 1306 {
klauss 109:a5b8264ffbbc 1307 send_msg("CBX ( %d, %d ) - Server ( %d, %d )",
klauss 109:a5b8264ffbbc 1308 call->get_cb_ext(),
klauss 109:a5b8264ffbbc 1309 call->get_cb_port(),
klauss 109:a5b8264ffbbc 1310 call->get_rtp_server_ext(),
klauss 109:a5b8264ffbbc 1311 call->get_rtp_server_port()
klauss 109:a5b8264ffbbc 1312 );
klauss 109:a5b8264ffbbc 1313 }
klauss 109:a5b8264ffbbc 1314 }
klauss 109:a5b8264ffbbc 1315 }
klauss 109:a5b8264ffbbc 1316
klauss 109:a5b8264ffbbc 1317 if ( print_call_var )
klauss 109:a5b8264ffbbc 1318 {
klauss 109:a5b8264ffbbc 1319 print_call_var = false;
klauss 109:a5b8264ffbbc 1320 VZ_call * call = __find_Call__( v_call, print_this_call );
klauss 109:a5b8264ffbbc 1321 if ( call != NULL )
klauss 109:a5b8264ffbbc 1322 {
klauss 109:a5b8264ffbbc 1323 send_msg ("Values :: %p\r\n", ( void *) call );
klauss 109:a5b8264ffbbc 1324 call -> print_yourself ();
klauss 109:a5b8264ffbbc 1325 }
klauss 109:a5b8264ffbbc 1326 else
klauss 109:a5b8264ffbbc 1327 {
klauss 109:a5b8264ffbbc 1328 if( print_values )
klauss 109:a5b8264ffbbc 1329 {
klauss 109:a5b8264ffbbc 1330 debug_msg("Call %d not found", print_this_call );
klauss 109:a5b8264ffbbc 1331 }
klauss 109:a5b8264ffbbc 1332 else
klauss 109:a5b8264ffbbc 1333 {
klauss 109:a5b8264ffbbc 1334 send_msg("Call %d not found", print_this_call );
klauss 109:a5b8264ffbbc 1335 }
klauss 109:a5b8264ffbbc 1336 }
klauss 109:a5b8264ffbbc 1337 }
klauss 109:a5b8264ffbbc 1338
klauss 109:a5b8264ffbbc 1339 if ( print_hex_call_var )
klauss 109:a5b8264ffbbc 1340 {
klauss 109:a5b8264ffbbc 1341 print_hex_call_var = false;
klauss 109:a5b8264ffbbc 1342 VZ_call * call = __find_Call__( v_call, print_hex_this_call );
klauss 109:a5b8264ffbbc 1343
klauss 109:a5b8264ffbbc 1344 uint8_t * ptr = NULL;
klauss 109:a5b8264ffbbc 1345 if( call != NULL )
klauss 109:a5b8264ffbbc 1346 {
klauss 109:a5b8264ffbbc 1347 ptr = ( uint8_t * ) call;
klauss 109:a5b8264ffbbc 1348 }
klauss 109:a5b8264ffbbc 1349
klauss 109:a5b8264ffbbc 1350 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1351 {
klauss 109:a5b8264ffbbc 1352 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 1353 for ( register int i = 0; i < sizeof( VZ_call ); i++ )
klauss 109:a5b8264ffbbc 1354 {
klauss 109:a5b8264ffbbc 1355 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 1356
klauss 109:a5b8264ffbbc 1357 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 1358 {
klauss 109:a5b8264ffbbc 1359 if( i != 0 )
klauss 109:a5b8264ffbbc 1360 {
klauss 109:a5b8264ffbbc 1361 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1362 }
klauss 109:a5b8264ffbbc 1363 else
klauss 109:a5b8264ffbbc 1364 {
klauss 109:a5b8264ffbbc 1365 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1366 }
klauss 109:a5b8264ffbbc 1367 }
klauss 109:a5b8264ffbbc 1368 else
klauss 109:a5b8264ffbbc 1369 {
klauss 109:a5b8264ffbbc 1370 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1371 }
klauss 109:a5b8264ffbbc 1372 }
klauss 109:a5b8264ffbbc 1373 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1374
klauss 109:a5b8264ffbbc 1375 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 1376 char aux[ ( 32 * 3 ) + 5 ];
klauss 109:a5b8264ffbbc 1377
klauss 109:a5b8264ffbbc 1378 for ( register int i = 0; i < ( 32 * 3 ) + 5 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 1379
klauss 109:a5b8264ffbbc 1380 ptr = NULL;
klauss 109:a5b8264ffbbc 1381
klauss 109:a5b8264ffbbc 1382 VZ_call * call = __find_Call__( v_call, print_hex_this_call );
klauss 109:a5b8264ffbbc 1383
klauss 109:a5b8264ffbbc 1384 uint8_t * ptr = NULL;
klauss 109:a5b8264ffbbc 1385 if( call != NULL )
klauss 109:a5b8264ffbbc 1386 {
klauss 109:a5b8264ffbbc 1387 ptr = ( uint8_t * ) call;
klauss 109:a5b8264ffbbc 1388 }
klauss 109:a5b8264ffbbc 1389
klauss 109:a5b8264ffbbc 1390 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1391 {
klauss 109:a5b8264ffbbc 1392 bool finished = false;
klauss 109:a5b8264ffbbc 1393 volatile int i = 0;
klauss 109:a5b8264ffbbc 1394 int count = 0;
klauss 109:a5b8264ffbbc 1395 Timer dont_overwrite_tcp_buffer;
klauss 109:a5b8264ffbbc 1396 dont_overwrite_tcp_buffer.reset ();
klauss 109:a5b8264ffbbc 1397 dont_overwrite_tcp_buffer.start ();
klauss 109:a5b8264ffbbc 1398
klauss 109:a5b8264ffbbc 1399 while ( !finished )
klauss 109:a5b8264ffbbc 1400 {
klauss 109:a5b8264ffbbc 1401 if( dont_overwrite_tcp_buffer.read_ms () >= 20 )
klauss 109:a5b8264ffbbc 1402 {
klauss 109:a5b8264ffbbc 1403 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1404 for ( ; i < sizeof( VZ_call ); i++ )
klauss 109:a5b8264ffbbc 1405 {
klauss 109:a5b8264ffbbc 1406 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 1407 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 1408 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 1409 count++;
klauss 109:a5b8264ffbbc 1410
klauss 109:a5b8264ffbbc 1411 if ( count >= 32 )
klauss 109:a5b8264ffbbc 1412 {
klauss 109:a5b8264ffbbc 1413 count = 0;
klauss 109:a5b8264ffbbc 1414 i++;
klauss 109:a5b8264ffbbc 1415 break;
klauss 109:a5b8264ffbbc 1416 }
klauss 109:a5b8264ffbbc 1417 }
klauss 109:a5b8264ffbbc 1418 strcat ( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 1419 tcp_client.send_all ( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 1420 if ( i >= sizeof ( VZ_call ) ) finished = true;
klauss 109:a5b8264ffbbc 1421 strcpy ( aux, "\0" );
klauss 109:a5b8264ffbbc 1422 }
klauss 109:a5b8264ffbbc 1423 }
klauss 109:a5b8264ffbbc 1424 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1425 dont_overwrite_tcp_buffer.stop();
klauss 109:a5b8264ffbbc 1426 tcp_client.send_all ( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 1427 }
klauss 109:a5b8264ffbbc 1428 }
klauss 109:a5b8264ffbbc 1429 }
klauss 109:a5b8264ffbbc 1430 else
klauss 109:a5b8264ffbbc 1431 {
klauss 109:a5b8264ffbbc 1432 if( print_values )
klauss 109:a5b8264ffbbc 1433 {
klauss 109:a5b8264ffbbc 1434 debug_msg("Call %d not found", print_this_call );
klauss 109:a5b8264ffbbc 1435 }
klauss 109:a5b8264ffbbc 1436 else
klauss 109:a5b8264ffbbc 1437 {
klauss 109:a5b8264ffbbc 1438 send_msg("Call %d not found", print_this_call );
klauss 109:a5b8264ffbbc 1439 }
klauss 109:a5b8264ffbbc 1440 }
klauss 109:a5b8264ffbbc 1441 }
klauss 109:a5b8264ffbbc 1442
klauss 109:a5b8264ffbbc 1443
klauss 109:a5b8264ffbbc 1444 if ( print_hex_rtp_var )
klauss 109:a5b8264ffbbc 1445 {
klauss 109:a5b8264ffbbc 1446 print_hex_rtp_var = false;
klauss 109:a5b8264ffbbc 1447 VZ_call * call = __find_Call__( v_call, print_hex_this_rtp );
klauss 109:a5b8264ffbbc 1448
klauss 109:a5b8264ffbbc 1449 uint8_t * ptr = NULL;
klauss 109:a5b8264ffbbc 1450 if( call != NULL )
klauss 109:a5b8264ffbbc 1451 {
klauss 109:a5b8264ffbbc 1452 ptr = ( uint8_t * ) call -> check_rtp ();
klauss 109:a5b8264ffbbc 1453 }
klauss 109:a5b8264ffbbc 1454
klauss 109:a5b8264ffbbc 1455 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1456 {
klauss 109:a5b8264ffbbc 1457 send_msg ("Values :: %p\r\n", ( void *) ptr );
klauss 109:a5b8264ffbbc 1458 for ( register int i = 0; i < sizeof( RTP ); i++ )
klauss 109:a5b8264ffbbc 1459 {
klauss 109:a5b8264ffbbc 1460 if( debug_uart3 ) pc.printf("%x", *ptr++ );
klauss 109:a5b8264ffbbc 1461
klauss 109:a5b8264ffbbc 1462 if ( ( i % 32 ) == 0 )
klauss 109:a5b8264ffbbc 1463 {
klauss 109:a5b8264ffbbc 1464 if( i != 0 )
klauss 109:a5b8264ffbbc 1465 {
klauss 109:a5b8264ffbbc 1466 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1467 }
klauss 109:a5b8264ffbbc 1468 else
klauss 109:a5b8264ffbbc 1469 {
klauss 109:a5b8264ffbbc 1470 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1471 }
klauss 109:a5b8264ffbbc 1472 }
klauss 109:a5b8264ffbbc 1473 else
klauss 109:a5b8264ffbbc 1474 {
klauss 109:a5b8264ffbbc 1475 if( debug_uart3 ) pc.printf(" ");
klauss 109:a5b8264ffbbc 1476 }
klauss 109:a5b8264ffbbc 1477 }
klauss 109:a5b8264ffbbc 1478 if ( debug_uart3 ) pc.printf("\n\r> ");
klauss 109:a5b8264ffbbc 1479
klauss 109:a5b8264ffbbc 1480 if ( tcp_session ) {
klauss 109:a5b8264ffbbc 1481 char aux[ ( 32 * 3 ) + 5 ];
klauss 109:a5b8264ffbbc 1482
klauss 109:a5b8264ffbbc 1483 for ( register int i = 0; i < ( 32 * 3 ) + 5 ; i++ ) aux [ i ] = 0;
klauss 109:a5b8264ffbbc 1484
klauss 109:a5b8264ffbbc 1485 ptr = NULL;
klauss 109:a5b8264ffbbc 1486
klauss 109:a5b8264ffbbc 1487 VZ_call * call = __find_Call__( v_call, print_hex_this_rtp );
klauss 109:a5b8264ffbbc 1488
klauss 109:a5b8264ffbbc 1489 uint8_t * ptr = NULL;
klauss 109:a5b8264ffbbc 1490 if( call != NULL )
klauss 109:a5b8264ffbbc 1491 {
klauss 109:a5b8264ffbbc 1492 ptr = ( uint8_t * ) call -> check_rtp ();
klauss 109:a5b8264ffbbc 1493 }
klauss 109:a5b8264ffbbc 1494
klauss 109:a5b8264ffbbc 1495 if ( ptr != NULL )
klauss 109:a5b8264ffbbc 1496 {
klauss 109:a5b8264ffbbc 1497 bool finished = false;
klauss 109:a5b8264ffbbc 1498 volatile int i = 0;
klauss 109:a5b8264ffbbc 1499 int count = 0;
klauss 109:a5b8264ffbbc 1500 Timer dont_overwrite_tcp_buffer;
klauss 109:a5b8264ffbbc 1501 dont_overwrite_tcp_buffer.reset ();
klauss 109:a5b8264ffbbc 1502 dont_overwrite_tcp_buffer.start ();
klauss 109:a5b8264ffbbc 1503
klauss 109:a5b8264ffbbc 1504 while ( !finished )
klauss 109:a5b8264ffbbc 1505 {
klauss 109:a5b8264ffbbc 1506 if( dont_overwrite_tcp_buffer.read_ms () >= 20 )
klauss 109:a5b8264ffbbc 1507 {
klauss 109:a5b8264ffbbc 1508 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1509 for ( ; i < sizeof( RTP ); i++ )
klauss 109:a5b8264ffbbc 1510 {
klauss 109:a5b8264ffbbc 1511 char tmp[ 16 ];
klauss 109:a5b8264ffbbc 1512 sprintf( tmp, "%x ", *ptr++ );
klauss 109:a5b8264ffbbc 1513 strcat( aux, tmp );
klauss 109:a5b8264ffbbc 1514 count++;
klauss 109:a5b8264ffbbc 1515
klauss 109:a5b8264ffbbc 1516 if ( count >= 32 )
klauss 109:a5b8264ffbbc 1517 {
klauss 109:a5b8264ffbbc 1518 count = 0;
klauss 109:a5b8264ffbbc 1519 i++;
klauss 109:a5b8264ffbbc 1520 break;
klauss 109:a5b8264ffbbc 1521 }
klauss 109:a5b8264ffbbc 1522 }
klauss 109:a5b8264ffbbc 1523 strcat ( aux, "\n\r\0" );
klauss 109:a5b8264ffbbc 1524 tcp_client.send_all ( ( char *)aux, strlen( (char * )aux ) );
klauss 109:a5b8264ffbbc 1525 if ( i >= sizeof ( RTP ) ) finished = true;
klauss 109:a5b8264ffbbc 1526 strcpy ( aux, "\0" );
klauss 109:a5b8264ffbbc 1527 }
klauss 109:a5b8264ffbbc 1528 }
klauss 109:a5b8264ffbbc 1529 dont_overwrite_tcp_buffer.reset();
klauss 109:a5b8264ffbbc 1530 dont_overwrite_tcp_buffer.stop();
klauss 109:a5b8264ffbbc 1531 tcp_client.send_all ( "\r\n> ", strlen( "\r\n> " ) );
klauss 109:a5b8264ffbbc 1532 }
klauss 109:a5b8264ffbbc 1533 }
klauss 109:a5b8264ffbbc 1534 }
klauss 109:a5b8264ffbbc 1535 else
klauss 109:a5b8264ffbbc 1536 {
klauss 109:a5b8264ffbbc 1537 if( print_values )
klauss 109:a5b8264ffbbc 1538 {
klauss 109:a5b8264ffbbc 1539 debug_msg("Call %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1540 }
klauss 109:a5b8264ffbbc 1541 else
klauss 109:a5b8264ffbbc 1542 {
klauss 109:a5b8264ffbbc 1543 send_msg("Call %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1544 }
klauss 109:a5b8264ffbbc 1545 }
klauss 109:a5b8264ffbbc 1546 }
klauss 109:a5b8264ffbbc 1547
klauss 109:a5b8264ffbbc 1548 if ( print_rtp_var )
klauss 109:a5b8264ffbbc 1549 {
klauss 109:a5b8264ffbbc 1550 print_rtp_var = false;
klauss 109:a5b8264ffbbc 1551 VZ_call * call = __find_Call__( v_call, print_this_rtp );
klauss 109:a5b8264ffbbc 1552 if ( call != NULL )
klauss 109:a5b8264ffbbc 1553 {
klauss 109:a5b8264ffbbc 1554 if ( call -> check_rtp () != NULL )
klauss 109:a5b8264ffbbc 1555 {
klauss 109:a5b8264ffbbc 1556 send_msg ("Values :: %p\r\n", ( void *) call -> check_rtp () );
klauss 109:a5b8264ffbbc 1557 call -> rtp_print_yourself ();
klauss 109:a5b8264ffbbc 1558 }
klauss 109:a5b8264ffbbc 1559 else
klauss 109:a5b8264ffbbc 1560 {
klauss 109:a5b8264ffbbc 1561 if( print_values )
klauss 109:a5b8264ffbbc 1562 {
klauss 109:a5b8264ffbbc 1563 debug_msg("Call->RTP %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1564 }
klauss 109:a5b8264ffbbc 1565 else
klauss 109:a5b8264ffbbc 1566 {
klauss 109:a5b8264ffbbc 1567 send_msg("Call->RTP %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1568 }
klauss 109:a5b8264ffbbc 1569 }
klauss 109:a5b8264ffbbc 1570 }
klauss 109:a5b8264ffbbc 1571 else
klauss 109:a5b8264ffbbc 1572 {
klauss 109:a5b8264ffbbc 1573 if( print_values )
klauss 109:a5b8264ffbbc 1574 {
klauss 109:a5b8264ffbbc 1575 debug_msg("Call->RTP %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1576 }
klauss 109:a5b8264ffbbc 1577 else
klauss 109:a5b8264ffbbc 1578 {
klauss 109:a5b8264ffbbc 1579 send_msg("Call->RTP %d not found", print_this_rtp );
klauss 109:a5b8264ffbbc 1580 }
klauss 109:a5b8264ffbbc 1581 }
klauss 109:a5b8264ffbbc 1582 }
klauss 109:a5b8264ffbbc 1583
klauss 114:472502b31a12 1584 //end debug_print
klauss 91:c2a86b1f8aaa 1585
klauss 91:c2a86b1f8aaa 1586 if( reset_cks == true ) {
klauss 81:3656f00ab3db 1587 pkg_cksok = 0;
klauss 81:3656f00ab3db 1588 pkg_ckserr = 0;
klauss 99:e80850c51106 1589 pkg_zero = 0;
klauss 81:3656f00ab3db 1590 reset_cks = false;
klauss 99:e80850c51106 1591 out_of_range = 0;
klauss 99:e80850c51106 1592 missed_pkg = 0;
klauss 100:09a23fcd3bdf 1593 delayed_pkg_to_cb = 0;
klauss 99:e80850c51106 1594 cpld_pkg_tx_counter = 0;
klauss 99:e80850c51106 1595 cpld_pkg_rx_counter = 0;
klauss 81:3656f00ab3db 1596 pcks_s = true;
klauss 81:3656f00ab3db 1597 }
klauss 91:c2a86b1f8aaa 1598
klauss 115:a1e1e2e60a2c 1599 // exibe os contadores de cks de pacotes recebidos na interface CBx->Header, e outros contadores relacionados
klauss 91:c2a86b1f8aaa 1600 if( pcks_s == true ) {
klauss 115:a1e1e2e60a2c 1601 send_msg(
klauss 115:a1e1e2e60a2c 1602 "\r\n"
klauss 115:a1e1e2e60a2c 1603 " PKG_CKS OK: %d ( %003.2f )\r\n"
klauss 115:a1e1e2e60a2c 1604 " PKG_CKS ERR: %d ( %003.2f )\r\n"
klauss 115:a1e1e2e60a2c 1605 " PKG_0: %d ( %003.2f )\r\n"
klauss 115:a1e1e2e60a2c 1606 " Out_of_range: %d ( %003.2f )\r\n"
klauss 115:a1e1e2e60a2c 1607 " Miss_Pkg: %d\r\n"
klauss 115:a1e1e2e60a2c 1608 " TX_delayed: %d\n\r"
klauss 115:a1e1e2e60a2c 1609 " TX_Counter: %d\n\r"
klauss 115:a1e1e2e60a2c 1610 " RX_Counter: %d\r\n",
klauss 115:a1e1e2e60a2c 1611 pkg_cksok, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_cksok / cpld_pkg_rx_counter ) * 100,
klauss 115:a1e1e2e60a2c 1612 pkg_ckserr, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_ckserr / cpld_pkg_rx_counter ) * 100,
klauss 115:a1e1e2e60a2c 1613 pkg_zero, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) pkg_zero / cpld_pkg_rx_counter ) * 100,
klauss 115:a1e1e2e60a2c 1614 out_of_range, ( cpld_pkg_rx_counter == 0 ) ? 0.00 : ( ( double ) out_of_range / cpld_pkg_rx_counter ) * 100,
klauss 115:a1e1e2e60a2c 1615 missed_pkg,
klauss 115:a1e1e2e60a2c 1616 delayed_pkg_to_cb,
klauss 115:a1e1e2e60a2c 1617 cpld_pkg_tx_counter,
klauss 115:a1e1e2e60a2c 1618 cpld_pkg_rx_counter
klauss 115:a1e1e2e60a2c 1619 );
klauss 81:3656f00ab3db 1620 pcks_s = false;
klauss 81:3656f00ab3db 1621 }
klauss 116:39a41ebb675c 1622
klauss 116:39a41ebb675c 1623 // zera os contadores de pacotes que resultaram em falha de envio vio ETH
klauss 116:39a41ebb675c 1624 if( reset_missed_send_udp_pkg ){
klauss 116:39a41ebb675c 1625 miss_fw_send_pkg = 0;
klauss 116:39a41ebb675c 1626 miss_prompt_udp_send_pkg = 0;
klauss 116:39a41ebb675c 1627 miss_sip_registry_send_pkg = 0;
klauss 116:39a41ebb675c 1628 miss_sip_invite_send_pkg = 0;
klauss 116:39a41ebb675c 1629 miss_sip_bye_send_pkg = 0;
klauss 116:39a41ebb675c 1630 miss_sip_unregistry_send_pkg = 0;
klauss 116:39a41ebb675c 1631 miss_sip_ok_send_pkg = 0;
klauss 116:39a41ebb675c 1632 miss_sip_rcv_bye_send_pkg = 0;
klauss 116:39a41ebb675c 1633 miss_wdt_send_pkg = 0;
klauss 116:39a41ebb675c 1634 miss_prompt_udp_send_pkg = 0;
klauss 116:39a41ebb675c 1635 miss_ftp_udp_send_pkg = 0;
klauss 116:39a41ebb675c 1636 miss_prompt_udp_rcv_pkg = 0;
klauss 116:39a41ebb675c 1637 reset_missed_send_udp_pkg = false;
klauss 116:39a41ebb675c 1638 missed_send_udp_pkg = true;
klauss 116:39a41ebb675c 1639 }
klauss 116:39a41ebb675c 1640
klauss 116:39a41ebb675c 1641 // exibe estatisticas de pacotes que resultaram em falha de envio na interface ETH
klauss 116:39a41ebb675c 1642 if( missed_send_udp_pkg )
klauss 116:39a41ebb675c 1643 {
klauss 116:39a41ebb675c 1644 send_msg( "\r\nMissed pkgs ::\r\n "
klauss 116:39a41ebb675c 1645 "FW: %d\r\n "
klauss 116:39a41ebb675c 1646 "Prompt UDP %d\r\n "
klauss 116:39a41ebb675c 1647 "Registry %d\r\n "
klauss 116:39a41ebb675c 1648 "Invite %d\r\n "
klauss 116:39a41ebb675c 1649 "Bye %d\r\n "
klauss 116:39a41ebb675c 1650 "Unregistry %d\r\n "
klauss 116:39a41ebb675c 1651 "UDP incoming ( invite ans ) %d\r\n "
klauss 116:39a41ebb675c 1652 "UDP incoming ( bye from * ) %d\r\n "
klauss 116:39a41ebb675c 1653 "Wdt [ alive | rst ] %d\r\n "
klauss 116:39a41ebb675c 1654 "Rcv prompt %d\r\n "
klauss 116:39a41ebb675c 1655 "[ debug | send ]_msg %d\r\n "
klauss 116:39a41ebb675c 1656 "RTP %d\r\n",
klauss 116:39a41ebb675c 1657 miss_fw_send_pkg,
klauss 116:39a41ebb675c 1658 miss_prompt_udp_send_pkg,
klauss 116:39a41ebb675c 1659 miss_sip_registry_send_pkg,
klauss 116:39a41ebb675c 1660 miss_sip_invite_send_pkg,
klauss 116:39a41ebb675c 1661 miss_sip_bye_send_pkg,
klauss 116:39a41ebb675c 1662 miss_sip_unregistry_send_pkg,
klauss 116:39a41ebb675c 1663 miss_sip_ok_send_pkg,
klauss 116:39a41ebb675c 1664 miss_sip_rcv_bye_send_pkg,
klauss 116:39a41ebb675c 1665 miss_wdt_send_pkg,
klauss 116:39a41ebb675c 1666 miss_prompt_udp_send_pkg,
klauss 116:39a41ebb675c 1667 miss_prompt_udp_rcv_pkg,
klauss 116:39a41ebb675c 1668 miss_ftp_udp_send_pkg
klauss 116:39a41ebb675c 1669 );
klauss 116:39a41ebb675c 1670
klauss 116:39a41ebb675c 1671 missed_send_udp_pkg = false;
klauss 116:39a41ebb675c 1672 }
klauss 114:472502b31a12 1673
klauss 100:09a23fcd3bdf 1674 if( flood_bug_pkg ){
klauss 100:09a23fcd3bdf 1675 static int id = 0x10;
klauss 100:09a23fcd3bdf 1676 if( id < 10 ) id = 0x0b;
klauss 116:39a41ebb675c 1677 send2callboxes( build_cb_package( 5828, 5123, __REGISTRY__,
klauss 116:39a41ebb675c 1678 ( char * )buffer, id++, CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 100:09a23fcd3bdf 1679 }
klauss 100:09a23fcd3bdf 1680
klauss 114:472502b31a12 1681 if( led_sync_timer.read() > 1 ) {
klauss 78:1353744f01e1 1682 led_sync_timer.reset();
klauss 78:1353744f01e1 1683 led3 = !led3;
klauss 78:1353744f01e1 1684 CAB_LED = !CAB_LED;
klauss 78:1353744f01e1 1685 }
klauss 114:472502b31a12 1686
klauss 91:c2a86b1f8aaa 1687 switch( type ) {
klauss 91:c2a86b1f8aaa 1688 case __DO_NOTHING__ :
klauss 91:c2a86b1f8aaa 1689 {}
klauss 91:c2a86b1f8aaa 1690 break;
klauss 91:c2a86b1f8aaa 1691
klauss 0:4d17cd9c8f9d 1692 case __CB_BYE__ : {
klauss 63:0d95da692bb4 1693 cb_bye_counter++;
klauss 0:4d17cd9c8f9d 1694 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1695 if( cb != NULL ) {
klauss 81:3656f00ab3db 1696 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 1697 data[ 0 ] |= BIT7;
klauss 0:4d17cd9c8f9d 1698 cb->set_msg_id( data[ 0 ] );
klauss 81:3656f00ab3db 1699 if( debug_main || debug_invite ) debug_msg( "Request bye from CBx " );
klauss 92:92df17f538a8 1700
klauss 81:3656f00ab3db 1701 bool already_removed = true;
klauss 91:c2a86b1f8aaa 1702 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 0:4d17cd9c8f9d 1703 VZ_call * call = (VZ_call *)v_call->get_element( i );
klauss 91:c2a86b1f8aaa 1704 if( call->get_cb_ext() == ext ) {
klauss 81:3656f00ab3db 1705 already_removed = false;
klauss 4:de46f0d9b14d 1706 cb->send_bye();
klauss 91:c2a86b1f8aaa 1707
klauss 0:4d17cd9c8f9d 1708 ts->return_timeslice( cb->get_timeslice() );
klauss 0:4d17cd9c8f9d 1709 cb->set_timeslice( 0x00 );
klauss 78:1353744f01e1 1710 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 91:c2a86b1f8aaa 1711
klauss 0:4d17cd9c8f9d 1712 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 1713 set_status( cb->sip->status, sip_idle );
klauss 91:c2a86b1f8aaa 1714
klauss 81:3656f00ab3db 1715 v_call->remove_element( i );
klauss 91:c2a86b1f8aaa 1716
klauss 116:39a41ebb675c 1717 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 116:39a41ebb675c 1718 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 92:92df17f538a8 1719
klauss 92:92df17f538a8 1720 // envia o ack bye depois atualiza o msg_id
klauss 92:92df17f538a8 1721 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 91:c2a86b1f8aaa 1722
klauss 116:39a41ebb675c 1723 cb -> set_rtp_port ( 0 );
klauss 116:39a41ebb675c 1724
klauss 116:39a41ebb675c 1725 cb -> reset_rtp_timer ();
klauss 116:39a41ebb675c 1726
klauss 3:cd9148672e25 1727 delete( call );
klauss 0:4d17cd9c8f9d 1728 }
klauss 0:4d17cd9c8f9d 1729 }
klauss 82:f55d13babca0 1730 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from vector call" );
klauss 114:472502b31a12 1731
klauss 114:472502b31a12 1732 //ok, mas nem sempre o cbx "entrou em call
klauss 82:f55d13babca0 1733 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 82:f55d13babca0 1734 Call_Box * cb = (Call_Box *)v_cb->get_element( i );
klauss 82:f55d13babca0 1735 if( cb->get_ext() == ext ) {
klauss 82:f55d13babca0 1736 already_removed = true;
klauss 82:f55d13babca0 1737 if( cb->get_status() != cb_idle ) {
klauss 82:f55d13babca0 1738 already_removed = false;
klauss 82:f55d13babca0 1739 cb->send_bye();
klauss 82:f55d13babca0 1740
klauss 82:f55d13babca0 1741 ts->return_timeslice( cb->get_timeslice() );
klauss 82:f55d13babca0 1742 cb->set_timeslice( 0x00 );
klauss 82:f55d13babca0 1743 data[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 82:f55d13babca0 1744
klauss 82:f55d13babca0 1745 set_status( cb->status, cb_idle );
klauss 82:f55d13babca0 1746 set_status( cb->sip->status, sip_idle );
klauss 82:f55d13babca0 1747
klauss 116:39a41ebb675c 1748 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 116:39a41ebb675c 1749 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 82:f55d13babca0 1750
klauss 92:92df17f538a8 1751 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 82:f55d13babca0 1752 }
klauss 82:f55d13babca0 1753 }
klauss 82:f55d13babca0 1754 }
klauss 91:c2a86b1f8aaa 1755
klauss 82:f55d13babca0 1756 if( already_removed ) if( debug_main || debug_invite ) debug_msg( "Already removed from inviting queue" );
klauss 91:c2a86b1f8aaa 1757
klauss 78:1353744f01e1 1758 cb->registry();
klauss 116:39a41ebb675c 1759 cb -> set_rtp_port ( 0 );
klauss 116:39a41ebb675c 1760 cb -> reset_rtp_timer ();
klauss 91:c2a86b1f8aaa 1761 } else if( debug_invite || debug_main ) debug_msg("Bye from who ? %d", ext );
klauss 91:c2a86b1f8aaa 1762 }
klauss 91:c2a86b1f8aaa 1763 break;
klauss 91:c2a86b1f8aaa 1764
klauss 0:4d17cd9c8f9d 1765 case __INVITE__ : {
klauss 114:472502b31a12 1766 if( drop_invite_pkg ){
klauss 115:a1e1e2e60a2c 1767 debug_msg("Dropando invite pck from %d msg id :: %d", ext, data[ 0 ] );
klauss 114:472502b31a12 1768 break;
klauss 114:472502b31a12 1769 }
klauss 63:0d95da692bb4 1770 invite_counter++;
klauss 116:39a41ebb675c 1771 if( debug_invite ) debug_msg("Invite request from %i", ext);
klauss 0:4d17cd9c8f9d 1772 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 115:a1e1e2e60a2c 1773
klauss 91:c2a86b1f8aaa 1774 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1775 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 91:c2a86b1f8aaa 1776 if( debug_main ) debug_msg( "Adding CBx :: %i", ext );
klauss 91:c2a86b1f8aaa 1777 cb = new Call_Box( ext, port );
klauss 91:c2a86b1f8aaa 1778
klauss 91:c2a86b1f8aaa 1779 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1780 memory_is_over = true;
klauss 91:c2a86b1f8aaa 1781 if( debug_memory ) debug_msg("Invite allocation cb fail");
klauss 91:c2a86b1f8aaa 1782 } else {
klauss 91:c2a86b1f8aaa 1783 v_cb->add( cb );
klauss 91:c2a86b1f8aaa 1784 }
klauss 89:0fe315117b00 1785 }
klauss 0:4d17cd9c8f9d 1786 }
klauss 115:a1e1e2e60a2c 1787
klauss 115:a1e1e2e60a2c 1788 if( cb != NULL )
klauss 115:a1e1e2e60a2c 1789 {
klauss 115:a1e1e2e60a2c 1790 cb->invite_retry_count_reset();
klauss 115:a1e1e2e60a2c 1791
klauss 91:c2a86b1f8aaa 1792 cb->set_msg_id( data[ 0 ] );
klauss 115:a1e1e2e60a2c 1793
klauss 115:a1e1e2e60a2c 1794 if( cb->status == cb_idle ){
klauss 116:39a41ebb675c 1795 cb -> set_invite_response_ok();
klauss 116:39a41ebb675c 1796 cb -> reset_rtp_timer ();
klauss 116:39a41ebb675c 1797 cb -> init_rtp_timer ();
klauss 115:a1e1e2e60a2c 1798 } else {
klauss 115:a1e1e2e60a2c 1799 data[ __TIMESLICE_PLACE__ ] = cb->get_timeslice();
klauss 115:a1e1e2e60a2c 1800
klauss 115:a1e1e2e60a2c 1801 cb->set_invite_response_pending();
klauss 115:a1e1e2e60a2c 1802
klauss 115:a1e1e2e60a2c 1803 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 115:a1e1e2e60a2c 1804
klauss 116:39a41ebb675c 1805 send2callboxes( build_cb_package( ext, port, __INVITE__,
klauss 116:39a41ebb675c 1806 ( char * )data, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 92:92df17f538a8 1807 }
klauss 115:a1e1e2e60a2c 1808
klauss 87:679ee0d594a9 1809 invite_handler( v_call, v_cb, ts, cb );
klauss 87:679ee0d594a9 1810 }
klauss 91:c2a86b1f8aaa 1811 }
klauss 91:c2a86b1f8aaa 1812 break;
klauss 4:de46f0d9b14d 1813 case __REGISTRY__ : {
klauss 63:0d95da692bb4 1814 registry_counter++;
klauss 78:1353744f01e1 1815 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1816 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 91:c2a86b1f8aaa 1817 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1818 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 91:c2a86b1f8aaa 1819 cb = new Call_Box( ext, port );
klauss 91:c2a86b1f8aaa 1820
klauss 91:c2a86b1f8aaa 1821 if( cb == NULL ) {
klauss 91:c2a86b1f8aaa 1822 memory_is_over = true;
klauss 91:c2a86b1f8aaa 1823 if( debug_memory ) debug_msg("Registry cb allocation fail");
klauss 91:c2a86b1f8aaa 1824 } else {
klauss 91:c2a86b1f8aaa 1825 v_cb->add( cb );
klauss 91:c2a86b1f8aaa 1826 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 91:c2a86b1f8aaa 1827 }
klauss 87:679ee0d594a9 1828 }
klauss 0:4d17cd9c8f9d 1829 }
klauss 78:1353744f01e1 1830 if( debug_main ) debug_msg("Registered %d - %d", ext, port );
klauss 91:c2a86b1f8aaa 1831
klauss 87:679ee0d594a9 1832 if( cb != NULL ) cb->registry();
klauss 114:472502b31a12 1833
klauss 91:c2a86b1f8aaa 1834 }
klauss 91:c2a86b1f8aaa 1835 break;
klauss 4:de46f0d9b14d 1836 case __BOOT__ : {
klauss 63:0d95da692bb4 1837 boot_counter++;
klauss 99:e80850c51106 1838 if( debug_boot == true ){
klauss 99:e80850c51106 1839 send_msg("Rcv boot pkg from (%d, %d) pkg-id %d", ext, port, data[ 0 ] );
klauss 99:e80850c51106 1840 }
klauss 116:39a41ebb675c 1841 send2callboxes( build_cb_package( ext, port, __REGISTRY__,
klauss 116:39a41ebb675c 1842 ( char * )data, data[ 0 ] | BIT7, CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 91:c2a86b1f8aaa 1843 }
klauss 91:c2a86b1f8aaa 1844 break;
klauss 99:e80850c51106 1845
klauss 99:e80850c51106 1846 case __FW__ : {
klauss 99:e80850c51106 1847 if( debug_fw_print ) send_msg("::FW pkg from %d - %d::", ext, port );
klauss 99:e80850c51106 1848 fw_cbx_pkg( ext, port, ( char *)buffer );
klauss 99:e80850c51106 1849 }
klauss 99:e80850c51106 1850 break;
klauss 91:c2a86b1f8aaa 1851
klauss 114:472502b31a12 1852 case __BOOTLOADER_CBX__ : {
klauss 67:cdedc64d9921 1853 bootloader_cbx_counter++;
klauss 91:c2a86b1f8aaa 1854 }
klauss 91:c2a86b1f8aaa 1855 break;
klauss 91:c2a86b1f8aaa 1856
klauss 114:472502b31a12 1857 case __PROMPT__ : {
klauss 78:1353744f01e1 1858 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 91:c2a86b1f8aaa 1859
klauss 91:c2a86b1f8aaa 1860 if( cb == NULL ) {
klauss 116:39a41ebb675c 1861 if( v_cb->size() < __MAX_CB_IN_A_BRANCH__ ) {
klauss 116:39a41ebb675c 1862 if( debug_main ) debug_msg("Adding Cbx :: %d", ext );
klauss 116:39a41ebb675c 1863 cb = new Call_Box( ext, port );
klauss 116:39a41ebb675c 1864 if( cb == NULL ){
klauss 116:39a41ebb675c 1865 memory_is_over = true;
klauss 116:39a41ebb675c 1866 }else{
klauss 116:39a41ebb675c 1867 v_cb->add( cb );
klauss 116:39a41ebb675c 1868 if( debug_main ) debug_msg("Added CBx -- %d", ext );
klauss 116:39a41ebb675c 1869 }
klauss 87:679ee0d594a9 1870 }
klauss 48:195c97f12e8e 1871 }
klauss 91:c2a86b1f8aaa 1872
klauss 92:92df17f538a8 1873 if( cb!= NULL ) cb->registry();
klauss 91:c2a86b1f8aaa 1874
klauss 91:c2a86b1f8aaa 1875 if( xstrmatch( ( uint8_t * )data, ( uint8_t * )"ping" ) ) {
klauss 78:1353744f01e1 1876 if( debug_ping ) send_msg( "Prompt pkg from ( %i, %i ) :: Ping", ext, port );
klauss 91:c2a86b1f8aaa 1877 } else {
klauss 78:1353744f01e1 1878 prompt_counter++;
klauss 114:472502b31a12 1879 //fixme isso nao poderia ser resolvido com um sendmsg ?
klauss 78:1353744f01e1 1880 send_msg( "Prompt pkg from ( %i, %i ) ::", ext, port );
klauss 91:c2a86b1f8aaa 1881 for( register uint8_t i = 0; i < 32; i++ ) {
klauss 100:09a23fcd3bdf 1882 if( debug_uart3 ) pc.printf("%c", data[ i ] );
klauss 100:09a23fcd3bdf 1883 if( i == 15 ) if( debug_uart3 ) pc.printf( "\r\n" );
klauss 78:1353744f01e1 1884 }
klauss 100:09a23fcd3bdf 1885 if( debug_uart3 ) pc.printf("\n\r> ");
klauss 91:c2a86b1f8aaa 1886
klauss 114:472502b31a12 1887 if( tcp_session ) {
klauss 116:39a41ebb675c 1888 char aux[ CB_BUFFER_SIZE + 3 ];
klauss 116:39a41ebb675c 1889 strncpy( aux, (char * )data, CB_BUFFER_SIZE );
klauss 78:1353744f01e1 1890 strcat( aux, "\n\r\0" );
klauss 78:1353744f01e1 1891 tcp_client.send_all( ( char *)data, strlen( (char * )data ) );
klauss 78:1353744f01e1 1892 tcp_client.send_all( "\r\n> ", strlen( "\r\n> " ) );
klauss 78:1353744f01e1 1893 }
klauss 48:195c97f12e8e 1894 }
klauss 91:c2a86b1f8aaa 1895 }
klauss 91:c2a86b1f8aaa 1896 break;
klauss 0:4d17cd9c8f9d 1897 case __AUDIO__ : {
klauss 63:0d95da692bb4 1898 audio_counter++;
klauss 115:a1e1e2e60a2c 1899 if ( received_audio_from_cb ) {
klauss 115:a1e1e2e60a2c 1900 debug_msg("audio pkg from %d", ext );
klauss 115:a1e1e2e60a2c 1901 }
klauss 115:a1e1e2e60a2c 1902
klauss 78:1353744f01e1 1903 VZ_call * call = __find_Call__( v_call, ext );
klauss 91:c2a86b1f8aaa 1904 if( call != NULL ) {
klauss 115:a1e1e2e60a2c 1905 if ( drop_rtp_from_cbx_pkg ){
klauss 114:472502b31a12 1906 led2 = !led2;
klauss 114:472502b31a12 1907 break;
klauss 115:a1e1e2e60a2c 1908 } else {
klauss 114:472502b31a12 1909 char * pkg = call->build_eth_package( data + 2 );
klauss 114:472502b31a12 1910 call->send_message( pkg );
klauss 114:472502b31a12 1911 call->cbx_pkg_idle_timer_reset();
klauss 114:472502b31a12 1912 }
klauss 115:a1e1e2e60a2c 1913 }
klauss 115:a1e1e2e60a2c 1914
klauss 115:a1e1e2e60a2c 1915 Call_Box * cb = __find_CB__( v_cb, ext );
klauss 115:a1e1e2e60a2c 1916 if( cb != NULL ){
klauss 115:a1e1e2e60a2c 1917 if ( cb->get_invite_response() == false ) {
klauss 115:a1e1e2e60a2c 1918 cb->set_invite_response_ok();
klauss 115:a1e1e2e60a2c 1919 cb->invite_retry_count_reset();
klauss 115:a1e1e2e60a2c 1920 } else {
klauss 115:a1e1e2e60a2c 1921 if( debug_main ) debug_msg("received missed package from CBx :: %i", ext );
klauss 115:a1e1e2e60a2c 1922 }
klauss 0:4d17cd9c8f9d 1923 }
klauss 91:c2a86b1f8aaa 1924 }
klauss 91:c2a86b1f8aaa 1925 break;
klauss 114:472502b31a12 1926 }// fim switch
klauss 105:a930035b6556 1927
klauss 99:e80850c51106 1928 { // rajada
klauss 115:a1e1e2e60a2c 1929 if( invite_retry_timer.read_ms() > 20 )
klauss 112:6ae726539ab9 1930 {
klauss 99:e80850c51106 1931 invite_retry_timer.reset();
klauss 99:e80850c51106 1932
klauss 112:6ae726539ab9 1933 static int retry_invite_pkg = 0;
klauss 112:6ae726539ab9 1934 bool need_retry = false;
klauss 112:6ae726539ab9 1935 Call_Box * cb = NULL;
klauss 112:6ae726539ab9 1936
klauss 112:6ae726539ab9 1937 for ( register int i = 0; i < v_cb->size(); i++ )
klauss 112:6ae726539ab9 1938 {
klauss 112:6ae726539ab9 1939 retry_invite_pkg++;
klauss 112:6ae726539ab9 1940 if ( retry_invite_pkg >= v_cb->size() ) retry_invite_pkg = 0;
klauss 112:6ae726539ab9 1941
klauss 112:6ae726539ab9 1942 cb = (Call_Box * )v_cb->get_element( i );
klauss 112:6ae726539ab9 1943 if ( cb != NULL )
klauss 112:6ae726539ab9 1944 {
klauss 112:6ae726539ab9 1945 if ( ( cb->status == cb_ringing ) || ( cb->status == cb_trying ) || ( cb->status == cb_on_call ) )
klauss 112:6ae726539ab9 1946 {
klauss 112:6ae726539ab9 1947 need_retry = true;
klauss 99:e80850c51106 1948 break;
klauss 99:e80850c51106 1949 }
klauss 92:92df17f538a8 1950 }
klauss 99:e80850c51106 1951 }
klauss 109:a5b8264ffbbc 1952
klauss 112:6ae726539ab9 1953 if ( need_retry )
klauss 112:6ae726539ab9 1954 {
klauss 112:6ae726539ab9 1955 if( cb->get_invite_response() == false )
klauss 112:6ae726539ab9 1956 {
klauss 112:6ae726539ab9 1957 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 99:e80850c51106 1958
klauss 112:6ae726539ab9 1959 buffer[ __TIMESLICE_PLACE__ ] = cb->get_timeslice();
klauss 112:6ae726539ab9 1960
klauss 116:39a41ebb675c 1961 send2callboxes( build_cb_package( cb->get_ext(), cb->get_port(), __INVITE__, ( char * )buffer,
klauss 116:39a41ebb675c 1962 cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 109:a5b8264ffbbc 1963
klauss 112:6ae726539ab9 1964 if( debug_invite ) debug_msg("resend invite OK to Cbx : ( %d, %d )", cb->get_ext(), cb->get_port() );
klauss 115:a1e1e2e60a2c 1965 }
klauss 115:a1e1e2e60a2c 1966
klauss 115:a1e1e2e60a2c 1967 if ( __find_Call__( v_call, cb->get_ext () ) == NULL )
klauss 112:6ae726539ab9 1968 {
klauss 115:a1e1e2e60a2c 1969
klauss 115:a1e1e2e60a2c 1970 if ( ( ( cb->status == cb_ringing ) || ( cb->status == cb_trying ) ) )
klauss 112:6ae726539ab9 1971 {
klauss 115:a1e1e2e60a2c 1972 const int rtp_tmp_length = 172;
klauss 116:39a41ebb675c 1973 char rtp_src_tmp_write_buffer [ CB_BUFFER_SIZE ];
klauss 116:39a41ebb675c 1974 uint8_t rtp_dst_tmp_write_buffer [ CB_BUFFER_SIZE ];
klauss 115:a1e1e2e60a2c 1975
klauss 115:a1e1e2e60a2c 1976 for ( register int i = 0; i < rtp_tmp_length; i++ ) rtp_src_tmp_write_buffer [ i ] = 'U'; // 0x55
klauss 115:a1e1e2e60a2c 1977
klauss 116:39a41ebb675c 1978 send2callboxes( build_cb_package( cb->get_ext (), cb->get_port (), __AUDIO__,
klauss 115:a1e1e2e60a2c 1979 rtp_src_tmp_write_buffer, __AUDIO__, rtp_tmp_length, rtp_dst_tmp_write_buffer ) );
klauss 115:a1e1e2e60a2c 1980 } else {
klauss 115:a1e1e2e60a2c 1981 if ( cb->get_invite_retry_count() == 0 )
klauss 112:6ae726539ab9 1982 {
klauss 115:a1e1e2e60a2c 1983 cb->send_bye();
klauss 115:a1e1e2e60a2c 1984
klauss 115:a1e1e2e60a2c 1985 ts->return_timeslice( cb->get_timeslice() );
klauss 115:a1e1e2e60a2c 1986 cb->set_timeslice( 0x00 );
klauss 115:a1e1e2e60a2c 1987
klauss 115:a1e1e2e60a2c 1988 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 115:a1e1e2e60a2c 1989
klauss 115:a1e1e2e60a2c 1990 for ( register uint8_t i = 0; i < v_call->size(); i++ )
klauss 115:a1e1e2e60a2c 1991 {
klauss 115:a1e1e2e60a2c 1992 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 115:a1e1e2e60a2c 1993 if( call->get_cb_ext() == cb->get_ext() )
klauss 115:a1e1e2e60a2c 1994 {
klauss 115:a1e1e2e60a2c 1995 v_call->remove_element( i );
klauss 115:a1e1e2e60a2c 1996 if( call != NULL ) delete( call );
klauss 115:a1e1e2e60a2c 1997 break;
klauss 115:a1e1e2e60a2c 1998 }
klauss 115:a1e1e2e60a2c 1999 }
klauss 115:a1e1e2e60a2c 2000
klauss 115:a1e1e2e60a2c 2001 if( debug_invite ) debug_msg( "-- No audio pkgs --" );
klauss 115:a1e1e2e60a2c 2002 set_status( cb->status, cb_idle );
klauss 115:a1e1e2e60a2c 2003 set_status( cb->sip->status, sip_idle );
klauss 92:92df17f538a8 2004 }
klauss 112:6ae726539ab9 2005 }
klauss 92:92df17f538a8 2006 }
klauss 92:92df17f538a8 2007 }
klauss 112:6ae726539ab9 2008 }
klauss 114:472502b31a12 2009 } // fim rajada
klauss 114:472502b31a12 2010
klauss 91:c2a86b1f8aaa 2011 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 0:4d17cd9c8f9d 2012 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 116:39a41ebb675c 2013 if ( call != NULL )
klauss 116:39a41ebb675c 2014 {
klauss 116:39a41ebb675c 2015 int length = 0;
klauss 116:39a41ebb675c 2016 char * tmp = call->get_eth_message( &length );
klauss 116:39a41ebb675c 2017 if( tmp != NULL ) {
klauss 116:39a41ebb675c 2018 int cb_port = 0xffff;
klauss 116:39a41ebb675c 2019 Call_Box * cb = __find_CB__( v_cb, call->get_cb_ext() );
klauss 116:39a41ebb675c 2020
klauss 116:39a41ebb675c 2021 if( cb != NULL ) {
klauss 116:39a41ebb675c 2022 cb_port = cb->get_port();
klauss 116:39a41ebb675c 2023
klauss 116:39a41ebb675c 2024 if ( drop_rtp_from_ast_pkg )
klauss 116:39a41ebb675c 2025 {
klauss 116:39a41ebb675c 2026 led1 = !led1;
klauss 116:39a41ebb675c 2027 }
klauss 116:39a41ebb675c 2028 else
klauss 116:39a41ebb675c 2029 {
klauss 116:39a41ebb675c 2030 uint8_t * pkg2cb = build_cb_package( call->get_cb_ext(), cb_port, __AUDIO__,
klauss 116:39a41ebb675c 2031 tmp, __AUDIO__, length, write_buffer );
klauss 116:39a41ebb675c 2032
klauss 116:39a41ebb675c 2033 send2callboxes( pkg2cb );
klauss 116:39a41ebb675c 2034 }
klauss 116:39a41ebb675c 2035
klauss 116:39a41ebb675c 2036 } else if( debug_main ) debug_msg("received missed package from CBx :: %i -- Type :: %i", ext, type );
klauss 116:39a41ebb675c 2037 }
klauss 0:4d17cd9c8f9d 2038 }
klauss 14:22a35f575502 2039 }
klauss 114:472502b31a12 2040
klauss 114:472502b31a12 2041 if( timer_sync_refresh.read_ms() > 250 ) {
klauss 114:472502b31a12 2042 timer_sync_refresh.reset();
klauss 106:a34fcf9f0e02 2043
klauss 116:39a41ebb675c 2044 static uint8_t time_to_mode = TIME_TO_REFRESH;
klauss 114:472502b31a12 2045
klauss 116:39a41ebb675c 2046 if ( time_to_mode == TIME_TO_REFRESH ){
klauss 116:39a41ebb675c 2047 time_to_mode = TIME_TO_WAKE_UP;
klauss 116:39a41ebb675c 2048 refresh ( v_cb );
klauss 114:472502b31a12 2049 } else {
klauss 116:39a41ebb675c 2050 time_to_mode = TIME_TO_REFRESH;
klauss 116:39a41ebb675c 2051 if ( wake_all ) if ( v_call->size() == 0 ) wake_all_up ( v_cb );
klauss 89:0fe315117b00 2052 }
klauss 89:0fe315117b00 2053 }
klauss 108:18a3702650f3 2054
klauss 78:1353744f01e1 2055 // check sip messages only for cbx in call ?
klauss 78:1353744f01e1 2056 int ext_to__be_removed = sip_manager( v_cb );
klauss 91:c2a86b1f8aaa 2057 if( ext_to__be_removed > 0x00 ) {
klauss 78:1353744f01e1 2058 Call_Box * cb = __find_CB__( v_cb, ext_to__be_removed );
klauss 91:c2a86b1f8aaa 2059 if( cb != NULL ) {
klauss 91:c2a86b1f8aaa 2060 if( cb->status == cb_on_call ) {
klauss 4:de46f0d9b14d 2061 ts->return_timeslice( cb->get_timeslice() );
klauss 4:de46f0d9b14d 2062 cb->set_timeslice( 0x00 );
klauss 4:de46f0d9b14d 2063 buffer[ __TIMESLICE_PLACE__ ] = 0x00;
klauss 91:c2a86b1f8aaa 2064
klauss 78:1353744f01e1 2065 set_status( cb->status, cb_idle );
klauss 78:1353744f01e1 2066 set_status( cb->sip->status, sip_idle );
klauss 91:c2a86b1f8aaa 2067
klauss 91:c2a86b1f8aaa 2068 for( register uint8_t i = 0; i < v_call->size(); i++ ) {
klauss 4:de46f0d9b14d 2069 VZ_call * call = ( VZ_call * )v_call->get_element( i );
klauss 91:c2a86b1f8aaa 2070 if( call->get_cb_ext() == ext_to__be_removed ) {
klauss 4:de46f0d9b14d 2071 v_call->remove_element( i );
klauss 4:de46f0d9b14d 2072 delete( call );
klauss 4:de46f0d9b14d 2073 }
klauss 2:93bec7313ccc 2074 }
klauss 91:c2a86b1f8aaa 2075
klauss 92:92df17f538a8 2076 cb->set_msg_id( ( cb->get_msg_id() + 1 ) & ~BIT7 );
klauss 116:39a41ebb675c 2077
klauss 116:39a41ebb675c 2078 cb -> set_rtp_port ( 0 );
klauss 116:39a41ebb675c 2079
klauss 116:39a41ebb675c 2080 cb -> reset_rtp_timer ();
klauss 114:472502b31a12 2081
klauss 116:39a41ebb675c 2082 send2callboxes( build_cb_package( ext, port, __CB_BYE__,
klauss 116:39a41ebb675c 2083 ( char * )buffer, cb->get_msg_id(), CB_BUFFER_SIZE - __VZ_HEADER_OFFSET__, write_buffer ) );
klauss 91:c2a86b1f8aaa 2084
klauss 91:c2a86b1f8aaa 2085 if( debug_invite ) debug_msg("Received Bye from *");
klauss 114:472502b31a12 2086 //cb->re_start_timer();
klauss 0:4d17cd9c8f9d 2087 }
klauss 91:c2a86b1f8aaa 2088 } else if( debug_main ) debug_msg("Missed bye request from * CBx :: %d", ext );
klauss 114:472502b31a12 2089 }
klauss 91:c2a86b1f8aaa 2090
klauss 81:3656f00ab3db 2091 /* Verifica andamento de ligações para eventualmente encerra-las por timeout */
klauss 116:39a41ebb675c 2092 call_manager( v_call, v_cb, ts );
klauss 91:c2a86b1f8aaa 2093
klauss 114:472502b31a12 2094 /* tratamento de pedidos de ligação */
klauss 81:3656f00ab3db 2095 invite_handler( v_call, v_cb, ts, NULL );
klauss 114:472502b31a12 2096
klauss 81:3656f00ab3db 2097 /* rotina de verificação de TS's perdidos */
klauss 91:c2a86b1f8aaa 2098 if( ( v_call->size() == 0 ) && ( ts->remain_timeslices() != __MAX_TIMESLICES__ ) ) {
klauss 91:c2a86b1f8aaa 2099 bool ts_reset = true;
klauss 91:c2a86b1f8aaa 2100 for( register uint8_t i = 0; i < v_cb->size(); i++ ) {
klauss 82:f55d13babca0 2101 if ( ( ( Call_Box * )v_cb->get_element( i ) )->get_status() != cb_idle &&
klauss 91:c2a86b1f8aaa 2102 ( ( Call_Box * )v_cb->get_element( i ) )->get_sip_status() != sip_idle ) {
klauss 78:1353744f01e1 2103 ts_reset = false;
klauss 78:1353744f01e1 2104 break;
klauss 78:1353744f01e1 2105 }
klauss 91:c2a86b1f8aaa 2106 }
klauss 114:472502b31a12 2107 if( ts_reset ) {
klauss 114:472502b31a12 2108 if( debug_invite ) debug_msg("Resetando TS");
klauss 114:472502b31a12 2109 ts->reset();
klauss 78:1353744f01e1 2110 }
klauss 0:4d17cd9c8f9d 2111 }
klauss 112:6ae726539ab9 2112
klauss 112:6ae726539ab9 2113 /* rotina "zeradora" de portas RTP */
klauss 112:6ae726539ab9 2114 for ( register uint8_t i = 0; i < v_cb->size(); i++ )
klauss 112:6ae726539ab9 2115 {
klauss 112:6ae726539ab9 2116 Call_Box * cb = (Call_Box *) v_cb->get_element (i);
klauss 112:6ae726539ab9 2117 if ( cb != NULL )
klauss 112:6ae726539ab9 2118 {
klauss 112:6ae726539ab9 2119 if ( ( cb->get_status () == cb_idle ) && ( cb->get_sip_status () == sip_idle ) && ( cb -> is_rtp_timer_timeout () ) )
klauss 112:6ae726539ab9 2120 {
klauss 116:39a41ebb675c 2121 if ( debug_reset_rtp ) debug_msg( "%d rtp reset", cb -> get_ext () );
klauss 112:6ae726539ab9 2122 set_status ( cb -> status, cb_idle );
klauss 112:6ae726539ab9 2123 set_status ( cb->sip->status, sip_idle );
klauss 112:6ae726539ab9 2124 cb -> reset_rtp_timer ();
klauss 112:6ae726539ab9 2125 cb -> set_rtp_port ( 0 );
klauss 112:6ae726539ab9 2126 }
klauss 112:6ae726539ab9 2127 }
klauss 112:6ae726539ab9 2128 }
klauss 114:472502b31a12 2129
klauss 81:3656f00ab3db 2130 /* rotina que esvazia possiveis pacotes que não foram transmitidos para evitar conflito */
klauss 72:895ca792c647 2131 tx_buffer_ring_buffer_handler();
klauss 91:c2a86b1f8aaa 2132
klauss 30:8dfb6d8de53d 2133 type = __DO_NOTHING__;
klauss 114:472502b31a12 2134
klauss 81:3656f00ab3db 2135 if( eth_status == 0 ) eth_wdt = ETH_CONNECT_TIMEOUT;
klauss 114:472502b31a12 2136
klauss 91:c2a86b1f8aaa 2137 if( wdt_timer.read() >= 1 ) {
klauss 91:c2a86b1f8aaa 2138 //FIXME remove myself
klauss 114:472502b31a12 2139 //registry_test = true;
klauss 114:472502b31a12 2140 //invite_retry_time = true;
klauss 114:472502b31a12 2141
klauss 83:b8a1d8fdeaeb 2142 uptime++;
klauss 91:c2a86b1f8aaa 2143
klauss 81:3656f00ab3db 2144 wdt_timer.reset();
klauss 91:c2a86b1f8aaa 2145
klauss 81:3656f00ab3db 2146 if( wdt_show ) debug_wdt = true;
klauss 91:c2a86b1f8aaa 2147
klauss 81:3656f00ab3db 2148 if( external_wdt ) external_wdt--;
klauss 81:3656f00ab3db 2149 if( pkg_wdt ) pkg_wdt--;
klauss 81:3656f00ab3db 2150 if( eth_wdt ) eth_wdt--;
klauss 91:c2a86b1f8aaa 2151
klauss 91:c2a86b1f8aaa 2152 if( eth_wdt && external_wdt && pkg_wdt ){
klauss 81:3656f00ab3db 2153 wdt.kick();
klauss 81:3656f00ab3db 2154 }
klauss 114:472502b31a12 2155 }
klauss 114:472502b31a12 2156
klauss 91:c2a86b1f8aaa 2157 if( debug_wdt ) {
klauss 87:679ee0d594a9 2158 send_msg("lpc_low_level_input_counter :: %d", lpc_low_level_input_counter );
klauss 87:679ee0d594a9 2159 lpc_low_level_input_counter = 0;
klauss 91:c2a86b1f8aaa 2160
klauss 81:3656f00ab3db 2161 debug_wdt = false;
klauss 91:c2a86b1f8aaa 2162 if( eth_status == 0 ) {
klauss 91:c2a86b1f8aaa 2163 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 2164 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 91:c2a86b1f8aaa 2165 EXTERN_WDT_IDLE - external_wdt,
klauss 91:c2a86b1f8aaa 2166 EXTERN_WDT_IDLE,
klauss 91:c2a86b1f8aaa 2167 RX_CB_IDLE - pkg_wdt,
klauss 91:c2a86b1f8aaa 2168 RX_CB_IDLE
klauss 91:c2a86b1f8aaa 2169 );
klauss 91:c2a86b1f8aaa 2170 } else {
klauss 91:c2a86b1f8aaa 2171 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 2172 ( wdt.WatchdogCausedReset() ) ? "true" : "false",
klauss 91:c2a86b1f8aaa 2173 ETH_CONNECT_TIMEOUT - eth_wdt,
klauss 91:c2a86b1f8aaa 2174 EXTERN_WDT_IDLE - external_wdt,
klauss 91:c2a86b1f8aaa 2175 EXTERN_WDT_IDLE,
klauss 91:c2a86b1f8aaa 2176 RX_CB_IDLE - pkg_wdt,
klauss 91:c2a86b1f8aaa 2177 RX_CB_IDLE
klauss 91:c2a86b1f8aaa 2178 );
klauss 81:3656f00ab3db 2179 }
klauss 114:472502b31a12 2180 }
klauss 114:472502b31a12 2181 }
klauss 0:4d17cd9c8f9d 2182 }