LPC 2368 Uart IAR EWARM printf scanf 实现2

在前面的实现里是使用中断来收发数据的，感觉代码较长，而且不好理解，效率也比较低，根据printf,scanf来阻塞的特点，改用查看标志位来收发数据，简洁，速度快，可以供大家借鉴。

下面是我写的关健代码。

/*****************************************************************************
*   uart.c:  UART API file for NXP LPC23xx/24xx Family Microprocessors
*
*   Copyright(C) 2006, NXP Semiconductor
*   All rights reserved.
*
*   History
*   2006.07.12  ver 1.00    Prelimnary version, first Release
*
******************************************************************************/
#include "LPC230x.h"                        /* LPC23xx/24xx definitions */
#include "type.h"
#include "target.h"

#include "uart.h"

#include <intrinsics.h>

 

/*****************************************************************************
** Function name:   UART0Handler
**
** Descriptions:    UART0 interrupt handler
**
** parameters:      None
** Returned value:    None
**
*****************************************************************************/

/*****************************************************************************
** Function name:   UARTInit
**
** Descriptions:    Initialize UART0 port, setup pin select,
**            clock, parity, stop bits, FIFO, etc.
**
** parameters:      portNum(0 or 1) and UART baudrate
** Returned value:    true or false, return false only if the
**            interrupt handler can't be installed to the
**            VIC table
**
*****************************************************************************/
DWORD UART0Init(  DWORD baudrate )
{
   DWORD Fdiv;
 
 
    PINSEL0 = 0x00000050;       /* RxD0 and TxD0 */
   
    U0LCR = 0x83;   /* 8 bits, no Parity, 1 Stop bit */
    Fdiv = ( Fpclk / 16 ) / baudrate ;  /*baud rate */
    U0DLM = Fdiv / 256;            
    U0DLL = Fdiv % 256;
    U0LCR = 0x03;   /* DLAB = 0 */
    U0FCR = 0x07;   /* Enable and reset TX and RX FIFO. */
   

   
    U0IER = 0; /* disable all UART0 interrupt */
    return (TRUE);
 
}

void UART0SendChar(char c)
{
  U0FCR = 0x04;   /* Enable and reset TX  FIFO. */
  U0THR=c;
//  U0TER=0x80;
  int temp=0;
  do
  {
    temp=U0LSR;

   
  }while((temp&0x20)==0);
//  U0TER=0x00;
}

int UART0ReceiveChar()
{
  U0FCR = 0x02;   /* Enable and reset RX  FIFO. */
 

  int temp=0;
  do
  {
    temp=U0LSR;
  
  }while((temp&0x01)==0);
  temp=U0RBR;
  return temp;

}

/******************************************************************************
**                            End Of File
******************************************************************************/

write.c

/*******************
 *
 * Copyright 1998-2003 IAR Systems.  All rights reserved.
 *
 * $Revision: 3162 $
 *
 * This is a template implementation of the "__write" function used by
 * the standard library.  Replace it with a system-specific
 * implementation.
 *
 * The "__write" function should output "size" number of bytes from
 * "buffer" in some application-specific way.  It should return the
 * number of characters written, or _LLIO_ERROR on failure.
 *
 * If "buffer" is zero then __write should perform flushing of
 * internal buffers, if any.  In this case "handle" can be -1 to
 * indicate that all handles should be flushed.
 *
 * The template implementation below assumes that the application
 * provides the function "MyLowLevelPutchar".  It should return the
 * character written, or -1 on failure.
 *
 ********************/
#include <yfuns.h>
#include "type.h"
#include "uart.h"

_STD_BEGIN

#pragma module_name = "?__write"

int MyLowLevelPutchar(int x)
{
 
  UART0SendChar(x);
  return 1;
}

/*
 * If the __write implementation uses internal buffering, uncomment
 * the following line to ensure that we are called with "buffer" as 0
 * (i.e. flush) when the application terminates.
 */

size_t __write(int handle, const unsigned char * buffer, size_t size)
{
  /* Remove the #if #endif pair to enable the implementation */

  size_t nChars = 0;

  if (buffer == 0)
  {
    /*
     * This means that we should flush internal buffers.  Since we
     * don't we just return.  (Remember, "handle" == -1 means that all
     * handles should be flushed.)
     */
    return 0;
  }

  /* This template only writes to "standard out" and "standard err",
   * for all other file handles it returns failure. */
  if (handle != _LLIO_STDOUT && handle != _LLIO_STDERR)
  {
    return _LLIO_ERROR;
  }

  for (/* Empty */; size != 0; --size)
  {
    if (MyLowLevelPutchar(*buffer++) < 0)
    {
      return _LLIO_ERROR;
    }

    ++nChars;
  }

  return nChars;

 

  /* Always return error code when implementation is disabled. */
  return _LLIO_ERROR;

 

}

_STD_END

 

 

read.c

 

/*******************
 *
 * Copyright 1998-2003 IAR Systems.  All rights reserved.
 *
 * $Revision: 3161 $
 *
 * This is a template implementation of the "__read" function used by
 * the standard library.  Replace it with a system-specific
 * implementation.
 *
 * The "__read" function reads a number of bytes, at most "size" into
 * the memory area pointed to by "buffer".  It returns the number of
 * bytes read, 0 at the end of the file, or _LLIO_ERROR if failure
 * occurs.
 *
 * The template implementation below assumes that the application
 * provides the function "MyLowLevelGetchar".  It should return a
 * character value, or -1 on failure.
 *
 ********************/

