LPC1768 (плата SK-MLPC1768) сборник основных рабочих функций

Практически в каждом проекте есть базовый набор основных функций. Чтобы не вспоминать где что набито и откуда выдрать, решил свести все в один основной и один заголовочный файл и подключать его ко всем проектам. А чтобы не искать его по многочисленным рабочим местам, буду хранить его здесь и понемногу расширять. Может еще кому пригодиться, таким же начинающим. А если кто дополнит или поправит, будет вообще замечательно.

SKLPC1768lib.h

#ifndef _SKLPC1768LIB_H
#define _SKLPC1768LIB_H

typedef struct {
    uint32_t RTC_Sec;
    uint32_t RTC_Min; 
    uint32_t RTC_Hour; 
    uint32_t RTC_Mday; 
    uint32_t RTC_Mon; 
    uint32_t RTC_Year; 
    uint32_t RTC_Wday; 
    uint32_t RTC_Yday; 
} RTCTime; 

/*----------------------------------------------------------------------------
  RTC functions
 *----------------------------------------------------------------------------*/

extern void InitRTC (void);
extern void DeInitRTC (void);
extern void RTCStart (void);
extern void RTCStop (void);
extern void RTC_IRQHandler (void);
extern void RTCSetTime (RTCTime Time);
extern RTCTime RTCGetTime( void );

/*----------------------------------------------------------------------------
  Delay functions
 *----------------------------------------------------------------------------*/

extern void Delay (uint32_t counter);
extern void Delay_s (uint16_t s);
extern void Delay_ms (uint16_t ms);
extern void Delay_mks (uint16_t mks);

/*----------------------------------------------------------------------------
  Text LCD functions
 *----------------------------------------------------------------------------*/

extern void WriteByte4 (uint32_t b);
extern void WriteByte (uint32_t b);
extern void WriteCommand (uint32_t c);
extern void WriteData (uint32_t d);
extern void ClrLCD (void);
extern void InitLCD (void);
extern void LCDputc (uint8_t c);
extern void LCDputs (uint8_t *s);
extern LCDgotoxy (uint32_t x, uint32_t y);

/*----------------------------------------------------------------------------
  Initialize UART pins, Baudrate, Power On
 *----------------------------------------------------------------------------*/

extern void InitUart (uint16_t uart, uint16_t baund);
extern void InitUart0_115200 (void);
extern void InitUart1_115200 (void);
extern void InitUart2_115200 (void);
extern void InitUart3_115200 (void);
extern void InitUart0_9600 (void);
extern void InitUart1_9600 (void);
extern void InitUart2_9600 (void);
extern void InitUart3_9600 (void);

/*----------------------------------------------------------------------------
  UART Power Off
 *----------------------------------------------------------------------------*/

extern void DeInitUart0 (void);
extern void DeInitUart1 (void);
extern void DeInitUart2 (void);
extern void DeInitUart3 (void);
extern void DeInitUartAll (void);

/*----------------------------------------------------------------------------
  Write character to Serial Port
 *----------------------------------------------------------------------------*/

extern int UART_putChar (uint16_t uart, uint8_t c);

/*----------------------------------------------------------------------------
  Read character from Serial Port   (blocking read)
 *----------------------------------------------------------------------------*/

extern int UART_getChar (uint16_t uart); 

/*----------------------------------------------------------------------------
  Read character from Serial Port   (non blocking read)
 *----------------------------------------------------------------------------*/

extern int UART_getChar_nb (uint16_t uart); 

/*----------------------------------------------------------------------------
  Write character to Serial Port
 *----------------------------------------------------------------------------*/

extern void UART_putString (uint16_t uart, uint8_t *s);

#endif


SKLPC1768lib.c

#include "LPC17xx.h"
#include "SKLPC1768lib.h"

LPC_UART_TypeDef *pUart0;
LPC_UART_TypeDef *pUart1;
LPC_UART_TypeDef *pUart2;
LPC_UART_TypeDef *pUart3;

