【LPC1768抛砖引玉系列】 先传点资料

Excellence

Excellence

//引脚功能
#define                PRIMARYFUNC                0X00        //主要功能(默认是GPIO)
#define                FIRSTFUNC                        0X01        //第一备用功能
#define                SECONDFUNC                        0X02        //第二备用功能
#define                THIRDFUNC                        0X03        //第三备用功能

//外设功率控制寄存器
#define      PCTIM0         (1 << 1)
#define      PCTIM1         (1 << 2)
#define      PCUART0        (1 << 3)
#define      PCUART1        (1 << 4)
#define      PCPWM1         (1 << 6)
#define      PCI2C0         (1 << 7)
#define      PCSPI                 (1 << 8)       
#define      PCRTC                (1 << 9)
#define      PCSSP1         (1 << 10)
#define      PCAD                (1 << 12)
#define      PCCAN1         (1 << 13)
#define      PCCAN2         (1 << 14)
#define      PCGPIO         (1 << 15)
#define      PCRIT                (1 << 16)
#define      PCMC                (1 << 17)
#define      PCQEI                (1 << 18)
#define      PCI2C1         (1 << 19)
#define      PCSSP0         (1 << 21)
#define      PCTIM2                (1 << 22)
#define      PCTIM3         (1 << 23)
#define      PCUART2        (1 << 24)
#define      PCUART3        (1 << 25)
#define      PCI2C2                (1 << 26)
#define      PCI2S                (1 << 27)
#define      PCGPDMA        (1 << 29)
#define      PCENET                (1 << 30)
#define      PCUSB                (1 << 31)

///各个外设中断号
#define                WDT_INT                                0
#define         SWI_INT                                1
#define         ARM_CORE0_INT                2
#define                ARM_CORE1_INT                3
#define                TIMER0_INT                        4
#define         TIMER1_INT                        5
#define         UART0_INT                        6
#define                UART1_INT                        7
#define                PWM0_1_INT                        8
#define         I2C0_INT                        9
#define         SPI0_INT                        10                       
#define                SSP1_INT                        11
#define                PLL_INT                                12
#define         RTC_INT                                13
#define         EINT0_INT                        14
#define         EINT1_INT                        15
#define         EINT2_INT                        16
#define         EINT3_INT                        17
#define                ADC0_INT                        18
#define         I2C1_INT                        19
#define         BOD_INT                                20
#define         EMAC_INT                        21
#define         USB_INT                                22
#define         CAN_INT                                23
#define         MCI_INT                                24
#define         GPDMA_INT                        25
#define         TIMER2_INT                        26
#define         TIMER3_INT                        27
#define         UART2_INT                        28
#define         UART3_INT                        29
#define         I2C2_INT                        30
#define         I2S_INT                                31

Excellence

Excellence

振荡器选择及设置。

在system_LPC17XX.c文件中，寄存器设置如下：

#define CLOCK_SETUP           1
#define SCS_Val               0x00000020
#define CLKSRCSEL_Val         0x00000001
#define PLL0_SETUP            1
#define PLL0CFG_Val           0x00050063
#define PLL1_SETUP            0
#define PLL1CFG_Val           0x00000023
#define CCLKCFG_Val           0x00000003
#define USBCLKCFG_Val         0x00000000
#define PCLKSEL0_Val          0x00000000
#define PCLKSEL1_Val          0x00000000
#define PCONP_Val             0x042887DE
#define CLKOUTCFG_Val         0x00000000

表示选外部晶振，倍频到400MHz,主频为100MHz.

如图：

Excellence

利用SYSTICK实现US级延时。仿照正点原子的STM32程序。

static volatile unsigned long  fac_us=0;//us延时倍乘数
static volatile unsigned long fac_ms=0;//ms延时倍乘数
void delay_init(u8 SystemOsc)
{
        SysTick->CTRL&=0xfffffffD;//
        fac_us=SystemOsc;                    
        fac_ms=fac_us*1000;
       
}
void delay_us(u32 nus)
{               
        static volatile unsigned long temp;                     
        SysTick->LOAD=nus*fac_us; //时间加载                           
        SysTick->VAL=0x00;        //清空计数器
        SysTick->CTRL|=0x05 ;      //开始倒数          

        do
        {
                temp=SysTick->CTRL;
        }
        while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
        SysTick->CTRL=0x00;       //关闭计数器
        SysTick->VAL =0X00;       //清空计数器         
}

