static uint16_t wbsio_get_spibase(uint16_t port)
{
uint8_t id;
uint16_t flashport = 0;
w836xx_ext_enter(port);
id = sio_read(port, 0x20);
if (id != 0xa0) {
msg_perr("\nW83627 not found at 0x%x, id=0x%02x want=0xa0.\n", port, id);
goto done;
}
if (0 == (sio_read(port, 0x24) & 2)) {
msg_perr("\nW83627 found at 0x%x, but SPI pins are not enabled. (CR[0x24] bit 1=0)\n", port);
goto done;
}
sio_write(port, 0x07, 0x06);
if (0 == (sio_read(port, 0x30) & 1)) {
msg_perr("\nW83627 found at 0x%x, but SPI is not enabled. (LDN6[0x30] bit 0=0)\n", port);
goto done;
}
flashport = (sio_read(port, 0x62) << 8) | sio_read(port, 0x63);
done:
w836xx_ext_leave(port);
return flashport;
}
uint16_t probe_id_ite(uint16_t port)
{
uint16_t id;
enter_conf_mode_ite(port);
id = sio_read(port, CHIP_ID_BYTE1_REG) << 8;
id |= sio_read(port, CHIP_ID_BYTE2_REG);
exit_conf_mode_ite(port);
return id;
}
// MT safe
int sio_readexpect(std::string &msg, const char * prefix, int * preflen, int timeout) {
std::deque<std::string> rejected;
// true timeout
int64 stoptime = time64() + timeout*1000;
int rv;
while (stoptime > time64()) {
int delta = (int)( (stoptime - time64()) / 1000 );
rv=sio_read(msg, (delta>0)?delta:0);
if (rv <= 0) break; // error or timeout
rv = sio_matchpref(msg.c_str(), prefix, preflen);
if (rv > 0) break; // found it
rejected.push_back(msg);
//printf("rejected: [%s] (%d)\n", msg.c_str(), rejected.size());
};
// push back the unanswered messages...
std::string tmp;
while (!rejected.empty()) {
tmp = rejected.back();
rejected.pop_back();
postponed.push_front(tmp);
//printf("postponed: [%s] (%d)\n", tmp.c_str(), postponed.size());
};
//printf("MESSAGE [%s] is number %d in list of\n%s\n", msg.c_str(), rv, prefix);
return rv;
};
/* Retrieves the just recorded buffer, if there is one. */
static int
sndio_rec_read(void *buf)
{
struct pollfd pfd;
nfds_t nfds;
int ret, nbytes, offset = 0;
/* make sure counters have been updated */
nfds = sio_pollfd(hdl, &pfd, POLLIN);
poll(&pfd, nfds, 0);
sio_revents(hdl, &pfd);
if (!(sio_revents(hdl, &pfd) & POLLIN))
return 0;
nbytes = sndio_rec_bufsize;
while (nbytes) {
ret = sio_read(hdl, buf + offset, nbytes);
if (sio_eof(hdl))
return 0;
offset += ret;
nbytes -= ret;
}
return 1;
}
/**
* Dedicated thread to read data from the serial port.
*/
static void gprs_thread(void *arg)
{
gprs_t * gprs = (gprs_t *)arg;
LWIP_DEBUGF(GPRS_DEBUG,("gprs: Thread: Started on device %d size %u\n",gprs->device,GPRS_MODEM_BUFFER_SIZE));
for (;;)
{
gprs->recvLen = sio_read(gprs->fd,(u8_t *)gprs->recvBuffer,GPRS_MODEM_BUFFER_SIZE);
if (gprs->recvLen > 0)
{
#if GPRS_SERIAL_STAT
gprs->rcvdBtes += gprs->recvLen;
#endif
if (tcpip_callback(gprs_input_callback,(void *)gprs) != ERR_OK)
{
LWIP_DEBUGF(GPRS_DEBUG,("gprs: Thread tcpip_callback() failed\n"));
}
else
{
sys_sem_wait(&gprs->recvSem);
}
}
}
}
static PaError
BlockingReadStream(PaStream *stream, void *data, unsigned long numFrames)
{
PaSndioStream *s = (PaSndioStream *)stream;
unsigned n, res, todo;
void *buf;
while (numFrames > 0) {
n = s->par.round;
if (n > numFrames)
n = numFrames;
buf = s->rbuf;
todo = n * s->par.rchan * s->par.bps;
while (todo > 0) {
res = sio_read(s->hdl, buf, todo);
if (res == 0)
return paUnanticipatedHostError;
buf = (char *)buf + res;
todo -= res;
}
s->rpos += n;
PaUtil_SetInputFrameCount(&s->bufproc, n);
PaUtil_SetInterleavedInputChannels(&s->bufproc, 0, s->rbuf, s->par.rchan);
res = PaUtil_CopyInput(&s->bufproc, &data, n);
if (res != n) {
DPR("BlockingReadStream: copyInput: %u != %u\n");
return paUnanticipatedHostError;
}
numFrames -= n;
}
return paNoError;
}
static void *
read_thread(void *dp)
{
sndio_in_driver *d = dp;
struct pollfd pfd;
int size, ret, off, nfds;
if (!sio_start(d->hdl)) {
error_error("could not start sndio");
goto done;
}
while (d->read_trun) {
nfds = sio_pollfd(d->hdl, &pfd, POLLIN);
poll(&pfd, nfds, -1);
if (sio_revents(d->hdl, &pfd) & POLLIN) {
size = d->par.rchan * d->par.bps * d->bufsize;
off = 0;
while (size > 0) {
ret = sio_read(d->hdl, d->sndbuf + off, size);
off += ret;
size -= ret;
}
sample_editor_sampled(d->sndbuf, d->bufsize,
d->par.rate, d->mf);
}
}
done:
pthread_exit(NULL);
return NULL;
}
static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
{
SndioData *s = s1->priv_data;
int64_t bdelay, cur_time;
int ret;
if ((ret = av_new_packet(pkt, s->buffer_size)) < 0)
return ret;
ret = sio_read(s->hdl, pkt->data, pkt->size);
if (ret == 0 || sio_eof(s->hdl)) {
av_free_packet(pkt);
return AVERROR_EOF;
}
pkt->size = ret;
s->softpos += ret;
/* compute pts of the start of the packet */
cur_time = av_gettime();
bdelay = ret + s->hwpos - s->softpos;
/* convert to pts */
pkt->pts = cur_time - ((bdelay * 1000000) /
(s->bps * s->channels * s->sample_rate));
return 0;
}
//---------------------------------------------------------------------------
bool __fastcall CSerialPort::ReadData(char *pBuffer,char EndByte)
{
DWORD dwStart=GetTickCount();
char Rx[MAX_BUFFER]={0};
int nIndex=0;
int nRet;
while(1)
{
nRet=sio_read(m_nPortNo,pBuffer,MAX_BUFFER);
if(nRet>0)
{
strncpy(Rx+nIndex,pBuffer,nRet);
nIndex+=nRet;
if(pBuffer[nRet-1]==EndByte)
{
strcpy(pBuffer,Rx);
return true;
}
}
if(nRet<0) return false;
if((GetTickCount()-dwStart)>2000) break;
::Sleep(1);
}
return false;
}
void probe_superio_ite(void)
{
struct superio s = {};
uint16_t ite_ports[] = {ITE_SUPERIO_PORT1, ITE_SUPERIO_PORT2, 0};
uint16_t *i = ite_ports;
s.vendor = SUPERIO_VENDOR_ITE;
for (; *i; i++) {
s.port = *i;
s.model = probe_id_ite(s.port);
switch (s.model >> 8) {
case 0x82:
case 0x86:
case 0x87:
/* FIXME: Print revision for all models? */
msg_pdbg("Found ITE Super I/O, ID 0x%04hx on port "
"0x%x\n", s.model, s.port);
register_superio(s);
break;
case 0x85:
msg_pdbg("Found ITE EC, ID 0x%04hx,"
"Rev 0x%02x on port 0x%x.\n",
s.model,
sio_read(s.port, CHIP_VER_REG),
s.port);
register_superio(s);
break;
}
}
return;
}
/* Core streaming function for this module
* This is what actually produces the data which gets streamed.
*
* returns: >0 Number of bytes read
* 0 Non-fatal error.
* <0 Fatal error.
*/
static int sndio_read(void *self, ref_buffer *rb)
{
int result;
im_sndio_state *s = self;
rb->buf = malloc(BUFSIZE * s->par.bps * s->par.rchan);
if(!rb->buf)
return -1;
result = sio_read(s->hdl, rb->buf, BUFSIZE * s->par.bps * s->par.rchan);
rb->len = result;
rb->aux_data = s->par.rate * s->par.rchan * s->par.bps;
if(s->newtrack)
{
rb->critical = 1;
s->newtrack = 0;
}
if(result == 0)
{
if(sio_eof(s->hdl))
{
LOG_ERROR0("Error reading from audio device");
free(rb->buf);
return -1;
}
}
return rb->len;
}
/**
* Static function for easy use of blockig or non-blocking
* sio_read
*
* @param fd serial device handle
* @param data pointer to data buffer for receiving
* @param len maximum length (in bytes) of data to receive
* @param block if 1, call sio_read; if 0, call sio_tryread
* @return return value of sio_read of sio_tryread
*/
static u32_t
slip_sio_read(sio_fd_t fd, u8_t* data, u32_t len, u8_t block)
{
if (block) {
return sio_read(fd, data, len);
} else {
return sio_tryread(fd, data, len);
}
}
static int it85xx_spi_common_init(struct superio s)
{
chipaddr base;
msg_pdbg("%s():%d superio.vendor=0x%02x\n", __func__, __LINE__,
s.vendor);
if (register_shutdown(it85xx_shutdown, NULL))
return 1;
#ifdef LPC_IO
/* Get LPCPNP of SHM. That's big-endian */
sio_write(s.port, LDNSEL, 0x0F); /* Set LDN to SHM (0x0F) */
shm_io_base = (sio_read(s.port, SHM_IO_BAR0) << 8) +
sio_read(s.port, SHM_IO_BAR1);
msg_pdbg("%s():%d shm_io_base=0x%04x\n", __func__, __LINE__,
shm_io_base);
/* These pointers are not used directly. They will be send to EC's
* register for indirect access. */
base = 0xFFFFF000;
ce_high = ((unsigned char*)base) + 0xE00; /* 0xFFFFFE00 */
ce_low = ((unsigned char*)base) + 0xD00; /* 0xFFFFFD00 */
/* pre-set indirect-access registers since in most of cases they are
* 0xFFFFxx00. */
INDIRECT_A0(shm_io_base, base & 0xFF);
INDIRECT_A2(shm_io_base, (base >> 16) & 0xFF);
INDIRECT_A3(shm_io_base, (base >> 24));
#endif
#ifdef LPC_MEMORY
base = (chipaddr)programmer_map_flash_region("it85 communication",
0xFFFFF000, 0x1000);
msg_pdbg("%s():%d base=0x%08x\n", __func__, __LINE__,
(unsigned int)base);
ce_high = (unsigned char*)(base + 0xE00); /* 0xFFFFFE00 */
ce_low = (unsigned char*)(base + 0xD00); /* 0xFFFFFD00 */
#endif
return 0;
}
int sio_read(char * buff, int maxbuff, int timeout, int pollfd) {
std::string data;
int rv= sio_read(data, timeout, pollfd);
if (rv > 0) {
if (rv > (maxbuff-4)) rv = maxbuff-4;
memcpy(buff, data.data(), rv);
buff[rv]=0;
} else {
buff[0] = 0;
};
return rv;
};
/**
* The SLIP input thread.
*
* Feed the IP layer with incoming packets
*
* @param nf the lwip network interface structure for this slipif
*/
static void
slipif_loop_thread(void *nf)
{
u8_t c;
struct netif *netif = (struct netif *)nf;
struct slipif_priv *priv = (struct slipif_priv *)netif->state;
while (1) {
if (sio_read(priv->sd, &c, 1) > 0) {
slipif_rxbyte_input(netif, c);
}
}
}
unsigned int
siofile_read(struct file *file, unsigned char *data, unsigned int count)
{
struct siofile *f = (struct siofile *)file;
unsigned int n;
#ifdef DEBUG
if (f->rtickets == 0) {
file_dbg(&f->file);
dbg_puts(": called with no read tickets\n");
}
#endif
if (count > f->rtickets)
count = f->rtickets;
n = f->started ? sio_read(f->hdl, data, count) : 0;
if (n == 0) {
f->file.state &= ~FILE_ROK;
if (sio_eof(f->hdl)) {
#ifdef DEBUG
dbg_puts(f->file.name);
dbg_puts(": failed to read from device\n");
#endif
file_eof(&f->file);
} else {
#ifdef DEBUG
if (debug_level >= 4) {
file_dbg(&f->file);
dbg_puts(": reading blocked\n");
}
#endif
}
return 0;
} else {
f->rtickets -= n;
if (f->rtickets == 0) {
f->file.state &= ~FILE_ROK;
#ifdef DEBUG
if (debug_level >= 4) {
file_dbg(&f->file);
dbg_puts(": read tickets exhausted\n");
}
#endif
}
}
return n;
}
u8_t
sio_recv( sio_fd_t fd )
{
u8_t data;
serdev_t *dev = fd;
if( dev->ready )
{
while( sio_read( fd, &data, 1 ) != 1 );
}
else
{
LWIP_ASSERT( "sio_recv: dev->ready != 0 ", dev->ready != 0 );
data = '\0';
}
return data;
}
/*
=======================================
RS232 接收线程
=======================================
*/
CR_API uint_t STDCALL
qst_rs232_main (
__CR_IN__ void_t* parm
)
{
sQstComm* ctx = (sQstComm*)parm;
/* 工作循环 */
while (!ctx->comm.quit)
{
uint_t back;
ansi_t cha, *data;
/* 一个个字节读 */
back = sio_read(ctx->comm.obj.port, &cha, 1);
if (back == 1) {
if (CR_VCALL(ctx->bufs)->putb_no(ctx->bufs, cha))
ctx->size += 1;
continue;
}
if (back != 0) {
thread_sleep(20);
continue;
}
/* 文本模式处理 */
if (ctx->size == 0)
continue;
data = (ansi_t*)(CR_VCALL(ctx->bufs)->flush(ctx->bufs));
if (ctx->comm.text)
ctx->size = qst_txt_mode(data, ctx->size);
/* 渲染读到的内容 */
_ENTER_COM_SINGLE_
ctx->comm.render(parm, data, ctx->size);
_LEAVE_COM_SINGLE_
/* 缓存指针复位 */
CR_VCALL(ctx->bufs)->reput(ctx->bufs, 0);
ctx->size = 0;
}
/* 退出时关闭串口 */
sio_close(ctx->comm.obj.port);
return (QST_OKAY);
}
static void *read_thread(void *arg)
{
struct ausrc_st *st = arg;
if (!sio_start(st->hdl)) {
warning("sndio: could not start record\n");
goto out;
}
while (st->run) {
size_t n = sio_read(st->hdl, st->sampv, st->sampc*2);
st->rh(st->sampv, n/2, st->arg);
}
out:
return NULL;
}
/***************************************************************
【函数功能】： 报文接收回调函数
【输 入】： 回传的串口号
【输 出】： 无
【全局变量】： g_pGyro
【说 明】： sio_read得到的可能是一个完整报文，可能是一半报文，
也可能是单个字节。len返回实际读取的字节数量。
！！！只有RecvCall这个线程，不再需要Mutex互斥量！！！
***************************************************************/
VOID CALLBACK CGyro::RecvCall(int port)
{
if (port != g_pGyro->m_iPort)
return;
int len = sio_read(port, g_pGyro->m_pRecvBuf, 20);
if (len == 0)
return;
/**********************************************/
//int err = g_pGyro->RecvProcess(len);
//if (err == -1) // 报文长度不对，入接收队列了，试图处理接收队列
//{
// err = g_pGyro->RecvQueueProcess();
//}
g_pGyro->m_pRecvQueue->QueueNWrite(g_pGyro->m_pRecvBuf, len);
g_pGyro->RecvQueueProcess();
/**********************************************/
}
static void
pppos_rx_thread(void *arg)
{
u32_t len;
u8_t buffer[128];
LWIP_UNUSED_ARG(arg);
/* Please read the "PPPoS input path" chapter in the PPP documentation. */
while (1) {
len = sio_read(ppp_sio, buffer, sizeof(buffer));
if (len > 0) {
/* Pass received raw characters from PPPoS to be decoded through lwIP
* TCPIP thread using the TCPIP API. This is thread safe in all cases
* but you should avoid passing data byte after byte. */
pppos_input_tcpip(ppp, buffer, len);
}
}
}
/***************************************************************
【函数功能】： 报文接收的回调函数
【输 入】： 回传的串口号
【输 出】： 无
【全局变量】： g_pSensor
【说 明】： sio_read得到的可能是一个完整报文，可能是一半报文，
也可能是单个字节。len返回实际读取的字节数量。
！！！接收回调线程 和 定时发送的回调线程 用m_hMutex做互斥！！！
***************************************************************/
VOID CALLBACK CSensor::RecvCall(int port)
{
if (port != g_pSensor->m_iPort)
return;
int len = sio_read(port,g_pSensor->m_pRecvBuf, MAX_SENSOR_BUF_SIZE);
if(len == 0)
return;
/**********************************************/
WaitForSingleObject(g_pSensor->m_hMutex,1000);
// 将报文写入接收队列，长度len可能是1或半个报文或整个报文长度
g_pSensor->m_pRecvQueue->QueueNWrite(g_pSensor->m_pRecvBuf, len);
int err = g_pSensor->RecvQueueProcess(); // 在队列中处理
if (err != -1) // 接收到一个完整报文，可能正确或错误
{
g_pSensor->m_sCmd.stat = STAT_SENSOR_R2T;
}
else // 等待下一个报文，或超时处理
{}
ReleaseMutex(g_pSensor->m_hMutex);
/**********************************************/
}
/**
* Waits for an response from the modem. This function returns:
* -1: when no more data could be read from the serial (polling)
* CHAT_ERR_OK: when the correct response was received
* CHAT_ERR_ABORT: when an abort response was received
* CHAT_ERR_TIMEOUT: when a timeout occured
* @param chat Chat
* @param item Item to wait for
* @return See above.
*/
static int chat_wait(struct chat *chat, const struct chat_item *item)
{
int count;
const struct chat_item *abort;
while (chat->recvd < BUFSIZE) {
/* Receive data from serial */
if ((count = sio_read(chat->sd, (u8_t *) &chat->buf[chat->recvd],
BUFSIZE - chat->recvd)) < 1)
break;
chat->recvd += count;
chat->buf[chat->recvd] = '\0';
/* Check abort strings */
for (abort = chat->items; abort->cmd != CHAT_LAST; abort++) {
if (abort->cmd != CHAT_ABORT)
continue;
if (strstr(chat->buf, abort->arg)) {
LWIP_DEBUGF(PPP_DEBUG, ("chat_wait: ABORT '%s'\n", abort->arg));
return CHAT_ERR_ABORT;
}
}
/* Check wait string */
if (strstr(chat->buf, item->arg)) {
LWIP_DEBUGF(PPP_DEBUG, ("chat_wait: SUCCESS\n"));
return CHAT_ERR_OK;
}
}
/* Check for timeout */
if (chat->timeleft == 0) {
LWIP_DEBUGF(PPP_DEBUG, ("chat_wait: TIMEOUT\n"));
return CHAT_ERR_TIMEOUT;
}
return -1;
}
static void *
sndio_mainloop(void *arg)
{
#define MAXFDS 8
struct pollfd pfds[MAXFDS];
cubeb_stream *s = arg;
int n, eof = 0, prime, nfds, events, revents, state = CUBEB_STATE_STARTED;
size_t pstart = 0, pend = 0, rstart = 0, rend = 0;
long nfr;
DPR("sndio_mainloop()\n");
s->state_cb(s, s->arg, CUBEB_STATE_STARTED);
pthread_mutex_lock(&s->mtx);
if (!sio_start(s->hdl)) {
pthread_mutex_unlock(&s->mtx);
return NULL;
}
DPR("sndio_mainloop(), started\n");
if (s->mode & SIO_PLAY) {
pstart = pend = s->nfr * s->pbpf;
prime = s->nblks;
if (s->mode & SIO_REC) {
memset(s->rbuf, 0, s->nfr * s->rbpf);
rstart = rend = s->nfr * s->rbpf;
}
} else {
prime = 0;
rstart = 0;
rend = s->nfr * s->rbpf;
}
for (;;) {
if (!s->active) {
DPR("sndio_mainloop() stopped\n");
state = CUBEB_STATE_STOPPED;
break;
}
/* do we have a complete block? */
if ((!(s->mode & SIO_PLAY) || pstart == pend) &&
(!(s->mode & SIO_REC) || rstart == rend)) {
if (eof) {
DPR("sndio_mainloop() drained\n");
state = CUBEB_STATE_DRAINED;
break;
}
if ((s->mode & SIO_REC) && s->conv)
s16_to_float(s->rbuf, s->nfr * s->rchan);
/* invoke call-back, it returns less that s->nfr if done */
pthread_mutex_unlock(&s->mtx);
nfr = s->data_cb(s, s->arg, s->rbuf, s->pbuf, s->nfr);
pthread_mutex_lock(&s->mtx);
if (nfr < 0) {
DPR("sndio_mainloop() cb err\n");
state = CUBEB_STATE_ERROR;
break;
}
s->swpos += nfr;
/* was this last call-back invocation (aka end-of-stream) ? */
if (nfr < s->nfr) {
if (!(s->mode & SIO_PLAY) || nfr == 0) {
state = CUBEB_STATE_DRAINED;
break;
}
/* need to write (aka drain) the partial play block we got */
pend = nfr * s->pbpf;
eof = 1;
}
if (prime > 0)
prime--;
if ((s->mode & SIO_PLAY) && s->conv)
float_to_s16(s->pbuf, nfr * s->pchan);
if (s->mode & SIO_REC)
rstart = 0;
if (s->mode & SIO_PLAY)
pstart = 0;
}
events = 0;
if ((s->mode & SIO_REC) && rstart < rend && prime == 0)
events |= POLLIN;
if ((s->mode & SIO_PLAY) && pstart < pend)
events |= POLLOUT;
nfds = sio_pollfd(s->hdl, pfds, events);
if (nfds > 0) {
pthread_mutex_unlock(&s->mtx);
n = poll(pfds, nfds, -1);
pthread_mutex_lock(&s->mtx);
if (n < 0)
continue;
}
revents = sio_revents(s->hdl, pfds);
if (revents & POLLHUP) {
state = CUBEB_STATE_ERROR;
break;
}
if (revents & POLLOUT) {
n = sio_write(s->hdl, s->pbuf + pstart, pend - pstart);
if (n == 0 && sio_eof(s->hdl)) {
DPR("sndio_mainloop() werr\n");
state = CUBEB_STATE_ERROR;
break;
}
pstart += n;
}
if (revents & POLLIN) {
n = sio_read(s->hdl, s->rbuf + rstart, rend - rstart);
if (n == 0 && sio_eof(s->hdl)) {
DPR("sndio_mainloop() rerr\n");
state = CUBEB_STATE_ERROR;
break;
}
rstart += n;
}
/* skip rec block, if not recording (yet) */
if (prime > 0 && (s->mode & SIO_REC))
rstart = rend;
}
sio_stop(s->hdl);
s->hwpos = s->swpos;
pthread_mutex_unlock(&s->mtx);
s->state_cb(s, s->arg, state);
return NULL;
}
/* This is somewhat different to other ports: we have a main loop here:
* a dedicated task that waits for packets to arrive. This would normally be
* done from interrupt context with embedded hardware, but we don't get an
* interrupt in windows for that :-) */
void main_loop()
{
#if !NO_SYS
err_t err;
sys_sem_t init_sem;
#endif /* NO_SYS */
#if PPP_SUPPORT
#if !USE_ETHERNET
int count;
u8_t rxbuf[1024];
#endif
volatile int callClosePpp = 0;
#endif /* PPP_SUPPORT */
/* initialize lwIP stack, network interfaces and applications */
#if NO_SYS
lwip_init();
test_init(NULL);
#else /* NO_SYS */
err = sys_sem_new(&init_sem, 0);
tcpip_init(test_init, &init_sem);
/* we have to wait for initialization to finish before
* calling update_adapter()! */
sys_sem_wait(&init_sem);
sys_sem_free(&init_sem);
#endif /* NO_SYS */
/* MAIN LOOP for driver update (and timers if NO_SYS) */
while (!_kbhit()) {
#if NO_SYS
/* handle timers (already done in tcpip.c when NO_SYS=0) */
sys_check_timeouts();
#endif /* NO_SYS */
#if USE_ETHERNET
#if !PCAPIF_RX_USE_THREAD
/* check for packets and link status*/
pcapif_poll(&netif);
/* When pcapif_poll comes back, there are not packets, so sleep to
prevent 100% CPU load. Don't do this in an embedded system since it
increases latency! */
sys_msleep(1);
#else /* !PCAPIF_RX_USE_THREAD */
sys_msleep(50);
#endif /* !PCAPIF_RX_USE_THREAD */
#else /* USE_ETHERNET */
#if 0 /* set this to 1 if PPP_INPROC_OWNTHREAD==0 or not defined (see ppp.c) */
/* try to read characters from serial line and pass them to PPPoS */
count = sio_read(ppp_sio, (u8_t*)rxbuf, 1024);
if(count > 0) {
pppos_input(ppp_desc, rxbuf, count);
} else
#endif
{
/* nothing received, give other tasks a chance to run */
sys_msleep(1);
}
#endif /* USE_ETHERNET */
#if !LWIP_NETIF_LOOPBACK_MULTITHREADING
/* check for loopback packets on all netifs */
netif_poll_all();
#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
#if PPP_SUPPORT
{
int do_hup = 0;
if(do_hup) {
pppSigHUP(ppp_desc);
do_hup = 0;
}
}
if(callClosePpp && (ppp_desc >= 0)) {
/* make sure to disconnect PPP before stopping the program... */
callClosePpp = 0;
#if NO_SYS
pppClose(ppp_desc);
#else
tcpip_callback_with_block(pppCloseCallback, (void*)ppp_desc, 0);
#endif
ppp_desc = -1;
}
#endif /* PPP_SUPPORT */
}
#if PPP_SUPPORT
if(ppp_desc >= 0) {
u32_t started;
printf("Closing PPP connection...\n");
/* make sure to disconnect PPP before stopping the program... */
#if NO_SYS
pppClose(ppp_desc);
#else
tcpip_callback_with_block(pppCloseCallback, (void*)ppp_desc, 0);
#endif
ppp_desc = -1;
/* Wait for some time to let PPP finish... */
started = sys_now();
do
{
#if USE_ETHERNET && !PCAPIF_RX_USE_THREAD
pcapif_poll(&netif);
#else /* USE_ETHERNET && !PCAPIF_RX_USE_THREAD */
sys_msleep(50);
#endif /* USE_ETHERNET && !PCAPIF_RX_USE_THREAD */
/* @todo: need a better check here: only wait until PPP is down */
} while(sys_now() - started < 5000);
}
#endif /* PPP_SUPPORT */
#if USE_ETHERNET
/* release the pcap library... */
pcapif_shutdown(&netif);
#endif /* USE_ETHERNET */
}
int
sio_getc(struct siobuf *sio)
{
char ch;
return sio_read(sio, &ch, 1) == 1 ? ch : -1;
}
/* Main routine for the server threads */
thr_startfunc_t serve_pipe(void *data)
{
char sio_buf[BUFSIZ], sock_buf[BUFSIZ];
int fd_max, sio_fd, sock_fd;
int sio_count, sock_count;
int res, port;
fd_set rfds, wfds;
pipe_s *pipe = (pipe_s *)data;
#if defined(__UNIX__)
struct timeval tv = {pipe->timeout, 0};
struct timeval *ptv = &tv;
#elif defined(__WIN32__)
struct timeval tv = {0,10000};
struct timeval *ptv = &tv;
DWORD msecs = 0, timeout = pipe->timeout * 1000;
#endif
port = pipe->sio.info.port;
/* Only proceed if we can lock the mutex */
if (thr_mutex_trylock(pipe->mutex))
{
error("server(%d) - resource is locked", port);
}
else
{
sio_count = 0;
sock_count = 0;
sio_fd = pipe->sio.fd;
sock_fd = pipe->sock.fd;
#if defined(__UNIX__)
fd_max = sio_fd > sock_fd ? sio_fd : sock_fd;
#elif defined(__WIN32__)
fd_max = sock_fd;
msecs = GetTickCount();
#endif
fprintf(stderr, "server(%d) - thread started\n", port);
while (1)
{
FD_ZERO(&rfds);
FD_ZERO(&wfds);
#if defined(__UNIX__)
/* Always ask for read notification to check for EOF */
FD_SET(sio_fd, &rfds);
/* Only ask for write notification if we have something to write */
if (sock_count > 0)
FD_SET(sio_fd, &wfds);
/* Reset timeout values */
tv.tv_sec = pipe->timeout;
tv.tv_usec = 0;
#endif
/* Always ask for read notification to check for EOF */
FD_SET(sock_fd, &rfds);
/* Only ask for write notification if we have something to write */
if (sio_count > 0)
FD_SET(sock_fd, &wfds);
//DBG_MSG2("server(%d) waiting for events", port);
/* Wait for read/write events */
res = select(fd_max + 1, &rfds, &wfds, NULL, ptv);
if (res == -1)
{
perror2("server(%d) - select()", port);
break;
}
#if defined(__UNIX__)
/* Use the select result for timeout detection */
if (res == 0)
{
fprintf(stderr, "server(%d) - timed out\n", port);
break;
}
/* Input from serial port? */
if (FD_ISSET(sio_fd, &rfds))
#elif defined(__WIN32__)
if (1)
#endif
{
/* Only read input if buffer is empty */
if (sio_count == 0)
{
sio_count = sio_read(&pipe->sio, sio_buf, sizeof(sio_buf));
if (sio_count <= 0)
{
if (sio_count == 0)
{
#if defined(__UNIX__)
fprintf(stderr, "server(%d) - EOF from sio\n", port);
break;
#endif
}
else
{
perror2("server(%d) - read(sio)", port);
break;
}
}
else
{
DBG_MSG3("server(%d) - read %d bytes from sio", port, sio_count);
}
}
}
/* Write to socket possible? */
if (FD_ISSET(sock_fd, &wfds))
{
if (sio_count > 0)
{
if ((res = tcp_write(&pipe->sock, sio_buf, sio_count)) < 0)
{
perror2("server(%d) - write(sock)", port);
break;
}
DBG_MSG3("server(%d) - Wrote %d bytes to sock", port, res);
sio_count -= res;
}
}
/* Input from socket? */
if (FD_ISSET(sock_fd, &rfds))
{
/* Only read input if buffer is empty */
if (sock_count == 0)
{
sock_count = tcp_read(&pipe->sock, sock_buf, sizeof(sock_buf));
if (sock_count <= 0)
{
if (sock_count == 0)
{
fprintf(stderr, "server(%d) - EOF from sock\n", port);
break;
}
else
{
perror2("server(%d) - read(sock)", port);
break;
}
}
DBG_MSG3("server(%d) - read %d bytes from sock", port, sock_count);
}
}
#if defined(__UNIX__)
/* Write to serial port possible? */
if (FD_ISSET(sio_fd, &wfds))
#elif defined(__WIN32__)
/* No socket IO performed? */
if ((!FD_ISSET(sock_fd, &rfds)) && (!FD_ISSET(sock_fd, &wfds)))
{
/* Break on a time out */
if (GetTickCount() - msecs > timeout)
{
fprintf(stderr, "server(%d) - timed out\n", port);
break;
}
}
else
{
msecs = GetTickCount();
}
if (1)
#endif
{
if (sock_count > 0)
{
if ((res = sio_write(&pipe->sio, sock_buf, sock_count)) < 0)
{
perror2("server(%d) - write(sio)", port);
break;
}
DBG_MSG3("server(%d) - wrote %d bytes to sio", port, res);
sock_count -= res;
}
}
}
/* Unlock our mutex */
thr_mutex_unlock(pipe->mutex);
}
fprintf(stderr, "server(%d) exiting\n", port);
/* Clean up - don't call pipe_cleanup() as that would nuke our mutex */
sio_cleanup(&pipe->sio);
tcp_cleanup(&pipe->sock);
free(pipe);
thr_exit((thr_exitcode_t)0);
return (thr_exitcode_t)0;
}
//嗅探模式读取应答通讯报文
int CComm_Thread::CommRecv(unsigned char *m_data)
{
COApp * pApp = (COApp *)AfxGetApp();
unsigned char x_ucLength;
unsigned char x_ucDataR[100],x_ucCrc[2];
//数据缓存初始化
x_ucLength = 0;
memset(x_ucCrc,0,sizeof(x_ucCrc));
memset(x_ucDataR,0,sizeof(x_ucDataR));
//开始进行嗅探读取数据
for(int k1=0; k1<10; k1++)
{
if(sio_read(pApp->x_Port,(char *)x_ucDataR,1) > 0)
break;
Sleep(10);
}
//嗅探失败退出
if(k1 >=10)
{
pApp->test.Format("嗅探失败!");
SendMessage(pApp->m_pMainWnd->m_hWnd,WM_MSGCOMMANS,0x10,0x00);
return x_ucLength;
}
//提取应答命令中的命令码，判断数据长度
if(sio_read(pApp->x_Port,(char *)&x_ucDataR[1],1) != 1)
return x_ucLength;
//根据命令码的不同，读取相应的后续内容数据
switch(x_ucDataR[1])
{
case 0x03: //数据提取
//读取数据长度
if(sio_read(pApp->x_Port,(char *)&x_ucDataR[2],1) == 1)
{
//判断数据是否超界
if(x_ucDataR[2] > 100)
{
sio_flush(pApp->x_Port,2);
return 0;
}
//读取后续数据
x_ucLength = x_ucDataR[2]+2;
if(sio_read(pApp->x_Port,(char *)&x_ucDataR[3],x_ucLength) == x_ucLength)
{ //应答长度合法
x_ucLength += 3;
//数据读取完毕，校验数据
CRC16(x_ucDataR,x_ucLength-2,x_ucCrc);
if((x_ucDataR[x_ucLength-2] != x_ucCrc[0]) || (x_ucDataR[x_ucLength-1] != x_ucCrc[1]))
{
pApp->test.Format("校验错误!");
SendMessage(pApp->m_pMainWnd->m_hWnd,WM_MSGCOMMANS,0x10,0x00);
x_ucLength = 0;
}
}
else
{ //应答长度非法
x_ucLength = 0;
}
}
break;
case 0x10: //参数设定
if(sio_read(pApp->x_Port,(char *)&x_ucDataR[2],6) == 6)
{ //长度合法
x_ucLength = 8;
//数据读取完毕，校验数据
CRC16(x_ucDataR,x_ucLength-2,x_ucCrc);
if((x_ucDataR[x_ucLength-2] != x_ucCrc[0]) || (x_ucDataR[x_ucLength-1] != x_ucCrc[1]))
{
pApp->test.Format("校验错误!");
SendMessage(pApp->m_pMainWnd->m_hWnd,WM_MSGCOMMANS,0x10,0x00);
x_ucLength = 0;
}
}
break;
default:
x_ucLength = 0;
break;
}
//拷贝输出应答报文
memcpy(m_data,x_ucDataR,x_ucLength);
//TEST
//pApp->test.Format("收到报文: ← %02X %02X %02X %02X %02X %02X %02X %02X",x_ucDataR[0],x_ucDataR[1],x_ucDataR[2],x_ucDataR[3],x_ucDataR[4],x_ucDataR[5],x_ucDataR[6],x_ucDataR[7]);
//SendMessage(pApp->m_pMainWnd->m_hWnd,WM_MSGCOMMANS,0x17,0x00);
//TEST
//清除缓冲区内的垃圾
sio_flush(pApp->x_Port,2);
return x_ucLength;
}
/*
* I/O loop for callback interface
*/
static void *
sndioThread(void *arg)
{
PaSndioStream *s = (PaSndioStream *)arg;
PaStreamCallbackTimeInfo ti;
unsigned char *data;
unsigned todo, rblksz, wblksz;
int n, result;
rblksz = s->par.round * s->par.rchan * s->par.bps;
wblksz = s->par.round * s->par.pchan * s->par.bps;
DPR("sndioThread: mode = %x, round = %u, rblksz = %u, wblksz = %u\n",
s->mode, s->par.round, rblksz, wblksz);
while (!s->stopped) {
if (s->mode & SIO_REC) {
todo = rblksz;
data = s->rbuf;
while (todo > 0) {
n = sio_read(s->hdl, data, todo);
if (n == 0) {
DPR("sndioThread: sio_read failed\n");
goto failed;
}
todo -= n;
data += n;
}
s->rpos += s->par.round;
ti.inputBufferAdcTime =
(double)s->realpos / s->par.rate;
}
if (s->mode & SIO_PLAY) {
ti.outputBufferDacTime =
(double)(s->realpos + s->par.bufsz) / s->par.rate;
}
ti.currentTime = s->realpos / (double)s->par.rate;
PaUtil_BeginBufferProcessing(&s->bufproc, &ti, 0);
if (s->mode & SIO_PLAY) {
PaUtil_SetOutputFrameCount(&s->bufproc, s->par.round);
PaUtil_SetInterleavedOutputChannels(&s->bufproc,
0, s->wbuf, s->par.pchan);
}
if (s->mode & SIO_REC) {
PaUtil_SetInputFrameCount(&s->bufproc, s->par.round);
PaUtil_SetInterleavedInputChannels(&s->bufproc,
0, s->rbuf, s->par.rchan);
}
result = paContinue;
n = PaUtil_EndBufferProcessing(&s->bufproc, &result);
if (n != s->par.round) {
DPR("sndioThread: %d < %u frames, result = %d\n",
n, s->par.round, result);
}
if (result != paContinue) {
break;
}
if (s->mode & SIO_PLAY) {
n = sio_write(s->hdl, s->wbuf, wblksz);
if (n < wblksz) {
DPR("sndioThread: sio_write failed\n");
goto failed;
}
s->wpos += s->par.round;
}
}
failed:
s->active = 0;
DPR("sndioThread: done\n");
}
int
main(int argc, char **argv) {
int ch;
struct sio_hdl *hdl;
ssize_t n;
/*
* defaults parameters
*/
sio_initpar(&par);
par.sig = 1;
par.bits = 16;
par.rchan = 2;
par.rate = 44100;
while ((ch = getopt(argc, argv, "r:c:e:b:x:")) != -1) {
switch(ch) {
case 'r':
if (sscanf(optarg, "%u", &par.rate) != 1) {
fprintf(stderr, "%s: bad rate\n", optarg);
exit(1);
}
break;
case 'c':
if (sscanf(optarg, "%u", &par.rchan) != 1) {
fprintf(stderr, "%s: channels number\n", optarg);
exit(1);
}
break;
case 'e':
if (!sio_strtoenc(&par, optarg)) {
fprintf(stderr, "%s: unknown encoding\n", optarg);
exit(1);
}
break;
case 'x':
for (par.xrun = 0;; par.xrun++) {
if (par.xrun == sizeof(xstr) / sizeof(char *)) {
fprintf(stderr,
"%s: bad xrun mode\n", optarg);
exit(1);
}
if (strcmp(xstr[par.xrun], optarg) == 0)
break;
}
break;
default:
usage();
exit(1);
break;
}
}
hdl = sio_open(SIO_DEVANY, SIO_REC, 0);
if (hdl == NULL) {
fprintf(stderr, "sio_open() failed\n");
exit(1);
}
sio_onmove(hdl, cb, NULL);
if (!sio_setpar(hdl, &par)) {
fprintf(stderr, "sio_setpar() failed\n");
exit(1);
}
if (!sio_getpar(hdl, &par)) {
fprintf(stderr, "sio_getpar() failed\n");
exit(1);
}
if (!sio_start(hdl)) {
fprintf(stderr, "sio_start() failed\n");
exit(1);
}
for (;;) {
n = sio_read(hdl, buf, BUFSZ);
if (n == 0) {
fprintf(stderr, "sio_write: failed\n");
exit(1);
}
rlat -= n / (int)(par.bps * par.rchan);
if (write(STDOUT_FILENO, buf, n) < 0) {
perror("stdout");
exit(1);
}
}
sio_close(hdl);
return 0;
}