void RTCSetTime (RTCTime Time)
{
	LPC_RTC->SEC = Time.RTC_Sec;
	LPC_RTC->MIN = Time.RTC_Min;
	LPC_RTC->HOUR = Time.RTC_Hour;
	LPC_RTC->DOM = Time.RTC_Mday;
	LPC_RTC->DOW = Time.RTC_Wday;
	LPC_RTC->DOY = Time.RTC_Yday;
	LPC_RTC->MONTH = Time.RTC_Mon;
	LPC_RTC->YEAR = Time.RTC_Year;   
}

RTCTime RTCGetTime (void)
{
	RTCTime LocalTime;
 
	LocalTime.RTC_Sec = LPC_RTC->SEC;
	LocalTime.RTC_Min = LPC_RTC->MIN;
	LocalTime.RTC_Hour = LPC_RTC->HOUR;
	LocalTime.RTC_Mday = LPC_RTC->DOM;
	LocalTime.RTC_Wday = LPC_RTC->DOW;
	LocalTime.RTC_Yday = LPC_RTC->DOY;
	LocalTime.RTC_Mon = LPC_RTC->MONTH;
	LocalTime.RTC_Year = LPC_RTC->YEAR;
	return ( LocalTime );   
}

void RTC_IRQHandler (void)
{
	LPC_RTC->ILR |= 0x01;
}

void InitRTC (void)
{
	LPC_SC->PCONP |= (1 << 9);
	if ( LPC_RTC->RTC_AUX & (0x1<<4) )
	{
		LPC_RTC->RTC_AUX |= (0x1<<4);
	}
	LPC_RTC->AMR = 0;
	LPC_RTC->CIIR = 1; 
	LPC_RTC->CCR = 0x10;
	LPC_RTC->CCR |= 0x01;
	NVIC_EnableIRQ(RTC_IRQn) ;
}

void DeInitRTC (void)
{
	LPC_SC->PCONP &=~(1 << 9);
}

void RTCStart (void)
{
	LPC_RTC->CCR |= 0x01;
}

void RTCStop (void)
{  
	LPC_RTC->CCR &= ~0x01;
} 


void Delay (uint32_t counter) 
{  
  while (counter--);
}

void Delay_s (uint16_t s) 
{  
	const uint32_t i = 12000000;
	while (s)
	{
	Delay (i);
	s--;
	}
}

void Delay_ms (uint16_t ms) 
{  
	const uint16_t i = 12000;
	while (ms)
	{
	Delay (i);
	ms--;
	}
}

void Delay_mks (uint16_t mks) 
{  
	const uint8_t i = 12;
	while (mks)
	{
	Delay (i);
	mks--;
	}
}

void WriteByte4 (uint32_t b)
{
	LPC_GPIO1->FIODIR |= 0x3F00000;
	LPC_GPIO1->FIOCLR = 0xF00000; 
	LPC_GPIO1->FIOSET = (b & 0xF)<<20;
	LPC_GPIO1->FIOSET = 0x2000000;
	Delay (1000);
	LPC_GPIO1->FIOCLR = 0x2000000;
	Delay (1000);
	LPC_GPIO1->FIOSET = 0xF;  
}

void WriteByte (uint32_t b)
{
	WriteByte4 (b>>4);
	WriteByte4 (b);
}

void WriteCommand (uint32_t c)
{
	LPC_GPIO1->FIOCLR = 0x1000000;
	WriteByte (c);
}

void WriteData (uint32_t d)
{
	LPC_GPIO1->FIOSET = 0x1000000;
	WriteByte (d);
}

void ClrLCD (void)
{
	WriteCommand (0x01);
}

