LPC1768. Установка времени. (WEB&GPS&Manual).

Сделал настройку и установку часов на железке. Можно устанавливать время вручную, через WEB форму, одноразово синхронизировать с устройством GPS или задать периодичность, с которой микроконтроллер будет брать точное время с GPS-ки. Дополнительно, время выводится на uart.





#include "LPC17xx.h"
#include "RTL.h"
#include "File_Config.h"
#include "Net_Config.h"
#include "stdio.h"
#include "string.h"

#define EVT_WEB_TIME 0x0100
#define EVT_LCD_PRINT 0x0101
#define EVT_UART0_PRINT 0x0102
#define EVT_LIFE_LED 0x0103

#define IER_RBR		0x01
#define IER_THRE	0x02
#define IER_RLS		0x04

#define IIR_PEND	0x01
#define IIR_RLS		0x03
#define IIR_RDA		0x02
#define IIR_CTI		0x06
#define IIR_THRE	0x01

#define LSR_RDR		0x01
#define LSR_OE		0x02
#define LSR_PE		0x04
#define LSR_FE		0x08
#define LSR_BI		0x10
#define LSR_THRE	0x20
#define LSR_TEMT	0x40
#define LSR_RXFE	0x80

#define BUFSIZE		0x180

uint32_t UART3Count = 0;
uint8_t UART3TxEmpty = 1;
uint32_t UART3Status;
uint8_t IRQbuf[BUFSIZE];
uint8_t GPSbuf[BUFSIZE]; 

const unsigned long led_mask[] = { 1UL<<23 };

uint64_t tcp_stack[1024/8];
uint64_t lcd_print_stack[1024/8];
uint64_t gps_print_stack[1024/8];

uint32_t retv;
uint8_t outBuf[100];

uint8_t PrintTime[9];
uint8_t PrintDate[11];
uint8_t GPSCurTime[9];
uint8_t GPSCurDate[11];
uint16_t GPSPeriod = 1000;
uint8_t GPSUseUpdate = 0;

MMCFG SDCardCfg;

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;


RTCTime CurrentTime;
RTCTime GPSCTime;

uint8_t TStatus[2];
uint8_t GPSStatus = 0;

uint32_t CurYear;
uint32_t CurMon;
uint32_t CurDay;

OS_TID t_WEB_PRINT;
OS_TID t_GPS_TIME;
OS_TID t_UART0_PRINT;
OS_TID t_LCD_PRINT;
OS_TID t_LIFE_LED;
OS_TID t_TIMER_HTTP;
OS_TID t_HTTP;

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

void InitLEDs (void)
{
	LPC_GPIO1->FIODIR = (1<<23);
}

void LEDon (unsigned int num)
{
	LPC_GPIO1->FIOPIN |= led_mask[num];
}

void LEDoff (unsigned int num)
{
	LPC_GPIO1->FIOPIN &= ~led_mask[num];
}

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 DeInitRTC (void)
{
	LPC_SC->PCONP &=~(1 << 9);
}