void main(void)
{
...
delay_init(96);
...
delay_us(20);       
}

Excellence

//延时nms
//注意nms的范围
//SysTick->LOAD为24位寄存器,所以,最大延时为:
//nms<=0xffffff*1000/SYSCLK
//SYSCLK单位为Hz,nms单位为ms
//对72M条件下,nms<=1864
void delay_ms(u32 nms)
{                                     
        static volatile unsigned long temp;                  
        SysTick->LOAD=nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
        SysTick->VAL =0x00;           //清空计数器
        SysTick->CTRL|=0x05 ;          //开始倒数  

        do
        {
                temp=SysTick->CTRL;
        }
        while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
        SysTick->CTRL=0x00;       //关闭计数器
        SysTick->VAL =0X00;       //清空计数器                      
}

Excellence

AD:

void DelayNS (uint32 dly)
{
        uint32 i;
       
        for ( ; dly>0; dly--)
                for (i=0; i<50000; i++);
}

void GpioConfigFunc(void)
{
         PinLed1;
         PinLed2;
         PinLed3;
         PinLed4;

         Led1PinOut;
         Led2PinOut;
         Led3PinOut;
         Led4PinOut;


         Led1OnOff(0);
         Led2OnOff(0);
         Led3OnOff(0);
         Led4OnOff(0);

         LPC_SC->PCONP |=PCAD;
         LPC_PINCON->PINSEL1 =(LPC_PINCON->PINSEL1&(~(0x03 << (2 *(AD_value-16)))))|(0x01<<(2*(AD_value-16)));       
       

         
}


uint32 AD_Leach(void)
{

                uint8 i;
                uint32 AdcMax,AdcMin,AdcSum,AdcResult,Adc_temp;
                volatile uint32 ADC_Data;

                ADC_Data=0;
               
                AdcMax=0;
        AdcMin=~0;
        AdcSum = 0;
        Adc_temp = 0;

               


                LPC_ADC->ADCR = (1 << 0)                                        |        // SEL=8,选择通道3
                        ((Fpclk/13000000 ) << 8)                |        // CLKDIV=Fpclk/1000000-1,转换时钟为1MHz
                        (0 << 16)                                                |        // BURST=0,软件控制转换操作
                        (0 << 17)                                                |        // CLKS=0, 使用11clock转换
                        (1 << 21)                                                |          // PDN=1,正常工髂Ｊ?
                        (0 << 22)                                                |          // TEST1:0=00,正常棺髂Ｊ?
                        (1 << 24)                                                |        // START=1,直接艫DC转换
                        (0 << 27);                                                         // 直接启动ADC皇保宋晃扌?
                DelayNS(1);                                                                //延时ms
                ADC_Data = LPC_ADC->ADDR0;                // 读取ADC结果，并浅鼶ONE标志位

               
        for(i=0;i<18;i++)
        {
            LPC_ADC->ADCR |= 1 << 24;                  
            while ((LPC_ADC->ADDR0 & 0x80000000) == 0);
                         LPC_ADC->ADCR |= 1 << 24;                    
            while ((LPC_ADC->ADDR0 & 0x80000000) == 0);


            Adc_temp        =        LPC_ADC->ADDR0;
            Adc_temp          =        (Adc_temp >>4)&0xfff;

            if(Adc_temp>AdcMax)
             {
              AdcMax=Adc_temp;
             }
           if(Adc_temp<AdcMin)
             {
              AdcMin=Adc_temp;
             }
           AdcSum+=Adc_temp;
        }
        AdcResult=(AdcSum-AdcMax-AdcMin)>>4;

        return(AdcResult);
       
}

Excellence

#define AD_value                23        //AD P0.23

Excellence

uint16         temp_ad=0;

temp_ad=(uint16)AD_Leach();
UART0_Printf("AD Value: %d\n",temp_ad);

Excellence

串口0 查询。

#define        UART_TXD0_NUM                2        //P0.2
#define        UART_RXD0_NUM                3        //P0.3

#define UART0_BPS     115200                                             /* 串口0通信波特率             */


extern         void         UART0_Init (void);
extern         void          UART0_SendByte (int ucData);
extern         int          UART0_GetChar (void);
extern         void         UART0_SendString (char *s);
extern         void         UART0_SendChar(uint16_t disp);  
extern         void         UART0_Printf(char *fmt,...);

