Exemplo n.º 1
0
void mpipe_setspeed(mpipe_speed speed) {
    ot_u8* baud_data;
    /// You will need to change this baud rate matrix if
    /// you change the bit clock from SMCLK @ 2.496 MHz
    /// Order is [ BR0, BR1, MCTL, ... ]
    /// BR1:0 = Floor(BitCLK/BaudRate)
    /// MCTL  = Round(((BitCLK/BaudRate) - Floor(BitCLK/BaudRate)) * 8) << 1
    static const ot_u8 baud_matrix[] = { 0x04, 0x01, 0x00, 0, \
                                         0x56, 0x00, 0x0A, 0, \
                                         0x2B, 0x00, 0x06, 0, \
                                         0x15, 0x00, 0x0A, 0  };

#   if (MCU_FEATURE(MPIPEDMA) == ENABLED)
        MPIPE_DMAEN(OFF);
#   else
#       error "Mpipe requires a DMA in this implementation"
#   endif

    UART_CLOSE();

    // Parity off, LSB-first, 8N1, async uart
    // Use SMCLK and keep UART reset
    MPIPE_UART->CTL0 = 0;
    MPIPE_UART->CTL1 = 0x81;
    //MPIPE_UART->IE   = 0;
    //MPIPE_UART->IFG  = 0;
    baud_data        = (ot_u8*)&baud_matrix[speed << 2];
    MPIPE_UART->BR0  = *baud_data++;
    MPIPE_UART->BR1  = *baud_data++;
    MPIPE_UART->MCTL = *baud_data;
}
Exemplo n.º 2
0
 /*主函数体*/