void InitRTC (void)
{
	DeInitRTC ();
	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 RTCStart (void)
{
	LPC_RTC->CCR |= 0x01;
}

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

void WriteByte4 (uint32_t b)
{
	LPC_GPIO2->FIODIR |= 0x3F;
	LPC_GPIO2->FIOCLR = 0xF; 
	LPC_GPIO2->FIOSET = (b & 0xF);
	LPC_GPIO2->FIOSET = 0x20;
	Delay (2000);
	LPC_GPIO2->FIOCLR = 0x20;
	Delay (2000);
	LPC_GPIO2->FIOSET = 0xF;  
}

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

void WriteCommand (uint32_t c)
{
	LPC_GPIO2->FIOCLR = 0x10;
	WriteByte (c);
}

void WriteData (uint32_t d)
{
	LPC_GPIO2->FIOSET = 0x10;
	WriteByte (d);
}

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

void InitLCD (void)
{
	Delay(20000000);
	LPC_GPIO2->FIODIR |= 0x3F;
	LPC_GPIO2->FIOCLR = 0x1F; 
	WriteByte4(0x30);
	Delay(1000000);
	WriteByte4(0x30);
	Delay(1000000);
	WriteByte4(0x30);
	Delay (1000000);
	WriteByte4(0x20);
	Delay (1000000);
	WriteCommand (0x20);
	Delay (1000000);
	WriteCommand (0x28);
	Delay (1000000);
	WriteCommand (0x0C);
	Delay (1000000);
	WriteCommand (0x06);
	Delay (1000000);
	WriteCommand (0x01);
	Delay (1000000);
	WriteCommand (0x01);
	Delay (1000000);
	WriteCommand (0x01);
	Delay (1000000); 	
}

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

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


void InitUart3_38400 (void)
{
        DeInitUart3 ();

        LPC_SC->PCONP |= (1<<25);
        LPC_PINCON->PINSEL0 |= (2 << 0);  
        LPC_PINCON->PINSEL0 |= (2 << 2); 
        LPC_UART3->LCR    = 0x83;          
        LPC_UART3->DLL    = 26;           
        LPC_UART3->FDR    = 0x21;          
        LPC_UART3->DLM    = 0;            
        LPC_UART3->LCR    = 0x03;          
        LPC_UART3->FCR     = 0x07;              
        NVIC_EnableIRQ(UART3_IRQn);
        LPC_UART3->IER = 0x07;
}

void UART3_IRQHandler (void) 
{
        uint8_t IIRValue, LSRValue;
        uint8_t Dummy = 0;
        
        IIRValue = LPC_UART3->IIR;
    
        IIRValue >>= 1;         
        IIRValue &= 0x07; 
		
		if ( IIRValue == IIR_RLS )	
  		{
			LSRValue = LPC_UART3->LSR;
			if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) )
			{  	  
	  			UART3Status = LSRValue;
	  			Dummy = LPC_UART3->RBR;						
	  			return;
			}
			if ( LSRValue & LSR_RDR )			
			{ 	  
	  			IRQbuf[UART3Count] = LPC_UART3->RBR;
                UART3Count++;
                if ( UART3Count == BUFSIZE )
                {
                        UART3Count = 0;         
                } 	
			}
  		}
  		else if ( IIRValue == IIR_RDA )	
  		{		
			IRQbuf[UART3Count] = LPC_UART3->RBR;
                UART3Count++;
                if ( UART3Count == BUFSIZE )
                {
                        UART3Count = 0;         
                } 
  		}
  		else if ( IIRValue == IIR_CTI )	
  		{
			UART3Status |= 0x100;	
  		}
  		else if ( IIRValue == IIR_THRE )
  		{  
			LSRValue = LPC_UART3->LSR;									
			if ( LSRValue & LSR_THRE )
			{
	  			UART3TxEmpty = 1;
			}
			else
			{
	 			 UART3TxEmpty = 0;
			}
  		}
}


void InitUart0_115200 (void)
{
	DeInitUart0 ();
	LPC_SC->PCONP |= (1<<3);
	LPC_PINCON->PINSEL0 |= (1 << 4);             	
    LPC_PINCON->PINSEL0 |= (1 << 6);
	LPC_UART0->LCR    = 0x83;                          
	LPC_UART0->DLL    = 9;                             
	LPC_UART0->FDR    = 0x21;                          
	LPC_UART0->DLM    = 0;                           
	LPC_UART0->LCR    = 0x03;                          
}

int UART_putChar0 (uint8_t c) 
{
	while (!(LPC_UART0->LSR & 0x20));
	return (LPC_UART0->THR = c);
}

void UART_putString0 (uint8_t *s) 
{
	while (*s != 0) 
	{
		UART_putChar0 (*s++);
	}
}