/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/
void UART0_Init (void)
{
        uint16_t usFdiv;
    /* UART0 */
        LPC_SC->PCONP |=PCUART0;

        //P0.2 TXD3,         P0.3 RXD3
        LPC_PINCON->PINSEL0 =(LPC_PINCON->PINSEL0&(~(0x03 << (2 *UART_TXD0_NUM))))|(FIRSTFUNC<<(2*UART_TXD0_NUM));
        LPC_PINCON->PINSEL0 =(LPC_PINCON->PINSEL0&(~(0x03 << (2 *UART_RXD0_NUM))))|(FIRSTFUNC<<(2*UART_RXD0_NUM));

          //12M:9600--71     115200--6   57600--13  //十进制
        //24M:9600--125     115200--13  57600--17  //十进制
        //25M:9600--92     115200--10  57600--19  //十进制
       
          LPC_UART0->LCR  = 0x83;                      /* 允许设置波特率               */
    usFdiv = (Fpclk / 16) / UART0_BPS;           /* 设置波特率                   */
    LPC_UART0->DLM  = usFdiv / 256;
    LPC_UART0->DLL  = usFdiv % 256;
    LPC_UART0->LCR  = 0x03;                      /* 锁定波特率                   */
    LPC_UART0->FCR  = 0x06;
       
        //12M:9600--0XA1   115200--0XC1   57600--0X20
        //24M:9600--0X41   115200--0X20   57600--0XF8
        //25M:9600--0XDA   115200--0XE5   57600--0X73
       
        //LPC_UART2->FDR = 0x41;
}

/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/

void UART0_SendByte (int ucData)
{

         if(ucData=='\n')
        {
            LPC_UART0->THR='\r';
                        while ((LPC_UART0->LSR & 0x20) == 0);                // 等待数据发送完毕
        }
      
        LPC_UART0->THR=ucData;
          while ((LPC_UART0->LSR & 0x20) == 0);                // 等待数据发送完毕
}
/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/
int UART0_GetChar (void)
{
          while (!(LPC_UART0->LSR & 0x01));
          return (LPC_UART0->RBR);
}

/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/
void UART0_SendString(char *pt)
{
    while(*pt)
        UART0_SendByte(*pt++);
}

/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/
void UART0_SendChar(uint16_t disp)
{
        uint16_t dispbuf[4];
        uint8_t i;

        dispbuf[3] = disp%10 + '0';
        dispbuf[2] = disp/10%10 + '0';
        dispbuf[1] = disp/10/10%10 + '0';
        dispbuf[0] = disp/10/10/10%10 + '0';
        for(i=0;i<4;i++)
                UART0_SendByte(dispbuf[i]);       
}
/*
***************************************************************************************************
** 函数名  :
** 描述    :
** 输入    : 无
** 输出    : 无
** 返回    : 无
** 作者    :
** 创建日期: 2012.6.18
** 版本    : V1.00
***************************************************************************************************
*/
void UART0_Printf(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    UART0_SendString(string);
    va_end(ap);
}

Excellence

串口0 中断。


///////////////////////////////////////////////////////////////////////////////////////////////////////////////


#define      USE_UART                    1


#define      UART0_BPS                    9600

#define      U0_DATA_BIT            3

#define      U0_CHECK_BIT_EN  0
#define      U0_CHECK_BIT            0

#define      U0_STOP_BIT            0

#define      U0_PROIRITY            1

#define                UART0_REC_LENGTH        100
#define                UART0_TXD_LENGTH        100


#ifdef      UART0_GLOBALS
#define     UART0_EXT
#else
#define     UART0_EXT    extern
#endif



//#define                FIFO_LENGTH                        12
#define                FIFO_LENGTH0                        14

#define                DATA_START_ADDR        6



extern uchar RecBuffer_T0[30];

UART0_EXT        struct
{
        uchar           Buffer[UART0_REC_LENGTH],Buffer1[UART0_REC_LENGTH];   
        uchar                CheckSum,OverTime;
   uchar         Command,Command2,Road,Timer,Error,Receiving;
   uint16          Counter,Length;
   volatile unsigned char        RxCount;
    volatile unsigned char         RxdCount;
}  Rec0;


UART0_EXT        struct
{
   uchar   Buffer[UART0_TXD_LENGTH+12];
   uchar   Command,CheckSum,Sending;   
   uint16  Length;
   volatile unsigned char         TxCount;
   volatile unsigned char         TxdCount;
}  Txd0;
UART0_EXT        uchar      *TxdP0;