void InitLCD (void)
{
	Delay(10000000);
	LPC_GPIO1->FIODIR |= 0x3F00000;
	LPC_GPIO1->FIOCLR = 0x1F00000; 
	WriteByte4(0x30);
	Delay(10000000);
	WriteByte4(0x30);
	Delay(10000000);
	WriteByte4(0x30);
	Delay (100000);
	WriteByte4(0x20);
	Delay (100000);
	WriteCommand (0x20);
	Delay (100000);
	WriteCommand (0x28);
	Delay (100000);
	WriteCommand (0x0C);
	Delay (100000);
	WriteCommand (0x06);
	Delay (100000);
	WriteCommand (0x01);
	Delay (100000);
}

void LCDputc (uint8_t c)
{
	WriteData(c);	
}

void LCDputs (uint8_t *s)
{
	while (*s) 
	{
    	LCDputc (*s++);
	}	
}

LCDgotoxy (uint32_t x, uint32_t y) 
{ 
	uint32_t c;

	c = --x;
	if (--y) 
	{
		c |= 0x40;
	}
	WriteCommand (c | 0x80);  
}

void InitUart (uint16_t uart, uint16_t baund)
{
	switch (uart)
	{
		case 0:
		{
			DeInitUart0 ();
			LPC_SC->PCONP |= (1<<3);
			LPC_PINCON->PINSEL0 |= (1 << 4);             	
			LPC_PINCON->PINSEL0 |= (1 << 6);          	
			pUart0 = (LPC_UART_TypeDef *)LPC_UART0;

			if (baund == 112500)
			{
				pUart0->LCR    = 0x83; 
				pUart0->DLL    = 9;      
				pUart0->FDR    = 0x21;      
				pUart0->DLM    = 0;       
				pUart0->LCR    = 0x03;  

			}
			if (baund == 9600)
			{
				pUart0->LCR    = 0x83;                        
				pUart0->DLL    = 104;                            
				pUart0->FDR    = 0x21;                        
				pUart0->DLM    = 0;                             
				pUart0->LCR    = 0x03;                        
			}
		}
		break;
		case 1:
		{
			DeInitUart1 ();
			LPC_SC->PCONP |= (1<<4);
			LPC_PINCON->PINSEL4 |= (2 << 0);
    		LPC_PINCON->PINSEL4 |= (2 << 2);
			pUart1 = (LPC_UART_TypeDef *)LPC_UART1;

			if (baund == 112500)
			{
				pUart1->LCR    = 0x83; 
				pUart1->DLL    = 9;      
				pUart1->FDR    = 0x21;      
				pUart1->DLM    = 0;       
				pUart1->LCR    = 0x03;  

			}
			if (baund == 9600)
			{
				pUart1->LCR    = 0x83;                        
				pUart1->DLL    = 104;                            
				pUart1->FDR    = 0x21;                        
				pUart1->DLM    = 0;                             
				pUart1->LCR    = 0x03;                        
			}
		}
		break;
		case 2:
		{
			DeInitUart2 ();
			LPC_SC->PCONP |= (1<<24);
			LPC_PINCON->PINSEL0 |= (1 << 20);  
			LPC_PINCON->PINSEL0 |= (1 << 22);
			pUart2 = (LPC_UART_TypeDef *)LPC_UART2;

			if (baund == 112500)
			{
				pUart2->LCR    = 0x83; 
				pUart2->DLL    = 9;      
				pUart2->FDR    = 0x21;      
				pUart2->DLM    = 0;       
				pUart2->LCR    = 0x03;  

			}
			if (baund == 9600)
			{
				pUart2->LCR    = 0x83;                        
				pUart2->DLL    = 104;                            
				pUart2->FDR    = 0x21;                        
				pUart2->DLM    = 0;                             
				pUart2->LCR    = 0x03;                        
			}
		}
		break;
		case 3:
		{
			DeInitUart3 ();
			LPC_SC->PCONP |= (1<<25);
			LPC_PINCON->PINSEL0 |= (2 << 0); 
			LPC_PINCON->PINSEL0 |= (2 << 2);
			pUart3 = (LPC_UART_TypeDef *)LPC_UART3;

			if (baund == 112500)
			{
				pUart3->LCR    = 0x83; 
				pUart3->DLL    = 9;      
				pUart3->FDR    = 0x21;      
				pUart3->DLM    = 0;       
				pUart3->LCR    = 0x03;  

			}
			if (baund == 9600)
			{
				pUart3->LCR    = 0x83;                        
				pUart3->DLL    = 104;                            
				pUart3->FDR    = 0x21;                        
				pUart3->DLM    = 0;                             
				pUart3->LCR    = 0x03;                        
			}
		}
		break;
	}	
}