uint16_t cgi_func (uint8_t *env, uint8_t *buf, uint16_t buflen, uint32_t *pcgi) 
{
	uint32_t len = 0;

	switch (env [0]) 
	{
		case 't':
		{
			len = sprintf ((S8 *) buf, (const S8 *) &env [2], PrintTime);
		}
		break;
		case 'd':
		{
			len = sprintf ((S8 *) buf, (const S8 *) &env [2], PrintDate);
		}
		break;		
		case 'a':
		{
			len = sprintf ((S8 *) buf, (const S8 *) &env [2], GPSCurDate);
		}
		break;
		case 'b':
		{
			len = sprintf ((S8 *) buf, (const S8 *) &env [2], GPSCurTime);
		}
		break;
		case 'c':
		{
			if (GPSStatus == 1)
			{
				len = sprintf ((S8 *) buf, (const S8 *) &env [2], "#00FF00");
			}
			if (GPSStatus == 0)
			{
				len = sprintf ((S8 *) buf, (const S8 *) &env [2], "#FF0000");
			}

		}
		break;
		case 'e':
		{
			len = sprintf ((S8 *) buf, (const S8 *) &env [2], (GPSPeriod/100));
		}
		break;
		case 'h':
		{
			if (GPSUseUpdate == 1)
			{
				len = sprintf ((S8 *) buf, (const S8 *) &env [2], "#00FF00");
			}
			if (GPSUseUpdate == 0)
			{
				len = sprintf ((S8 *) buf, (const S8 *) &env [2], "#FF0000");
			}

		}
		break;
		
	}
	return ((U16) len);
}

void cgi_process_data (uint8_t code, uint8_t *dat, uint16_t len) 
{
	uint8_t *var;

	uint8_t SecStr[3];
	uint8_t MinStr[3];
	uint8_t HourStr[3];
	uint8_t DayStr[3];
	uint8_t MonStr[3];
	uint8_t YearStr[5];
	uint8_t PeriodStr[5];
	uint32_t SecD;
	uint32_t MinD;
	uint32_t HourD;
	uint32_t DayD;
	uint32_t MonD;
	uint32_t YearD;
	uint32_t PeriodD;

	var = (uint8_t *) alloc_mem (40);
	do 
	{
		dat = http_get_var (dat, var, 40);
		//UART_putString0 (var);
		//UART_putString0 ("\n\n\n\n");
		if (var [0] != 0 ) 
		{
			if (str_scomp (var, "setdate") == __TRUE) 
			{
				strncpy(DayStr, var+8, 2);
				strncpy(MonStr, var+11, 2);
				strncpy(YearStr, var+14, 4);
				DayD = atoi(DayStr);
				if ((DayD != NULL) && (31 >= DayD) && (0 < DayD))
				{
					LPC_RTC->DOM = DayD;
				}
				MonD = atoi(MonStr);
				if ((MonD != NULL) && (12 >= MonD) && (0 < MonD))
				{
					LPC_RTC->MONTH = MonD;
				}
				YearD = atoi(YearStr);
				if ((YearD != NULL) && (2020 > YearD) && (2010 < YearD))
				{
					LPC_RTC->YEAR = YearD;
				}
				os_evt_set (EVT_WEB_TIME, t_WEB_PRINT);						
			}
			if (str_scomp (var, "settime") == __TRUE) 
			{
				strncpy(HourStr, var+8, 2);
				strncpy(MinStr, var+11, 2);
				strncpy(SecStr, var+14, 2);
				SecD = atoi(SecStr);
				if ((60 > SecD) && (0 <= SecD))
				{
					LPC_RTC->SEC = SecD;	
				}
				MinD = atoi(MinStr);
				if ((60 > MinD) && (0 <= MinD))
				{
					LPC_RTC->MIN = MinD;
				}
				HourD = atoi(HourStr);
				if ((24 > HourD) && (0 <= HourD))
				{
					LPC_RTC->HOUR = HourD;						
				}
				os_evt_set (EVT_WEB_TIME, t_WEB_PRINT);							 								
			}
			if (str_scomp (var, "changesetgps") == __TRUE) 
			{
				RTCSetTime (GPSCTime);
				os_evt_set (EVT_WEB_TIME, t_WEB_PRINT);			 								
			}
			if (str_scomp (var, "setgpstime") == __TRUE) 
			{
				strncpy(PeriodStr, var+11, 4);
				PeriodD = atoi(PeriodStr);
				if (PeriodD ==0)
				{
					GPSUseUpdate = 0;
				}
				if (PeriodD > 86401)
				{
					PeriodD = 86400;
				} 

				if ((PeriodD > 0) && (PeriodD < 86401))
				{
					GPSUseUpdate = 1;
					GPSPeriod = (PeriodD*100);
				} 			 								
			}
							
		}
	} while (dat);
	free_mem ((OS_FRAME *)var);
}