extern uchar                 PutString0(uchar  *,uchar);
extern uchar                      PutBuffer0(uchar,uint16,uchar *);
extern void                           Uart0_SendChar(uchar  data);
extern void                                ClearReceiveFlag0(uint16);
extern void                                ClearTransmitFlag0(void);
extern void                                UART0_Init(void);
extern void                                UART0_IRQHandler(void)  ;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


uchar RecBuffer_T[30];
uchar RecBuffer_T0[30];

/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
void       Uart0_SendChar(uchar data)
{
    while((LPC_UART0->LSR & 0x00000040) == 0);    //
    LPC_UART0->THR = data;   
}
/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
uchar         PutString0(uchar  *p,uchar DataLen)
{
        uchar                i,Len;
    //RS485_TRANSMIT_ENABLE;         
       

   if(Txd0.Sending)
           return 1;                         // 串口忙，发送失败，需要等待
        //Txd0.Length = strlen((char *)p);
        Txd0.Length=DataLen;
        if(Txd0.Length==0)
                return 1;
        TxdP0 = p;
        Txd0.Sending = 1;
        if(Txd0.Length>FIFO_LENGTH0)                
                Len = FIFO_LENGTH0;
        else                                                
                Len = Txd0.Length;
        for(i=0;i<Len;i++)        {        LPC_UART0->THR = *TxdP0;                TxdP0++;        }
        Txd0.Length -= Len;
        return 0;
}   // End of <PutString> Function

/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
uchar         PutBuffer0(uchar InitSum,uint16 L,uchar *p)
{
        uint16   i,Len;

        if(Txd0.Sending)
           return 1;         // 串口忙，发送失败，需要等待
   Txd0.Length = L;
        TxdP0 = p;
        if(!InitSum)                        // 如果调用本函数前已计算校验和，则这里不再计算
        {
                Txd0.CheckSum = 0;
                for(i=0;i<Txd0.Length;i++)
                {
           //        Txd.CheckSum ^= *p;
           Txd0.CheckSum =CRC8((unsigned char *)p,Txd0.Length);
                   p++;
                }
                *p = Txd0.CheckSum;                // Add ChechSum at the end of the buffer
                Txd0.Length += 1;                  
        }
        Txd0.Sending = 1;
        if(Txd0.Length>FIFO_LENGTH0)                
                Len = FIFO_LENGTH0;
        else                                                
                Len = Txd0.Length;
        for(i=0;i<Len;i++)        {        LPC_UART0->THR = *TxdP0;                TxdP0++;        }
        Txd0.Length -= Len;
        return 0;
}  // End of <PutBuffer> Function

/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
void                        UART0_IRQHandler(void)      // UART0 interrupt function
{
   uchar           IIR,rc;
   uchar           i,j,FifoLen;
        uint16        Len;
        //uchar RecBuffer[20];
       

        IIR = LPC_UART0->IIR;
        switch (IIR & 0x0e)                  
        {
             case 0x02:                    // Transmit interrupt $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$          

                        if(Txd0.Length)
                        {
                             if(Txd0.Length>FIFO_LENGTH0)                
                                        Len = FIFO_LENGTH0;
                                else                                                
                                        Len = Txd0.Length;
                                for(i=0;i<Len;i++)        {        LPC_UART0->THR = *TxdP0;                TxdP0++;        }
                                Txd0.Length -= Len;
                                Txd0.Sending = TRUE;
                     }
                        else
                        {
                             ClearTransmitFlag0();       
                                //IOSET0                =        1<<RTS;
                                //IOSET0                =        1<<CTS;
                       
                        }
                break;        //          
                case 0x0c:                // 接收数据有效，超时。注：这里不能用break语句                       
                        Rec0.OverTime = 1;
                  case 0x04:     // 接收数据有效 $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$


               
                                        FifoLen = 0;
                        while((LPC_UART0->LSR&0x01) == 1)                 //  最多14字节
                           {
                           rc = LPC_UART0->RBR;
                           //////////////////////////////////// 接收数据
                  // RecBuffer_T1[Rec.RxdCount++]=rc;
                           if(Rec0.Counter<UART0_REC_LENGTH)                // 不能超出缓冲区长度
                           {                                  
                                   Rec0.Buffer[Rec0.Counter++] = rc;       
                                for(j=0;j<30;j++)
                                {

                                        RecBuffer_T0[j]=Rec0.Buffer[j];
                                }
                                        FifoLen ++;
                           }                          
                           }       

                   ///////////////////////////////////// 判断是否为帧头
          
                   if(Rec0.Receiving==0)
                           {
                                   //FF 52 00 00 00 00 00 00 00 00 92 FE
                                  
                                   if(Rec0.Buffer[0]==0xff)
                                   {
                                          
                                           Rec0.Receiving = TRUE;
                                       
                                        for(i=0;i<30;i++)
                                                RecBuffer_T0=RecBuffer_T0;

                                   }
                                   else
                                           {
                                           Rec0.Error = TRUE;
                                        Rec0.Counter=0;
//                                        Rec0.RxdCount=0;
                                        //=0;
                                           }
                               
                           }
                break;
                default: break;
        }        // End of Switch                                   
       

}  // End of UART0 Interrupt function