void InitUart0_115200 (void)
{
	DeInitUart0 ();

	LPC_SC->PCONP |= (1<<3);

	LPC_PINCON->PINSEL0 |= (1 << 4);             	/* Pin P0.2 used as TXD0 (Com0) */
    LPC_PINCON->PINSEL0 |= (1 << 6);             	/* Pin P0.3 used as RXD0 (Com0) */

	pUart0 = (LPC_UART_TypeDef *)LPC_UART0;

	pUart0->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart0->DLL    = 9;                             /* 115200 Baud Rate @ 24.0 MHZ PCLK */
	pUart0->FDR    = 0x21;                          /* FR 1,51, DIVADDVAL = 1, MULVAL = 2 */
	pUart0->DLM    = 0;                             /* High divisor latch = 0         */
	pUart0->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart1_115200 (void)
{
	DeInitUart1 ();

	LPC_SC->PCONP |= (1<<4);

	LPC_PINCON->PINSEL4 |= (2 << 0);             	/* Pin P2.0 used as TXD1 (Com1) */
    LPC_PINCON->PINSEL4 |= (2 << 2);             	/* Pin P2.1 used as RXD1 (Com1) */

    pUart1 = (LPC_UART_TypeDef *)LPC_UART1;

	pUart1->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart1->DLL    = 9;                             /* 115200 Baud Rate @ 24.0 MHZ PCLK */
	pUart1->FDR    = 0x21;                          /* FR 1,51, DIVADDVAL = 1, MULVAL = 2 */
	pUart1->DLM    = 0;                             /* High divisor latch = 0         */
	pUart1->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart2_115200 (void)
{
	DeInitUart2 ();

	LPC_SC->PCONP |= (1<<24);

	LPC_PINCON->PINSEL0 |= (1 << 20);             	/* Pin P0.10 used as TXD2 (Com2) */
    LPC_PINCON->PINSEL0 |= (1 << 22);             	/* Pin P0.11 used as RXD2 (Com2) */

    pUart2 = (LPC_UART_TypeDef *)LPC_UART2;

	pUart2->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart2->DLL    = 9;                             /* 115200 Baud Rate @ 24.0 MHZ PCLK */
	pUart2->FDR    = 0x21;                          /* FR 1,51, DIVADDVAL = 1, MULVAL = 2 */
	pUart2->DLM    = 0;                             /* High divisor latch = 0         */
	pUart2->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart3_115200 (void)
{
	DeInitUart3 ();

	LPC_SC->PCONP |= (1<<25);

	LPC_PINCON->PINSEL0 |= (2 << 0);             	/* Pin P0.0 used as TXD3 (Com3) */
    LPC_PINCON->PINSEL0 |= (2 << 2);             	/* Pin P0.1 used as RXD3 (Com3) */

    pUart3 = (LPC_UART_TypeDef *)LPC_UART3;

	pUart3->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart3->DLL    = 9;                             /* 115200 Baud Rate @ 24.0 MHZ PCLK */
	pUart3->FDR    = 0x21;                          /* FR 1,51, DIVADDVAL = 1, MULVAL = 2 */
	pUart3->DLM    = 0;                             /* High divisor latch = 0         */
	pUart3->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart0_9600 (void)
{
	DeInitUart0 ();

	LPC_SC->PCONP |= (1<<3);

	LPC_PINCON->PINSEL0 |= (1 << 4);             	/* Pin P0.2 used as TXD0 (Com0) */
    LPC_PINCON->PINSEL0 |= (1 << 6);             	/* Pin P0.3 used as RXD0 (Com0) */

	pUart0 = (LPC_UART_TypeDef *)LPC_UART0;

	pUart0->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart0->DLL    = 104;                           /* 9600 Baud Rate @ 24.0 MHZ PCLK */
	pUart0->FDR    = 0x21;                          /* FR 1,50, DIVADDVAL = 1, MULVAL = 2 */
	pUart0->DLM    = 0;                             /* High divisor latch = 0         */
	pUart0->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart1_9600 (void)
{
	DeInitUart1 ();

	LPC_SC->PCONP |= (1<<4);

	LPC_PINCON->PINSEL4 |= (2 << 0);             	/* Pin P2.0 used as TXD1 (Com1) */
    LPC_PINCON->PINSEL4 |= (2 << 2);             	/* Pin P2.1 used as RXD1 (Com1) */

    pUart1 = (LPC_UART_TypeDef *)LPC_UART1;

	pUart1->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart1->DLL    = 104;                           /* 9600 Baud Rate @ 24.0 MHZ PCLK */
	pUart1->FDR    = 0x21;                          /* FR 1,50, DIVADDVAL = 1, MULVAL = 2 */
	pUart1->DLM    = 0;                             /* High divisor latch = 0         */
	pUart1->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart2_9600 (void)
{
	DeInitUart2 ();

	LPC_SC->PCONP |= (1<<24);

	LPC_PINCON->PINSEL0 |= (1 << 20);             	/* Pin P0.10 used as TXD2 (Com2) */
    LPC_PINCON->PINSEL0 |= (1 << 22);             	/* Pin P0.11 used as RXD2 (Com2) */

	pUart2 = (LPC_UART_TypeDef *)LPC_UART2;

	pUart2->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart2->DLL    = 104;                           /* 9600 Baud Rate @ 24.0 MHZ PCLK */
	pUart2->FDR    = 0x21;                          /* FR 1,50, DIVADDVAL = 1, MULVAL = 2 */
	pUart2->DLM    = 0;                             /* High divisor latch = 0         */
	pUart2->LCR    = 0x03;                          /* DLAB = 0                       */
}

void InitUart3_9600 (void)
{
	DeInitUart3 ();

	LPC_SC->PCONP |= (1<<25);

	LPC_PINCON->PINSEL0 |= (2 << 0);             	/* Pin P0.0 used as TXD3 (Com3) */
    LPC_PINCON->PINSEL0 |= (2 << 2);             	/* Pin P0.1 used as RXD3 (Com3) */

	pUart3 = (LPC_UART_TypeDef *)LPC_UART3;

	pUart3->LCR    = 0x83;                          /* 8 bits, no Parity, 1 Stop bit  */
	pUart3->DLL    = 104;                           /* 9600 Baud Rate @ 24.0 MHZ PCLK */
	pUart3->FDR    = 0x21;                          /* FR 1,50, DIVADDVAL = 1, MULVAL = 2 */
	pUart3->DLM    = 0;                             /* High divisor latch = 0         */
	pUart3->LCR    = 0x03;                          /* DLAB = 0                       */
}

void DeInitUart0 (void)
{
	LPC_SC->PCONP &= ~(1<<3);
	LPC_PINCON->PINSEL0 &= ~(3 << 4);
    LPC_PINCON->PINSEL0 &= ~(3 << 6); 
}

void DeInitUart1 (void)
{
	LPC_SC->PCONP &= ~(1<<4);
	LPC_PINCON->PINSEL4 &= ~(3 << 0);
    LPC_PINCON->PINSEL4 &= ~(3 << 2);
}

void DeInitUart2 (void)
{
	LPC_SC->PCONP &= ~(1<<24);
	LPC_PINCON->PINSEL0 &= ~(3 << 20); 
    LPC_PINCON->PINSEL0 &= ~(3 << 22);
}

void DeInitUart3 (void)
{
	LPC_SC->PCONP &= ~(1<<25);
	LPC_PINCON->PINSEL0 &= ~(3 << 0);  
    LPC_PINCON->PINSEL0 &= ~(3 << 2);
}

void DeInitUartAll (void)
{
	DeInitUart0 ();
	DeInitUart1 ();
	DeInitUart2 ();
	DeInitUart3 ();
}

int UART_putChar (uint16_t uart, uint8_t c) 
{
	LPC_UART_TypeDef *pUart;

	switch (uart)
	{
		case 0:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART0;
		}
		break;
		case 1:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART1;
		}
		break;
		case 2:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART2;
		}
		break;
		case 3:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART3;
		}
		break;
	}

	while (!(pUart->LSR & 0x20));
	return (pUart->THR = c);
}

int UART_getChar (uint16_t uart) 
{
	LPC_UART_TypeDef *pUart;

	switch (uart)
	{
		case 0:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART0;
		}
		break;
		case 1:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART1;
		}
		break;
		case 2:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART2;
		}
		break;
		case 3:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART3;
		}
		break;
	}

	while (!(pUart->LSR & 0x01));
	return (pUart->RBR);
}