__task void f_GPS_TIME (void) 
{
	uint8_t n = 0;
	uint8_t SecStr[3];
	uint8_t MinStr[3];
	uint8_t HourStr[3];
	uint8_t DayStr[3];
	uint8_t MonStr[3];
	uint8_t YearStr[5];
	uint32_t SecD;
	uint32_t MinD;
	uint32_t HourD;
	uint32_t DayD;
	uint32_t MonD;
	uint32_t YearD;	
	uint8_t *c;
	uint8_t *s;	

	while (1)
	{
	strncpy(GPSbuf, IRQbuf, BUFSIZE);
	c = strstr (GPSbuf, "$GPRMC");
	s = strchr (c , 0x2C);

	strncpy(HourStr, s+1, 2);
	strncpy(MinStr, s+3, 2);
	strncpy(SecStr, s+5, 2);
	strncpy(TStatus, s+12, 1);
	if (TStatus[0] == 0x41)
	{
		GPSStatus = 1;
	}
	if (TStatus[0] == 0x56)
	{
		GPSStatus = 0;
	}

	SecD = atoi(SecStr);
	if ((60 > SecD) && (0 <= SecD))
	{
		GPSCTime.RTC_Sec = SecD;	
	}
	MinD = atoi(MinStr);
	if ((60 > MinD) && (0 <= MinD))
	{
		GPSCTime.RTC_Min = MinD;
	}
	HourD = atoi(HourStr);
	if ((24 > HourD) && (0 <= HourD))
	{
		HourD = HourD + 4;
		if (HourD > 24)
		{			
			GPSCTime.RTC_Hour = (24 - HourD);
		}
		else
		{
			GPSCTime.RTC_Hour = HourD;
		} 	
	}
	n = 0;
	while (n<8)
	{ 
   	s = strchr (s+1, 0x2C);
	n++;
	}
	strncpy(DayStr, s+1, 2);
	strncpy(MonStr, s+3, 2);
	strncpy(YearStr, s+5, 2);
	DayD = atoi(DayStr);
	if ((DayD != NULL) && (31 >= DayD) && (0 < DayD))
	{
		GPSCTime.RTC_Mday = DayD;
	}
	MonD = atoi(MonStr);
	if ((MonD != NULL) && (12 >= MonD) && (0 < MonD))
	{
		GPSCTime.RTC_Mon = MonD;
	}
	YearD = (atoi(YearStr) + 2000);
	if ((YearD != NULL) && (2020 > YearD) && (2010 < YearD))
	{
		GPSCTime.RTC_Year = YearD;
	}
	
	sprintf(GPSCurTime, "%02d:%02d:%02d", GPSCTime.RTC_Hour, GPSCTime.RTC_Min, GPSCTime.RTC_Sec);
	sprintf(GPSCurDate, "%02d/%02d/%04d", GPSCTime.RTC_Mday, GPSCTime.RTC_Mon, GPSCTime.RTC_Year);

	if (GPSUseUpdate == 1)
	{
		RTCSetTime (GPSCTime); 
	}
	os_dly_wait (GPSPeriod);
	} 
}

__task void f_WEB_PRINT (void) 
{
	uint8_t i = 0;

	while (1) 
	{
		os_evt_wait_or (EVT_WEB_TIME, 0xffff);

		CurrentTime = RTCGetTime();

		sprintf(PrintTime, "%02d:%02d:%02d", CurrentTime.RTC_Hour, CurrentTime.RTC_Min, CurrentTime.RTC_Sec);
		sprintf(PrintDate, "%02d/%02d/%04d", CurrentTime.RTC_Mday, CurrentTime.RTC_Mon, CurrentTime.RTC_Year);
	}
}