/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
void                        ClearReceiveFlag0(uint16 c)
{        
        uchar i;
        c=c;
        Rec0.CheckSum = Rec0.Error = 0;
        Rec0.Command = Rec0.OverTime = 0;
        Rec0.Command2 = 0;
        Rec0.Counter  = Rec0.Length   = Rec0.Receiving = 0;                       

                for(i=0;i<UART0_REC_LENGTH;i++)        { Rec0.Buffer = 0; }
       
} // End of Function                                 

/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
void                        ClearTransmitFlag0(void)
{
       
       
        Txd0.CheckSum = Txd0.Sending = 0;       
        Txd0.Length = 0;       
} // End of Function                                  




/********************************************************************************************
* Function name                        :        
* Descriptions                        :         
* input parameters                :     
* output parameters                :   
* Returned value                :      
********************************************************************************************/
void                        UART0_Init(void)
{
        //uint16  Fdiv;       
       
        LPC_SC->PCONP |=PCUART0;

        //P0.2 TXD3,         P0.3 RXD3
        LPC_PINCON->PINSEL0 =(LPC_PINCON->PINSEL0&(~(0x03 << (2 *UART_TXD0_NUM))))|(FIRSTFUNC<<(2*UART_TXD0_NUM));
        LPC_PINCON->PINSEL0 =(LPC_PINCON->PINSEL0&(~(0x03 << (2 *UART_RXD0_NUM))))|(FIRSTFUNC<<(2*UART_RXD0_NUM));
  
       
           LPC_UART0->LCR = 0x83;                       
        //Fdiv = (24000000UL / 16) / UART0_BPS;    // set baudrate
       
        //12M:9600--71     115200--6   57600--13  //十进制
        //24M:9600--125     115200--13  57600--17  //十进制
           LPC_UART0->DLM = 0;///Fdiv / 256;                                                       
        LPC_UART0->DLL = 125;///Fdiv % 256;          
        LPC_UART0->LCR = ((U0_DATA_BIT)|(U0_STOP_BIT<<2)|(U0_CHECK_BIT_EN<<3)|(U0_CHECK_BIT<<4));
           LPC_UART0->IER = 0x03;                       // Enable RDA and THRE interrupts
        LPC_UART0->FCR = 0xc7;
               
        //12M:9600--0XA1   115200--0XC1   57600--0X20
        //24M:9600--0X41   115200--0X20   57600--0XF8
        LPC_UART0->FDR = 0x41;
       
    NVIC_SetPriority(UART0_IRQn, 5);

        NVIC_EnableIRQ(UART0_IRQn);                                       


}  // End of UART0 initialize function


////////////////////////////////////////////////////////////////////////////////////
int main (void)
{
        uchar TestUartData[]={0xFF,0xF0,0x2D,0xF0,0xE1,0xF0,0xF0,0xD2,0x78,0x00};
           delayXms(100);
   
          SystemInit();
        SystemPinInit();
        GpioConfigFunc();

        UART0_Init();
        //UART1_Init();
        //UART2_Init();
        //UART3_Init();
        ClearTransmitFlag0();
        ClearReceiveFlag0(30);


        PutBuffer0(1,10, TestUartData);

       


  while (1)
          {     

                delayXms(5000);
                //LED1_OFF;
                Led1OnOff(0);
                delayXms(5000);
                //LED2_OFF;
                Led2OnOff(0);
                delayXms(5000);
                //LED3_OFF;
                Led3OnOff(0);
                delayXms(5000);
                //LED4_OFF;
                Led4OnOff(0);
                delayXms(5000);

                PutBuffer0(1,10, TestUartData);


                //LED1_ON;
                //LED2_ON;
                //LED3_ON;
                //LED4_ON;
                Led1OnOff(1);
                Led2OnOff(1);
                Led3OnOff(1);
                Led4OnOff(1);
                delayXms(5000);


          }
}