int main(int argc, char **argv)
{
	int fd;                            		//文件描述符
	int err;                          	 	//返回调用函数的状态
	int len;                        
	int i;
	char rcv_buf[200];       
	char send_buf[30]="**This's a GPS Locator!**\n";
	int listen_fd,accept_fd;
	struct sockaddr_in     client_addr;
	int n;
//	int nbytes;
	
	if(argc != 3){
		printf("Usage: %s  /dev/ttyS*  s-Send/r-Receive\n",argv[0]);
		return FALSE;
	}
	fd = UART_OPEN(fd,argv[1]);		 //打开串口,返回文件描述符
	
	do{
		err = UART_DEFAULT(fd);
	}while(FALSE == err || FALSE == fd);
	printf("Port is READY!\n");
	
	if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)		//创建socket
  	{
        printf("Socket Error:%s\n\a",strerror(errno));
		return FALSE;
  	}
	bzero(&client_addr,sizeof(struct sockaddr_in));
 	client_addr.sin_family=AF_INET;
 	client_addr.sin_port=htons(MY_PORT);
 	client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
 	n=1;
 	setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int)); //如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间
	if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)	//Bind 
  	{
        printf("Bind Error:%s\n\a",strerror(errno));
		return FALSE;
  	}
	listen(listen_fd,MAX_CONN_NUM);
	
	if(0 == strcmp(argv[2],"s"))
	{
		for(i = 0;i < 50;i++)
		{
			len = UART_SEND(fd,send_buf,30);
			if(len > 0)
				printf("Count.%d :Send data successful!\n",i);
			else
				printf("Count.%d :Send data failed!\n",i);
			sleep(1);
		}        
	}
    else if(0 == strcmp(argv[2],"r"))
	{
		while (1) 					//循环读取数据
		{  
			accept_fd=accept(listen_fd,NULL,NULL);
			if((accept_fd<0)&&(errno==EINTR))
				continue;
			else if(accept_fd<0)
			{
				printf("Accept Error:%s\n\a",strerror(errno));
				continue;
			}			
			if((n=fork())==0)
			{
				/* 子进程处理客户端的连接 */
				unsigned int i;
				for(i=0;i<200;i++){
					len = UART_RECV(fd, rcv_buf,MAX_REC_BUFF);
				if(len > 0)
					write(accept_fd,rcv_buf,len);
				else
					printf("(Time limit)No data now!\n");
				}
				close(accept_fd);
				exit(0);
			}
			else if(n<0)
				printf("Fork Error:%s\n\a",strerror(errno));
		}       
	}
	else 
	{
	   fprintf(stderr,"Unsupported char:'s' or 'r'\n");    
	   return (FALSE); 	
	}
	UART_CLOSE(fd); 
    close(listen_fd);    
	return 0;
}
Exemplo n.º 3
0
void mpipe_isr() {
/// MPipe is state-based.  Depending on the MPipe implementation and the HW
/// implementation of the DMA+UART, state transitions may happen differently.
/// <LI> In typical RX, there is a header detection event that sets-up a second
///      RX process for downloading the rest of the packet.  When the DMA is
///      done, the process completes.  </LI>
/// <LI> For TX, there is a wait-state needed while the HW UART finishes
///      sending the DMA buffered data (two bytes). </LI>
/// <LI> If MPipe does not have HW acks, then software can be used to manage
///      Acks.  In this case, a complete TX process also requires RX'ing an
///      Ack, and a complete RX process requires TX'ing an Ack. </LI>

    switch (mpipe.state) {
        case MPIPE_Idle: //note, case doesn't break!
#           if ((OT_FEATURE(MPIPE_CALLBACKS) == ENABLED) && !defined(EXTF_mpipe_sig_rxdetect))
                mpipe.sig_rxdetect(0);  
#           elif defined(EXTF_mpipe_sig_rxdetect)
                mpipe_sig_rxdetect(0);
#           endif

        case MPIPE_RxHeader: 
        	///@note DMA doesn't seem to need intermediate disabling here
            mpipe.state             = MPIPE_RxPayload;
            mpipe_alp.inq->length   = mpipe_alp.inq->front[2] + 10;
            mpipe_alp.inq->back     = (mpipe_alp.inq->front+6) + mpipe_alp.inq->front[2];
            MPIPE_DMA_RXCONFIG( (mpipe_alp.inq->front+6), \
            		            mpipe_alp.inq->front[2]+4, \
            		            ON);
            return;

        case MPIPE_RxPayload:
#           if (MPIPE_USE_ACKS)
            // ACKs must be used when Broadcast mode is off
            if (mpipe.priority != MPIPE_Broadcast) {
                // 1. On ACKs, txndef() requires caller to choose state 
                // 2. Copy RX'ed sequence number into local sequence number
                // 3. Copy NACK/ACK status to 6th byte in NDEF header
                {
                    ot_u8* scratch;
                    mpipe.state = MPIPE_TxAck_Done; //MPIPE_TxAck_Wait;
                    scratch     = \
                    	mpipe_alp.inq->front[mpipe_alp.inq->length-MPIPE_FOOTERBYTES];
                    mpipe.sequence.ubyte[UPPER] = *scratch++;
                    mpipe.sequence.ubyte[LOWER] = *scratch;
                }
                sub_txack_header();
                if (platform_crc_block(mpipe_alp.inq->front, mpipe_alp.inq->length)) {
                	mpipe.outq->front[5] = 0x7F;
                }
                mpipe_txndef(NULL, False, MPIPE_Ack);
                return;
            }
#           endif
            break;	//goto mpipe_isr_RXDONE;

        //case MPIPE_TxAck_Wait:
            //MPIPE_UART->IE = UCTXIE;
            //return;

        case MPIPE_TxAck_Done:  // TX'ed an ACK
            //MPIPE_UART->IE = 0;
#           if (MPIPE_USE_ACKS)
            if (mpipe_alp.outq->front[5] != 0) { // TX'ed a NACK
                mpipe_rxndef(NULL, False, mpipe.priority);
                mpipe.state = MPIPE_RxHeader;
                return;
            }
#           endif
            break; //goto mpipe_isr_RXDONE;

        //case MPIPE_Tx_Wait:
            //MPIPE_UART->IE = UCTXIE;
            //return;

        case MPIPE_Tx_Done:
            //MPIPE_UART->IE = 0;
#           if (MPIPE_USE_ACKS)
            if (mpipe.priority != MPIPE_Broadcast) {
                mpipe_rxndef(NULL, False, MPIPE_Ack);
                mpipe.state = MPIPE_RxAck;
                return;
            }
            goto mpipe_isr_TXDONE;  // Broadcast, so no ACK
#           endif
            
        case MPIPE_RxAck:
#           if (MPIPE_USE_ACKS)
            if (platform_crc_block(mpipe_alp.inq->front, 10) != 0) { //RX'ed NACK
                mpipe_txndef(NULL, False, mpipe.priority);
                break;
            }
#           endif
            goto mpipe_isr_TXDONE;  //RX'ed ACK
            
       default: mpipe_kill();
                return;
    }
    
    // This is a stack-less RX-Done subroutine
    mpipe_isr_RXDONE:
    UART_CLOSE();
    mpipe.state = MPIPE_Idle;
#   if (MPIPE_USE_ACKS)
        mpipe.priority = MPIPE_Low;
#   endif
#   if ((OT_FEATURE(MPIPE_CALLBACKS) == ENABLED) && !defined(EXTF_mpipe_sig_rxdone))
        mpipe.sig_rxdone(0);
#   elif defined(EXTF_mpipe_sig_rxdone)
        mpipe_sig_rxdone(0);
#   else
        otapi_ndef_proc(NULL);
#   endif
    return;
    
    // This is a stack-less TX-Done subroutine
    mpipe_isr_TXDONE:
    UART_CLOSE();
    mpipe.sequence.ushort++;    //increment sequence on TX Done
    mpipe.state = MPIPE_Idle;
    //if (mpipe_alp.outq->getcursor == mpipe_alp.outq->putcursor) {
    	q_empty(mpipe_alp.outq);
    	mpipe_alp.outq->back -= 10;
    //}
#   if ((OT_FEATURE(MPIPE_CALLBACKS) == ENABLED) && !defined(EXTF_mpipe_sig_txdone))
        mpipe.sig_txdone(0);
#   elif defined(EXTF_mpipe_sig_txdone)
        mpipe_sig_txdone(0);
#	else
        otapi_ndef_idle(NULL);
#   endif

}