__task void f_LCD_PRINT (void) 
{
	uint8_t i = 0;

	while (1) 
	{
		CurrentTime = RTCGetTime();

		sprintf(PrintTime, "%02d:%02d:%02d", CurrentTime.RTC_Hour, CurrentTime.RTC_Min, CurrentTime.RTC_Sec);
		sprintf(PrintDate, "%02d/%02d/%04d", CurrentTime.RTC_Mday, CurrentTime.RTC_Mon, CurrentTime.RTC_Year);

		LCDgotoxy (1,2);
		LCDputs (PrintDate);		
		LCDgotoxy (13,2);
		LCDputs (PrintTime);

		os_evt_set (EVT_UART0_PRINT, t_UART0_PRINT);
		os_dly_wait (100);
	}
}

__task void f_UART0_PRINT (void) 
{
	while (1) 
	{
		os_evt_wait_or (EVT_UART0_PRINT, 0xffff);
		
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		UART_putChar0 (0x08);
		
		UART_putString0 (PrintDate);
		UART_putString0 ("  ");
		UART_putString0 (PrintTime);
										
		os_evt_set (EVT_LIFE_LED, t_LIFE_LED);
	}
}

__task void f_LIFE_LED (void) 
{
	uint8_t i = 1;
	while (1) 
	{
		os_evt_wait_or (EVT_LIFE_LED, 0xffff); 
		if (i)
		{
			LEDon(0);
			i=!i;
		}
		else
		{
			LEDoff(0);
			i=!i;
		}        
    }
}

__task void f_TIMER_HTTP (void) 
{
	os_itv_set (10);
	while (1) 
	{
		os_itv_wait ();
		timer_tick ();
	}
}

__task void f_HTTP (void) 
{
	while (1) 
	{
		main_TcpNet ();
		os_tsk_pass ();
	}
}

__task void init (void) 
{	
	os_tsk_prio_self (100);	
	
	t_TIMER_HTTP = os_tsk_create (f_TIMER_HTTP, 99);
	UART_putString0 ("\nTask - TIMER_HTTP Started\n");
	t_GPS_TIME = os_tsk_create_user (f_GPS_TIME, 50, &gps_print_stack, sizeof(gps_print_stack));
	UART_putString0 ("Task - GPS_HTTP Started\n");
	t_WEB_PRINT = os_tsk_create (f_WEB_PRINT, 40);
	UART_putString0 ("Task - WEB_PRINT Started\n");
	t_LCD_PRINT = os_tsk_create_user (f_LCD_PRINT, 4, &lcd_print_stack, sizeof(lcd_print_stack));
	UART_putString0 ("Task - LCD_PRINT Started\n");
	t_UART0_PRINT = os_tsk_create (f_UART0_PRINT, 3);
	UART_putString0 ("Task - UART0_PRINT Started\n");
	t_LIFE_LED = os_tsk_create (f_LIFE_LED, 2);
	UART_putString0 ("Task - LIFE_LED Started\n");
	t_HTTP = os_tsk_create_user (f_HTTP, 1, &tcp_stack, sizeof(tcp_stack));
	UART_putString0 ("Task - HTTP Started\n");
	
	UART_putString0 ("\nOS Started\n\n"); 
	os_tsk_delete_self (); 
}