int UART_getChar_nb (uint16_t uart) 
{
	LPC_UART_TypeDef *pUart;

	switch (uart)
	{
		case 0:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART0;
		}
		break;
		case 1:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART1;
		}
		break;
		case 2:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART2;
		}
		break;
		case 3:
		{
		 	pUart =  (LPC_UART_TypeDef *)LPC_UART3;
		}
		break;
	}
  
	if (pUart->LSR & 0x01)
	return (pUart->RBR);
	else
	return 0;
}

void UART_putString (uint16_t uart, uint8_t *s) 
{
	while (*s != 0) 
	{
		UART_putChar(uart, *s++);
	}
}


  • 0
  • 23 апреля 2011, 20:47
  • lexanet

Комментарии (6)

RSS свернуть / развернуть
Мдя, код действительно нубский :) Много дублирования, магические числа там где есть формулы расчета.
Небольшой совет. Не увлекайтесь созданием набора функций на любой вкус. Выбирети задачу и решая её пишите только необходимое (ну возможно совсем чуть чуть для расширения возможностей). Всё равно когда будите решать следующий проект будите переделывать.
У вас есть «универсальная» функция настройки портов и «индивидуальные» для конкретных порта и скорости. и код продублирован. лучше будет если вы либо универсальную сведёте к вызову инднвидуальных, либо индивидуальные к выхову универсальной (что лучше, т.к. коэффициенты делителя можно расчитать по формуле во время выполнения).
0
Посмотрите вот эту библиотечку CodeBase LPC1343, не совсем ваш контроллер, но близко.
0
Дык, только учусь :) А различные Standard Peripherals Library, ну их нафиг. Если ими пользоваться, регистров мк в жизни живых не увидишь :)
0
А вам важно видить эти регистры? Или сделать что-то? или сделать, но своими руками?
Библиотеки позволяют писать более переносимый код, если конечно библиотеки были с возможностью переносимости.
А ссылку я дал, что бы вы посмотрели как остальные делают. Проект под BSD лицензией в исходниках. Посмотрите как там сделано, что бы вы сделали иначе, что у них лучше реализовано.
0
С библиотеками я знаком, и кроме этой ссылки. Да, мне важно видеть регистры, мне не нужен легко переносимый код, я хочу писать свой код или изучать учебные исходники не выпуская из рук Reference manual. Мне не нравиться такая настройка UART-а:
USART_InitStructure.USART_BaudRate = baud_rate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;

Мне больше нравиться:
0
pUart0->LCR = 0x83;
pUart0->DLL = 9;
pUart0->FDR = 0x21;
pUart0->DLM = 0;
pUart0->LCR = 0x03;
0
Только зарегистрированные и авторизованные пользователи могут оставлять комментарии.