Yuuichi Akagawa / SNICInterface_fork

SNICInterface for development

Fork of SNICInterface by muRata

SNIC/SNIC_Core.cpp@44:9d901fec86b8, 2015-01-17 (annotated)

Committer:
YuuichiAkagawa
Date:
Sat Jan 17 06:12:43 2015 +0000
Revision:
44:9d901fec86b8
Parent:
43:d80bbb12ffe6 
Add GR-PEACH platform.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kishino 39:a1233ca02edf 1 /* Copyright (C) 2014 Murata Manufacturing Co.,Ltd., MIT License
kishino 41:1c1b5ad4d491 2 * muRata, SWITCH SCIENCE Wi-FI module TypeYD SNIC-UART.
kishino 20:dd736d328de6 3 *
kishino 39:a1233ca02edf 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
kishino 39:a1233ca02edf 5 * and associated documentation files (the "Software"), to deal in the Software without restriction,
kishino 39:a1233ca02edf 6 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
kishino 39:a1233ca02edf 7 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
kishino 39:a1233ca02edf 8 * furnished to do so, subject to the following conditions:
kishino 20:dd736d328de6 9 *
kishino 39:a1233ca02edf 10 * The above copyright notice and this permission notice shall be included in all copies or
kishino 39:a1233ca02edf 11 * substantial portions of the Software.
kishino 20:dd736d328de6 12 *
kishino 39:a1233ca02edf 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
kishino 39:a1233ca02edf 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
kishino 39:a1233ca02edf 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
kishino 39:a1233ca02edf 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
kishino 39:a1233ca02edf 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
kishino 39:a1233ca02edf 18 */
kishino 20:dd736d328de6 19 #include "mbed.h"
kishino 20:dd736d328de6 20 #include "SNIC_Core.h"
kishino 20:dd736d328de6 21 #include "SNIC_UartMsgUtil.h"
kishino 20:dd736d328de6 22 #include <string>
kishino 20:dd736d328de6 23
kishino 29:6a0ba999597d 24 /** Wait signal ID of UART recv */
kishino 35:e4e7f86fd975 25 #define UART_DISPATCH_SIGNAL 0x00000002
kishino 20:dd736d328de6 26
kishino 35:e4e7f86fd975 27 #define UART_RECVBUF_SIZE 2048
kishino 29:6a0ba999597d 28 #define UART_THREAD_STACK_SIZE 512
kishino 39:a1233ca02edf 29 #define UART_FIXED_HEADER_SIZE 3
kishino 39:a1233ca02edf 30 #define UART_FIXED_SIZE_IN_FRAME 6
kishino 39:a1233ca02edf 31 #define UART_RECV_QUEUE_TIMEOUT 500
kishino 29:6a0ba999597d 32
kishino 20:dd736d328de6 33 typedef struct
kishino 20:dd736d328de6 34 {
kishino 35:e4e7f86fd975 35 tagMEMPOOL_BLOCK_T *mem_p;
kishino 20:dd736d328de6 36 unsigned int size;
kishino 20:dd736d328de6 37 }tagUART_RECVBUF_T;
kishino 20:dd736d328de6 38
kishino 29:6a0ba999597d 39 /*
kishino 29:6a0ba999597d 40 Define the global buffer using the area for Ethernet.
kishino 29:6a0ba999597d 41 */
YuuichiAkagawa 44:9d901fec86b8 42 #if defined(TARGET_RZ_A1H)
YuuichiAkagawa 44:9d901fec86b8 43 unsigned char gUART_TEMP_BUF[UART_RECVBUF_SIZE];
YuuichiAkagawa 44:9d901fec86b8 44 unsigned char gUART_COMMAND_BUF[UART_REQUEST_PAYLOAD_MAX];
YuuichiAkagawa 44:9d901fec86b8 45 /** MemoryPool for payload of UART response */
YuuichiAkagawa 44:9d901fec86b8 46 MemoryPool<tagMEMPOOL_BLOCK_T, MEMPOOL_PAYLOAD_NUM> mMemPoolPayload;
YuuichiAkagawa 44:9d901fec86b8 47 /** MemoryPool for UART receive */
YuuichiAkagawa 44:9d901fec86b8 48 MemoryPool<tagMEMPOOL_BLOCK_T, MEMPOOL_UART_RECV_NUM> mMemPoolUartRecv;
YuuichiAkagawa 44:9d901fec86b8 49 #else
kishino 29:6a0ba999597d 50 unsigned char gUART_TEMP_BUF[UART_RECVBUF_SIZE] __attribute__((section("AHBSRAM1")));
kishino 29:6a0ba999597d 51 unsigned char gUART_COMMAND_BUF[UART_REQUEST_PAYLOAD_MAX] __attribute__((section("AHBSRAM1")));
kishino 29:6a0ba999597d 52 /** MemoryPool for payload of UART response */
kishino 43:d80bbb12ffe6 53 //MemoryPool<tagMEMPOOL_BLOCK_T, MEMPOOL_PAYLOAD_NUM> mMemPoolPayload __attribute__((section("AHBSRAM1")));
kishino 43:d80bbb12ffe6 54 MemoryPool<tagMEMPOOL_BLOCK_T, MEMPOOL_PAYLOAD_NUM> mMemPoolPayload __attribute__((section("AHBSRAM0")));
kishino 29:6a0ba999597d 55 /** MemoryPool for UART receive */
kishino 43:d80bbb12ffe6 56 MemoryPool<tagMEMPOOL_BLOCK_T, MEMPOOL_UART_RECV_NUM> mMemPoolUartRecv __attribute__((section("AHBSRAM0")));
YuuichiAkagawa 44:9d901fec86b8 57 #endif
kishino 35:e4e7f86fd975 58 Queue<tagMEMPOOL_BLOCK_T, MEMPOOL_UART_RECV_NUM> mUartRecvQueue;
kishino 29:6a0ba999597d 59
kishino 29:6a0ba999597d 60 tagMEMPOOL_BLOCK_T *gUART_RCVBUF_p;
kishino 43:d80bbb12ffe6 61 int gUART_RECV_COUNT = 0;
kishino 43:d80bbb12ffe6 62
kishino 20:dd736d328de6 63 C_SNIC_Core *C_SNIC_Core::mInstance_p = NULL;
kishino 20:dd736d328de6 64
kishino 20:dd736d328de6 65 C_SNIC_Core *C_SNIC_Core::getInstance()
kishino 20:dd736d328de6 66 {
kishino 20:dd736d328de6 67 if( mInstance_p == NULL )
kishino 20:dd736d328de6 68 {
kishino 20:dd736d328de6 69 mInstance_p = new C_SNIC_Core();
kishino 20:dd736d328de6 70 }
kishino 20:dd736d328de6 71 return mInstance_p;
kishino 20:dd736d328de6 72 }
kishino 20:dd736d328de6 73
kishino 20:dd736d328de6 74 C_SNIC_Core::C_SNIC_Core()
kishino 20:dd736d328de6 75 {
kishino 20:dd736d328de6 76 int i;
kishino 20:dd736d328de6 77
kishino 20:dd736d328de6 78 mUartCommand_p = new C_SNIC_UartCommandManager();
kishino 20:dd736d328de6 79 for( i = 0; i < MAX_SOCKET_ID+1; i++ )
kishino 20:dd736d328de6 80 {
kishino 20:dd736d328de6 81 mConnectInfo[i].recvbuf_p = NULL;
kishino 20:dd736d328de6 82 mConnectInfo[i].is_connected = false;
kishino 43:d80bbb12ffe6 83 mConnectInfo[i].is_receive_complete = true;
kishino 33:33f1bc919486 84
kishino 33:33f1bc919486 85 mUdpRecvInfo[i].recvbuf_p = NULL;
kishino 33:33f1bc919486 86 mUdpRecvInfo[i].is_received = false;
kishino 20:dd736d328de6 87 }
kishino 20:dd736d328de6 88
kishino 29:6a0ba999597d 89 mUartRecvThread_p = NULL;
kishino 29:6a0ba999597d 90 mUartRecvDispatchThread_p = NULL;
kishino 20:dd736d328de6 91 }
kishino 20:dd736d328de6 92
kishino 26:f2e1030964e4 93 C_SNIC_Core::~C_SNIC_Core()
kishino 26:f2e1030964e4 94 {
kishino 26:f2e1030964e4 95 }
kishino 26:f2e1030964e4 96
kishino 29:6a0ba999597d 97 int C_SNIC_Core::resetModule( PinName reset )
kishino 29:6a0ba999597d 98 {
kishino 29:6a0ba999597d 99 DigitalOut reset_pin( reset );
kishino 29:6a0ba999597d 100
kishino 29:6a0ba999597d 101 reset_pin = 0;
kishino 43:d80bbb12ffe6 102 wait(0.3);
kishino 29:6a0ba999597d 103 reset_pin = 1;
kishino 43:d80bbb12ffe6 104 wait(0.3);
kishino 29:6a0ba999597d 105
kishino 29:6a0ba999597d 106 return 0;
kishino 29:6a0ba999597d 107 }
kishino 29:6a0ba999597d 108
kishino 20:dd736d328de6 109 int C_SNIC_Core::initUart(PinName tx, PinName rx, int baud)
kishino 20:dd736d328de6 110 {
kishino 38:f13e4e563d65 111 mUartRequestSeq = 0;
kishino 20:dd736d328de6 112
kishino 20:dd736d328de6 113 mUart_p = new RawSerial( tx, rx );
kishino 20:dd736d328de6 114 mUart_p->baud( baud );
kishino 20:dd736d328de6 115 mUart_p->format(8, SerialBase::None, 1);
kishino 29:6a0ba999597d 116
kishino 20:dd736d328de6 117 // Initialize uart
kishino 38:f13e4e563d65 118 gUART_RCVBUF_p = NULL;
kishino 20:dd736d328de6 119
kishino 35:e4e7f86fd975 120 mUart_p->attach( C_SNIC_Core::uartRecvCallback );
kishino 29:6a0ba999597d 121 // Create UART recv dispatch thread
kishino 29:6a0ba999597d 122 mUartRecvDispatchThread_p = new Thread( C_SNIC_Core::uartRecvDispatchThread, NULL, osPriorityNormal, UART_THREAD_STACK_SIZE);
kishino 29:6a0ba999597d 123 if( mUartRecvDispatchThread_p == NULL )
kishino 20:dd736d328de6 124 {
kishino 40:b6b10c22a121 125 DEBUG_PRINT("[C_SNIC_Core::initUart] thread create failed\r\n");
kishino 20:dd736d328de6 126 return -1;
kishino 20:dd736d328de6 127 }
kishino 20:dd736d328de6 128
kishino 20:dd736d328de6 129 return 0;
kishino 20:dd736d328de6 130 }
kishino 38:f13e4e563d65 131 unsigned int C_SNIC_Core::preparationSendCommand( unsigned char cmd_id, unsigned char cmd_sid
kishino 20:dd736d328de6 132 , unsigned char *req_buf_p, unsigned int req_buf_len
kishino 20:dd736d328de6 133 , unsigned char *response_buf_p, unsigned char *command_p )
kishino 20:dd736d328de6 134 {
kishino 38:f13e4e563d65 135 unsigned int command_len = 0;
kishino 20:dd736d328de6 136
kishino 20:dd736d328de6 137 // Make all command request
kishino 36:f33fcf5975ab 138 command_len = C_SNIC_UartMsgUtil::makeRequest( cmd_id, req_buf_p, req_buf_len, command_p );
kishino 20:dd736d328de6 139
kishino 20:dd736d328de6 140 // Set data for response
kishino 20:dd736d328de6 141 mUartCommand_p->setCommandID( cmd_id );
kishino 20:dd736d328de6 142 mUartCommand_p->setCommandSID( cmd_sid | 0x80 );
kishino 20:dd736d328de6 143 mUartCommand_p->setResponseBuf( response_buf_p );
kishino 20:dd736d328de6 144
kishino 20:dd736d328de6 145 return command_len;
kishino 20:dd736d328de6 146 }
kishino 20:dd736d328de6 147
kishino 20:dd736d328de6 148 int C_SNIC_Core::sendUart( unsigned int len, unsigned char *data )
kishino 20:dd736d328de6 149 {
kishino 20:dd736d328de6 150 int ret = 0;
kishino 20:dd736d328de6 151 mUartMutex.lock();
kishino 20:dd736d328de6 152 for( int i = 0; i < len; i++ )
kishino 20:dd736d328de6 153 {
kishino 20:dd736d328de6 154 // Write to UART
kishino 20:dd736d328de6 155 ret = mUart_p->putc( data[i] );
kishino 20:dd736d328de6 156 if( ret == -1 )
kishino 20:dd736d328de6 157 {
kishino 20:dd736d328de6 158 break;
kishino 20:dd736d328de6 159 }
kishino 20:dd736d328de6 160 }
kishino 20:dd736d328de6 161 mUartMutex.unlock();
kishino 36:f33fcf5975ab 162
kishino 20:dd736d328de6 163 return ret;
kishino 20:dd736d328de6 164 }
kishino 20:dd736d328de6 165
kishino 29:6a0ba999597d 166 tagMEMPOOL_BLOCK_T *C_SNIC_Core::allocCmdBuf()
kishino 20:dd736d328de6 167 {
kishino 20:dd736d328de6 168 // Get buffer from MemoryPool
kishino 20:dd736d328de6 169 return mMemPoolPayload.alloc();
kishino 20:dd736d328de6 170 }
kishino 20:dd736d328de6 171
kishino 20:dd736d328de6 172 void C_SNIC_Core::freeCmdBuf( tagMEMPOOL_BLOCK_T *buf_p )
kishino 20:dd736d328de6 173 {
kishino 20:dd736d328de6 174 mMemPoolPayload.free( buf_p );
kishino 20:dd736d328de6 175 }
kishino 20:dd736d328de6 176
kishino 29:6a0ba999597d 177 tagMEMPOOL_BLOCK_T *C_SNIC_Core::allocUartRcvBuf()
kishino 29:6a0ba999597d 178 {
kishino 29:6a0ba999597d 179 // Get buffer from MemoryPool
kishino 29:6a0ba999597d 180 return mMemPoolUartRecv.alloc();
kishino 29:6a0ba999597d 181 }
kishino 29:6a0ba999597d 182
kishino 29:6a0ba999597d 183 void C_SNIC_Core::freeUartRecvBuf( tagMEMPOOL_BLOCK_T *buf_p )
kishino 29:6a0ba999597d 184 {
kishino 29:6a0ba999597d 185 mMemPoolUartRecv.free( buf_p );
kishino 29:6a0ba999597d 186 }
kishino 29:6a0ba999597d 187
kishino 22:a9ec0cad4f84 188 C_SNIC_Core::tagCONNECT_INFO_T *C_SNIC_Core::getConnectInfo( int socket_id )
kishino 20:dd736d328de6 189 {
kishino 20:dd736d328de6 190 if( (socket_id < 0) || (socket_id > MAX_SOCKET_ID) )
kishino 20:dd736d328de6 191 {
kishino 20:dd736d328de6 192 return NULL;
kishino 20:dd736d328de6 193 }
kishino 20:dd736d328de6 194 return &mConnectInfo[socket_id];
kishino 20:dd736d328de6 195 }
kishino 20:dd736d328de6 196
kishino 33:33f1bc919486 197 C_SNIC_Core::tagUDP_RECVINFO_T *C_SNIC_Core::getUdpRecvInfo( int socket_id )
kishino 33:33f1bc919486 198 {
kishino 33:33f1bc919486 199 if( (socket_id < 0) || (socket_id > MAX_SOCKET_ID) )
kishino 33:33f1bc919486 200 {
kishino 33:33f1bc919486 201 return NULL;
kishino 33:33f1bc919486 202 }
kishino 33:33f1bc919486 203 return &mUdpRecvInfo[socket_id];
kishino 33:33f1bc919486 204 }
kishino 33:33f1bc919486 205
kishino 20:dd736d328de6 206 C_SNIC_UartCommandManager *C_SNIC_Core::getUartCommand()
kishino 20:dd736d328de6 207 {
kishino 20:dd736d328de6 208 return mUartCommand_p;
kishino 20:dd736d328de6 209 }
kishino 20:dd736d328de6 210
kishino 29:6a0ba999597d 211 unsigned char *C_SNIC_Core::getCommandBuf()
kishino 29:6a0ba999597d 212 {
kishino 29:6a0ba999597d 213 return gUART_COMMAND_BUF;
kishino 29:6a0ba999597d 214 }
kishino 20:dd736d328de6 215
kishino 43:d80bbb12ffe6 216 void C_SNIC_Core::lockAPI( void )
kishino 43:d80bbb12ffe6 217 {
kishino 43:d80bbb12ffe6 218 mAPIMutex.lock();
kishino 43:d80bbb12ffe6 219 }
kishino 43:d80bbb12ffe6 220
kishino 43:d80bbb12ffe6 221 void C_SNIC_Core::unlockAPI( void )
kishino 43:d80bbb12ffe6 222 {
kishino 43:d80bbb12ffe6 223 mAPIMutex.unlock();
kishino 43:d80bbb12ffe6 224 }
kishino 43:d80bbb12ffe6 225
kishino 29:6a0ba999597d 226 void C_SNIC_Core::uartRecvCallback( void )
kishino 29:6a0ba999597d 227 {
kishino 20:dd736d328de6 228 C_SNIC_Core *instance_p = C_SNIC_Core::getInstance();
kishino 29:6a0ba999597d 229 if( instance_p != NULL )
kishino 20:dd736d328de6 230 {
kishino 29:6a0ba999597d 231 int recvdata = 0;
kishino 20:dd736d328de6 232
kishino 39:a1233ca02edf 233 // Check received data from UART.
kishino 39:a1233ca02edf 234 while( instance_p->mUart_p->readable() )
kishino 20:dd736d328de6 235 {
kishino 20:dd736d328de6 236 // Receive data from UART.
kishino 20:dd736d328de6 237 recvdata = instance_p->mUart_p->getc();
kishino 20:dd736d328de6 238
kishino 29:6a0ba999597d 239 // Check UART receiving buffer
kishino 29:6a0ba999597d 240 if( gUART_RCVBUF_p != NULL )
kishino 20:dd736d328de6 241 {
kishino 29:6a0ba999597d 242 gUART_RCVBUF_p->buf[ gUART_RCVBUF_p->size ] = (unsigned char)recvdata;
kishino 29:6a0ba999597d 243 gUART_RCVBUF_p->size++;
kishino 29:6a0ba999597d 244
kishino 39:a1233ca02edf 245 if( gUART_RCVBUF_p->size == UART_FIXED_HEADER_SIZE )
kishino 20:dd736d328de6 246 {
kishino 36:f33fcf5975ab 247 // get demand size
kishino 36:f33fcf5975ab 248 unsigned short payload_len = ( ( (gUART_RCVBUF_p->buf[1] & ~0x80) & 0xff) | ( ( (gUART_RCVBUF_p->buf[2] & ~0xC0) << 7) & 0xff80) );
kishino 39:a1233ca02edf 249 gUART_RCVBUF_p->demand_size = payload_len + UART_FIXED_SIZE_IN_FRAME;
kishino 39:a1233ca02edf 250 if( gUART_RCVBUF_p->demand_size > MEMPOOL_BLOCK_SIZE )
kishino 39:a1233ca02edf 251 {
kishino 39:a1233ca02edf 252 gUART_RCVBUF_p->demand_size = MEMPOOL_BLOCK_SIZE;
kishino 39:a1233ca02edf 253 }
kishino 36:f33fcf5975ab 254 }
kishino 36:f33fcf5975ab 255
kishino 36:f33fcf5975ab 256 if( gUART_RCVBUF_p->demand_size > 0 )
kishino 36:f33fcf5975ab 257 {
kishino 36:f33fcf5975ab 258 // Check size of received data.
kishino 36:f33fcf5975ab 259 if( gUART_RCVBUF_p->size >= gUART_RCVBUF_p->demand_size )
kishino 36:f33fcf5975ab 260 {
kishino 36:f33fcf5975ab 261 // Add queue
kishino 36:f33fcf5975ab 262 mUartRecvQueue.put( gUART_RCVBUF_p );
kishino 36:f33fcf5975ab 263
kishino 36:f33fcf5975ab 264 gUART_RCVBUF_p = NULL;
kishino 20:dd736d328de6 265
kishino 43:d80bbb12ffe6 266 if( gUART_RECV_COUNT >= MEMPOOL_UART_RECV_NUM )
kishino 43:d80bbb12ffe6 267 {
kishino 43:d80bbb12ffe6 268 instance_p->mUart_p->attach( NULL );
kishino 43:d80bbb12ffe6 269 }
kishino 36:f33fcf5975ab 270 // set signal for dispatch thread
kishino 36:f33fcf5975ab 271 instance_p->mUartRecvDispatchThread_p->signal_set( UART_DISPATCH_SIGNAL );
kishino 43:d80bbb12ffe6 272 break;
kishino 36:f33fcf5975ab 273 }
kishino 20:dd736d328de6 274 }
kishino 20:dd736d328de6 275 }
kishino 20:dd736d328de6 276 else
kishino 20:dd736d328de6 277 {
kishino 20:dd736d328de6 278 // Check received data is SOM.
kishino 20:dd736d328de6 279 if( recvdata == UART_CMD_SOM )
kishino 20:dd736d328de6 280 {
kishino 29:6a0ba999597d 281 gUART_RCVBUF_p = instance_p->allocUartRcvBuf();
kishino 43:d80bbb12ffe6 282 gUART_RECV_COUNT++;
kishino 29:6a0ba999597d 283 gUART_RCVBUF_p->size = 0;
kishino 36:f33fcf5975ab 284 gUART_RCVBUF_p->demand_size = 0;
kishino 43:d80bbb12ffe6 285
kishino 29:6a0ba999597d 286 // get buffer for Uart receive
kishino 29:6a0ba999597d 287 gUART_RCVBUF_p->buf[ 0 ] = (unsigned char)recvdata;
kishino 29:6a0ba999597d 288
kishino 29:6a0ba999597d 289 gUART_RCVBUF_p->size++;
kishino 20:dd736d328de6 290 }
kishino 20:dd736d328de6 291 }
kishino 20:dd736d328de6 292 }
kishino 20:dd736d328de6 293 }
kishino 20:dd736d328de6 294 }
kishino 20:dd736d328de6 295
kishino 29:6a0ba999597d 296 void C_SNIC_Core::uartRecvDispatchThread (void const *args_p)
kishino 29:6a0ba999597d 297 {
kishino 29:6a0ba999597d 298 C_SNIC_Core *instance_p = C_SNIC_Core::getInstance();
kishino 29:6a0ba999597d 299 C_SNIC_UartCommandManager *uartCmdMgr_p = instance_p->getUartCommand();
kishino 29:6a0ba999597d 300
kishino 29:6a0ba999597d 301 tagMEMPOOL_BLOCK_T *uartRecvBuf_p;
kishino 29:6a0ba999597d 302 osEvent evt;
kishino 29:6a0ba999597d 303
kishino 29:6a0ba999597d 304 for(;;)
kishino 29:6a0ba999597d 305 {
kishino 29:6a0ba999597d 306 // wait
kishino 29:6a0ba999597d 307 Thread::signal_wait( UART_DISPATCH_SIGNAL );
kishino 29:6a0ba999597d 308
kishino 29:6a0ba999597d 309 // Get scanresults from queue
kishino 39:a1233ca02edf 310 evt = mUartRecvQueue.get(UART_RECV_QUEUE_TIMEOUT);
kishino 29:6a0ba999597d 311 if (evt.status == osEventMessage)
kishino 29:6a0ba999597d 312 {
kishino 29:6a0ba999597d 313 do
kishino 29:6a0ba999597d 314 {
kishino 29:6a0ba999597d 315 uartRecvBuf_p = (tagMEMPOOL_BLOCK_T *)evt.value.p;
kishino 29:6a0ba999597d 316
kishino 38:f13e4e563d65 317 #if 0 /* for Debug */
kishino 29:6a0ba999597d 318 {
kishino 29:6a0ba999597d 319 int i;
kishino 29:6a0ba999597d 320 for(i=0;i<uartRecvBuf_p->size;i++)
kishino 29:6a0ba999597d 321 {
kishino 40:b6b10c22a121 322 DEBUG_PRINT("%02x", uartRecvBuf_p->buf[i]);
kishino 29:6a0ba999597d 323 }
kishino 40:b6b10c22a121 324 DEBUG_PRINT("\r\n");
kishino 29:6a0ba999597d 325 }
kishino 32:ae95309643aa 326 #endif
kishino 29:6a0ba999597d 327 unsigned char command_id;
kishino 29:6a0ba999597d 328 // Get payload from received data from UART.
kishino 29:6a0ba999597d 329 int payload_len = C_SNIC_UartMsgUtil::getResponsePayload( uartRecvBuf_p->size, uartRecvBuf_p->buf
kishino 29:6a0ba999597d 330 , &command_id, gUART_TEMP_BUF );
kishino 33:33f1bc919486 331 // Check receive a TCP packet
kishino 29:6a0ba999597d 332 if( (command_id == UART_CMD_ID_SNIC) && (gUART_TEMP_BUF[0] == UART_CMD_SID_SNIC_CONNECTION_RECV_IND) )
kishino 29:6a0ba999597d 333 {
kishino 29:6a0ba999597d 334 // Packet buffering
kishino 29:6a0ba999597d 335 uartCmdMgr_p->bufferredPacket( gUART_TEMP_BUF, payload_len );
kishino 29:6a0ba999597d 336 }
kishino 32:ae95309643aa 337 // Check connected from TCP client
kishino 32:ae95309643aa 338 else if( (command_id == UART_CMD_ID_SNIC) && (gUART_TEMP_BUF[0] == UART_CMD_SID_SNIC_TCP_CLIENT_SOCKET_IND) )
kishino 32:ae95309643aa 339 {
kishino 32:ae95309643aa 340 // Connected from TCP client
kishino 32:ae95309643aa 341 uartCmdMgr_p->connectedTCPClient( gUART_TEMP_BUF, payload_len );
kishino 32:ae95309643aa 342 }
kishino 33:33f1bc919486 343 // Check receive UDP packet
kishino 33:33f1bc919486 344 else if( (command_id == UART_CMD_ID_SNIC) && (gUART_TEMP_BUF[0] == UART_CMD_SID_SNIC_UDP_RECV_IND) )
kishino 33:33f1bc919486 345 {
kishino 33:33f1bc919486 346 // UDP packet buffering
kishino 33:33f1bc919486 347 uartCmdMgr_p->bufferredUDPPacket( gUART_TEMP_BUF, payload_len );
kishino 33:33f1bc919486 348 }
kishino 29:6a0ba999597d 349 // Check scan results indication
kishino 29:6a0ba999597d 350 else if( (command_id == UART_CMD_ID_WIFI) && (gUART_TEMP_BUF[0] == UART_CMD_SID_WIFI_SCAN_RESULT_IND) )
kishino 29:6a0ba999597d 351 {
kishino 29:6a0ba999597d 352 // Scan result indicate
kishino 29:6a0ba999597d 353 uartCmdMgr_p->scanResultIndicate( gUART_TEMP_BUF, payload_len );
kishino 29:6a0ba999597d 354 }
kishino 29:6a0ba999597d 355 // Checks in the command which is waiting.
kishino 29:6a0ba999597d 356 else if( uartCmdMgr_p->isWaitingCommand(command_id, gUART_TEMP_BUF) )
kishino 29:6a0ba999597d 357 {
kishino 29:6a0ba999597d 358 // Get buffer for payload data
kishino 29:6a0ba999597d 359 unsigned char *payload_buf_p = uartCmdMgr_p->getResponseBuf();
kishino 29:6a0ba999597d 360 if( payload_buf_p != NULL )
kishino 29:6a0ba999597d 361 {
kishino 29:6a0ba999597d 362 memcpy( payload_buf_p, gUART_TEMP_BUF, payload_len );
kishino 29:6a0ba999597d 363 uartCmdMgr_p->setResponseBuf( NULL );
kishino 29:6a0ba999597d 364 }
kishino 29:6a0ba999597d 365 // Set status
kishino 29:6a0ba999597d 366 uartCmdMgr_p->setCommandStatus( gUART_TEMP_BUF[2] );
kishino 29:6a0ba999597d 367 // Set signal for command response wait.
kishino 29:6a0ba999597d 368 uartCmdMgr_p->signal();
kishino 29:6a0ba999597d 369 }
kishino 39:a1233ca02edf 370 else
kishino 39:a1233ca02edf 371 {
kishino 43:d80bbb12ffe6 372 //DEBUG_PRINT(" The received data is not expected.\r\n");
kishino 39:a1233ca02edf 373 }
kishino 39:a1233ca02edf 374
kishino 29:6a0ba999597d 375 //
kishino 29:6a0ba999597d 376 instance_p->freeUartRecvBuf( uartRecvBuf_p );
kishino 43:d80bbb12ffe6 377 gUART_RECV_COUNT--;
kishino 43:d80bbb12ffe6 378 if( gUART_RECV_COUNT == (MEMPOOL_UART_RECV_NUM-1) )
kishino 43:d80bbb12ffe6 379 {
kishino 43:d80bbb12ffe6 380 instance_p->mUart_p->attach( C_SNIC_Core::uartRecvCallback ); //debug
kishino 43:d80bbb12ffe6 381 }
kishino 29:6a0ba999597d 382
kishino 29:6a0ba999597d 383 evt = mUartRecvQueue.get(500);
kishino 29:6a0ba999597d 384 } while( evt.status == osEventMessage );
kishino 29:6a0ba999597d 385 }
kishino 29:6a0ba999597d 386 }
kishino 29:6a0ba999597d 387 }