int main (void)
{
	SystemInit ();
	InitUart0_115200 ();
	InitUart3_38400 ();
	UART_putString0 ("\n\nStarting ... \n\n");

	InitLCD ();
	LCDgotoxy (2,1);
	LCDputs ("Starting ...");

	InitLEDs ();
	UART_putString0 ("LEDs Inited\n");

	InitRTC ();
	
	CurrentTime = RTCGetTime();
	CurYear = CurrentTime.RTC_Yday; 
	CurMon = CurrentTime.RTC_Mon;
	CurDay = CurrentTime.RTC_Mday;
	
	if ((2010 < CurYear) || ((2020 < CurYear)))
	{
		
		LPC_RTC->SEC = 0;
		LPC_RTC->MIN = 0;
		LPC_RTC->HOUR = 1;
		LPC_RTC->DOM = 1;
		LPC_RTC->MONTH = 1;
		LPC_RTC->YEAR = 2011; 
		
	}	
	if ((CurMon == 0) || (CurMon > 12))
	{
		
		LPC_RTC->SEC = 0;
		LPC_RTC->MIN = 0;
		LPC_RTC->HOUR = 1;
		LPC_RTC->DOM = 1;
		LPC_RTC->MONTH = 1;
		LPC_RTC->YEAR = 2011; 
		
	}
	if ((CurDay ==0) || (CurDay > 31))
	{
		
		LPC_RTC->SEC = 0;
		LPC_RTC->MIN = 0;
		LPC_RTC->HOUR = 1;
		LPC_RTC->DOM = 1;
		LPC_RTC->MONTH = 1;
		LPC_RTC->YEAR = 2011; 
		
	}
	
	UART_putString0 ("\nRTC Inited\n\n");

	while ((retv = finit ()) != 0) 
	{    
    	if (retv == 1) 
		{
			UART_putString0 ("SD/MMC Init Failed\n");
			UART_putString0 ("Insert Memory card and press key...\n");
		}
    	else 
		{
			UART_putString0 ("SD/MMC Card is Unformatted\n");
			if (fformat ("M:SD_CARD") != 0) 
			{
    			UART_putString0 ("SD Memory Card format failed.\n");
  			}
  			else 
			{
    			UART_putString0 ("SD Memory Card formatted.\n");
  			}

		}
	}

	mmc_read_config (&SDCardCfg);
	sprintf (outBuf, "SerNr:  0x%08X", SDCardCfg.sernum);
  	UART_putString0 (outBuf);
  	sprintf (outBuf, " BlockNr:0x%08X", SDCardCfg.blocknr);
  	UART_putString0 (outBuf);
  	sprintf (outBuf, " RdLen:  0x%04X", SDCardCfg.read_blen);
  	UART_putString0 (outBuf);
  	sprintf(outBuf, " WrLen:  0x%04X", SDCardCfg.write_blen);
  	UART_putString0 (outBuf);
	sprintf(outBuf, "\n\n%d bytes free.\n", ffree("M:"));
	UART_putString0 (outBuf);
	UART_putString0 ("\nSD/MMC Inited\n");

	init_TcpNet ();
	UART_putString0 ("\nTCP/IP Inited\n");

	UART_putString0 ("\nOS Starting ...\n");
	ClrLCD (); 
	os_sys_init(init);

}

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

RSS свернуть / развернуть
Появилось свободное время. Начал оформлять в коробки (рассовывать по корпусам).
0
А что это заплаты вообще и где ты их взял?
0
  • avatar
  • Aneg
  • 06 января 2012, 22:50
starterkit.ru
0
Если у тебя есть eth, то зачем GPS? корректировка по NTP вполне со всем справляется.
0
Инет не стабилен. То есть, то нет. В деревне живу.
0
Не подскажете каким образом в RL-ARM можно «вручную» формировать HTTP ответы? Мне нужно динамически формировать страницу исходя из данных на SD-карте и передовать достаточно внушительные объемы данных. Хранить веб-страницу теми способоми, что описаны в мануле мне нельзя.
0
Так может хранить и страницы и данные на SD карте или USB-флэшке?
0
Нет, в том то как раз и дело, что просто веб-сервер с флешки не подходит. У меня есть журнал событий, который может накопить приличный объем данных за время работы. Поэтому мы хотим динамически подгружать новые данные посредством методов GET и POST, чтобы каждый раз при обновлении не таскать журнал целиком. А вот можно ли получить «распарсенный» HTTP в RL-ARM я так и не понял.
0
Только зарегистрированные и авторизованные пользователи могут оставлять комментарии.