#include <yfuns.h>
#include "type.h"
#include "uart.h"

 

 

_STD_BEGIN

#pragma module_name = "?__read"

 

int MyLowLevelGetchar()
{

  return  UART0ReceiveChar();
 
}
 
 

 

size_t __read(int handle, unsigned char * buffer, size_t size)
{
  /* Remove the #if #endif pair to enable the implementation */
  

  int nChars = 0;

 

 
  /* This template only reads from "standard in", for all other file
   * handles it returns failure. */
  if (handle != _LLIO_STDIN)
  {
    return _LLIO_ERROR;
  }

  for (/* Empty */; size > 0; --size)
  {
    int c = MyLowLevelGetchar();
    if (c < 0)
      break;

    *buffer++ = c;
    ++nChars;
  }

  return nChars;

 

  /* Always return error code when implementation is disabled. */
  return _LLIO_ERROR;

}

_STD_END

 

/*****************************************************************************
 *   irq.c: Interrupt handler C file for NXP LPC230x Family Microprocessors
 *
 *   Copyright(C) 2006, NXP Semiconductor
 *   All rights reserved.
 *
 *   History
 *   2006.07.13  ver 1.00    Prelimnary version, first Release
 *
******************************************************************************/
#include "LPC230x.h"   /* LPC23XX Peripheral Registers */
#include "type.h"
#include "irq.h"

/* Initialize the interrupt controller */
/******************************************************************************
** Function name:  init_VIC
**
** Descriptions:  Initialize VIC interrupt controller.
** parameters:   None
** Returned value:  None
**
******************************************************************************/
void init_VIC(void)
{
    DWORD i = 0;
    DWORD *vect_addr, *vect_cntl;
    
    /* initialize VIC*/
    VICIntEnClr = 0xffffffff;
    VICVectAddr = 0;
    VICIntSelect = 0;

    /* set all the vector and vector control register to 0 */
    for ( i = 0; i < VIC_SIZE; i++ )
    {
  vect_addr = (DWORD *)(VIC_BASE_ADDR + VECT_ADDR_INDEX + i*4);
  vect_cntl = (DWORD *)(VIC_BASE_ADDR + VECT_CNTL_INDEX + i*4);
  *vect_addr = 0x0; 
  *vect_cntl = 0xF;
    }
    return;
}

/******************************************************************************
** Function name:  install_irq
**
** Descriptions:  Install interrupt handler
** parameters:   Interrupt number, interrupt handler address,
**      interrupt priority
** Returned value:  true or false, return false if IntNum is out of range
**
******************************************************************************/
DWORD install_irq( DWORD IntNumber, void *HandlerAddr, DWORD Priority )
{
    DWORD *vect_addr;
    DWORD *vect_cntl;
     
    VICIntEnClr = 1 << IntNumber; /* Disable Interrupt */
    if ( IntNumber >= VIC_SIZE )
    {
  return ( FALSE );
    }
    else
    {
  /* find first un-assigned VIC address for the handler */
  vect_addr = (DWORD *)(VIC_BASE_ADDR + VECT_ADDR_INDEX + IntNumber*4);
  vect_cntl = (DWORD *)(VIC_BASE_ADDR + VECT_CNTL_INDEX + IntNumber*4);
  *vect_addr = (DWORD)HandlerAddr; /* set interrupt vector */
  *vect_cntl = Priority;
  VICIntEnable = 1 << IntNumber; /* Enable Interrupt */
  return( TRUE );
    }
}

/******************************************************************************
**                            End Of File
******************************************************************************/

 

/*****************************************************************************
 *   uarttest.c:  main C entry file for NXP LPC23xx Family Microprocessors
 *
 *   Copyright(C) 2006, NXP Semiconductor
 *   All rights reserved.
 *
 *   History
 *   2006.07.13  ver 1.00    Prelimnary version, first Release
 *
 * Note:
 *  After power-up the controller get clock from internal RC oscillator that
 * is unstable and may fail with J-Link auto detect, therefore adaptive clocking
 * should always be used. The adaptive clock can be select from menu:
 *  Project->Options..., section Debugger->J-Link/J-Trace  JTAG Speed - Adaptive.
 *
 ******************************************************************************/
#include "LPC230x.h"                        /* LPC21xx definitions */
#include "type.h"

#include "target.h"
#include "uart.h"

#include    <stdio.h>

 

/*****************************************************************************
**   Main Function  main()
*****************************************************************************/
int main (void)
{
  TargetResetInit();

  UART0Init( 115200); /* baud rate setting */
 

 
  printf("Hello,World! This demo is modified by hammergo!/n");
  printf("Welcome to arm programming world!/n");

 
  int test=0;
  while(1)
  {
    printf("Please input test value:");
    scanf("%d",&test);
    if(test>0)
    {
      printf("test>0/n");
    }else
    {
      printf("test<=0/n");
    }
  }
 

  return 0;
}

/*****************************************************************************
**                            End Of File
*****************************************************************************/