Excellence

DAC....


#define        DAC_NUM                        26        //P0.26

volatile const uint16 SinTable[] =
{
0x1FF,0x20C,0x218,0x225,0x231,0x23E,0x24A,0x256,0x263,0x26F,0x27B,0x287,0x293,0x29F,0x2AB,0x2B7
,0x2C3,0x2CE,0x2DA,0x2E5,0x2F0,0x2FB,0x306,0x311,0x31B,0x326,0x330,0x33A,0x343,0x34D,0x357,0x360
,0x369,0x371,0x37A,0x382,0x38A,0x392,0x39A,0x3A1,0x3A8,0x3AF,0x3B6,0x3BC,0x3C2,0x3C8,0x3CD,0x3D3
,0x3D8,0x3DC,0x3E1,0x3E5,0x3E8,0x3EC,0x3EF,0x3F2,0x3F5,0x3F7,0x3F9,0x3FB,0x3FC,0x3FD,0x3FE,0x3FE
,0x3FE,0x3FE,0x3FE,0x3FD,0x3FC,0x3FB,0x3F9,0x3F7,0x3F5,0x3F2,0x3EF,0x3EC,0x3E8,0x3E5,0x3E1,0x3DC
,0x3D8,0x3D3,0x3CD,0x3C8,0x3C2,0x3BC,0x3B6,0x3AF,0x3A8,0x3A1,0x39A,0x392,0x38A,0x382,0x37A,0x371
,0x369,0x360,0x357,0x34D,0x343,0x33A,0x330,0x326,0x31B,0x311,0x306,0x2FB,0x2F0,0x2E5,0x2DA,0x2CE
,0x2C3,0x2B7,0x2AB,0x29F,0x293,0x287,0x27B,0x26F,0x263,0x256,0x24A,0x23E,0x231,0x225,0x218,0x20C
,0x1FF,0x1F2,0x1E6,0x1D9,0x1CD,0x1C0,0x1B4,0x1A8,0x19B,0x18F,0x183,0x177,0x16B,0x15F,0x153,0x147
,0x13B,0x130,0x124,0x119,0x10E,0x103,0x0F8,0x0ED,0x0E3,0x0D8,0x0CE,0x0C4,0x0BB,0x0B1,0x0A7,0x09E
,0x095,0x08D,0x084,0x07C,0x074,0x06C,0x064,0x05D,0x056,0x04F,0x048,0x042,0x03C,0x036,0x031,0x02B
,0x026,0x022,0x01D,0x019,0x016,0x012,0x00F,0x00C,0x009,0x007,0x005,0x003,0x002,0x001,0x000,0x000
,0x000,0x000,0x000,0x001,0x002,0x003,0x005,0x007,0x009,0x00C,0x00F,0x012,0x016,0x019,0x01D,0x022
,0x026,0x02B,0x031,0x036,0x03C,0x042,0x048,0x04F,0x056,0x05D,0x064,0x06C,0x074,0x07C,0x084,0x08D
,0x095,0x09E,0x0A8,0x0B1,0x0BB,0x0C4,0x0CE,0x0D8,0x0E3,0x0ED,0x0F8,0x103,0x10E,0x119,0x124,0x130
,0x13B,0x147,0x153,0x15F,0x16B,0x177,0x183,0x18F,0x19B,0x1A8,0x1B4,0x1C0,0x1CD,0x1D9,0x1E6,0x1F2

};                                                                  // 正弦表   

LPC_PINCON->PINSEL1 =(LPC_PINCON->PINSEL1&(~(0x03 << (2 *(DAC_NUM-16)))))|(0x02<<(2*(DAC_NUM-16)));


for (i = 0; i <255 ; i++)//255   T
                {       
                LPC_DAC->DACR = (SinTable << 6);          /* 输出正弦波 */
            }

Excellence

无线通讯NRF24L01。。。在正点原子STM32程序上改为LPC1768

Excellence

彩屏液晶显示字符

seaman117

上个DMA串口收发的看看啊！

Excellence

收集的。。。。

sanliuyaoling

顶！！！！！！！！！！！！！！！！！！！！！！！

电子小生

顶一个！