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@86:bf7b0d4c3232, 2015-01-05 (annotated)

Committer:
klauss
Date:
Mon Jan 05 12:43:12 2015 +0000
Revision:
86:bf7b0d4c3232
Parent:
85:b6f2dc1d0f4f
Child:
87:679ee0d594a9
rx buffer personal config

Who changed what in which revision?

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