Individální projekty MPOA

Tato stránka je pouze pro čtení. Můžete si pouze prohlédnout zdrojový kód, ale ne ho měnit. Zeptejte se správce, pokud si myslíte, že něco není v pořádku.
===== Zadání =====

Navrhněte jednotku MCU_board s procesorem LPC1111JHN33/103, umožňující ovládání externě připojeného LNA. MCU_board je bateriově napájená. Pomocí vhodné řídící logiky zajistěte: kontrolu napětí baterie, řízené nabíjení baterie po připojení externího nabíjecího adaptéru, odpojování napájení od externího LNA při nabíjení a komunikaci s PC, signalizaci stavu pomocí LED (zařízení ready, vybitá baterie apod.), výpis aktuálního stavu do PC. Součástí externího LNA je 7-bitový digitální (SPI) atenuátor Skyworks SKY12343-364LF, pro který vytvořte drivery.

----
===== Úvod =====
Cílem projektu je sestavit kompletní HW včetně obslužného FW, umožňující řízení externí DPS realizující nízkošumový předzesilovač, jehož součástí je digitální atenuátor, ovládatelný přes SPI. Aby bylo zařízení kompaktní, bude pro napájení využit Li-Ion akumulátor (CL-18650-26H/2S1P - https://www.tme.eu/cz/Document/aaa419bfc53b2c461a40a88733ebb793/1130.00.00.PDF). 

===== Řešení =====

Protože při psaní FW přestal být procesor LPC1111JHN33/103 dostačující (především flash paměť), byl v průběhu vývoje nahrazen procesorem LPC11U34FHN33/311 (https://www.nxp.com/products/processors-and-microcontrollers/arm-based-processors-and-mcus/lpc-cortex-m-mcus/lpc1100-cortex-m0-plus-m0/40kb-flash-8kb-sram-hvqfn32-package:LPC11U34FHN33), obsahující především větší flash paměť a nově vnitřní paměť EEPROM. Procesor je napájen napětím 3.3V. Hodinový signál je zajištěn externím krystalem 12 MHz. Stejně tak umožňuje v budoucnu použití USB bez externího driveru (FTDI). Schéma disponuje drobnými úpravami, které nejsou promítnuty ve verzi DPS, pro kterou byl psán FW - jde o nepatrné úpravy typu odstranění již zbytečných jumperů, využití stabilizátorů s vyšším proudovým zatížením, nahrazení 2 SMD LED za RGB LED, možnost nevyužití FTDI. 

{{ :2017:msedlak:sch.png?direct&600 |}}
<code> Obr.1 Schéma zapojení MCU_board </code>

Pro vývoj FW je využíváno prostředí LPCXpresso v8.1.4 [Build 606] s využitím platformy LPCOpen v2.03 pro procesory LPC11XX (https://www.nxp.com/support/developer-resources/software-development-tools/lpc-developer-resources-/lpcopen-libraries-and-examples/lpcopen-software-development-platform-lpc11xx:LPCOPEN-SOFTWARE-FOR-LPC11XX). 
Běh programu je zajištěn pomocí handlerů:
<code c>
int main(void) {

	MySystemInit();
	eeprom.iap_return_code = IAP_read_eeprom( (char*)TARGET_EEPROM_ADDRESS, mem, MEM_SIZE ); // default set of attenuator after reset (read from eeprom memory)
	eeprom.actual_attenuation = ((100 * mem[ATT_INTEGERS]) + (mem[ATT_TENTHS]));
        if (eeprom.iap_return_code == 0) //eeprom_read_OK
     	    sky12343_driver(mem[ATT_INTEGERS],mem[ATT_TENTHS]);

	while(1) {
    	    if (flags.ms)
    	    {
    		flags.ms = false;
    		ADC_read_all_channels();
    		if (!DEBUG_MODE)
    		WDT_RESET();
    	    }

    	    if(flags.sec)
    	    {
     	        flags.sec = false;
    	        Signalization_handler();
    	        PC_detection_handler();
    	        Charge_handler();
    	        Uart_handler();
    	      }
        }
    return 0 ;
}

void SysTick_Handler(void)
{
	flags.ms = true;
	ms_tick++;

	if(ms_tick == 1000)
	{
		ms_tick = 0;
		flags.sec = true;
	}
}
</code>

==== Nabíjení: ====
Nabíjecí část je ve schématu v levém dolním rohu. Tato část je složena ze vstupní ochrany proti přepólování a přepětí na vstupním konektoru. Součástí je i vratná 1.1A pojistka. Jako nabíjecí obvod je využit IO MCP73213 (http://ww1.microchip.com/downloads/en/DeviceDoc/20002190C.pdf). 

Pomocí AD převodníku procesoru je snímání napětí na napájecím konektoru. Je-li toto napětí větší než 10V, dojde k sepnutí tranzistoru pomocí pinu procesoru CHARGE_CURRENT_SET, což zajistí snížení odporu na pinu PROG nabíjecího obvodu. Je-li napětí akumulátoru menší než 7,4V nabíjecí obvod změní stav pinu STAT na stav nízké impedance, což zapříčiní změnu napětí na pinu procesoru STAT_DET (z 3V0 na 0V). Nabíjení je v této fázi aktivní. Jakmile je akumulátor nabit, nabíjecí obvod změní pin STAT na úroveň vysoké impedance, pin procesoru STAT_DET změní napětí z 0V na 3V0 - nabíjení je kompletní a procesor rozpojí tranzistor na pinu CHARGE_CURRENT_SET, díky čemuž přejde nabíjecí obvod do režimu shutdown. Po celou dobu nabíjení je externí LNA odpojeno. 
Handler obsluhující nabíjení:
<code c>
extern void Charge_handler(void)
{
	if((voltage.ext_pwr < EXT_PWR_TRESHOLD) && (voltage.battery_voltage > BATTERY_CHARGED))
	{
		flags.charging = false;
		flags.batt_charged = true;
		flags.batt_need_charging = false;
		if(state != pc_connected)
		state = normal_operation;
		RF_SUPPLY_EN(true);
	}
	else if((voltage.ext_pwr < EXT_PWR_TRESHOLD) && (voltage.battery_voltage < BATTERY_CHARGED))
	{
		flags.charging = false;
		flags.batt_need_charging = true;
		flags.batt_charged = false;
		state = batt_need_charging;
		RF_SUPPLY_EN(true);
	}

	if(voltage.ext_pwr > EXT_PWR_TRESHOLD)
	{

		if(!flags.charging)
		{
			CHARGE_CURRENT_SET(true);
			delay_us(750); 
			ADC_read_channel_fast(adc_stat_det);

			if(voltage.stat_det > STAT_DET_TRESHOLD)
			{
				CHARGE_CURRENT_SET(false);
				flags.charging = false;
			}
			else
			{
				flags.charging = true;
				flags.batt_charged = false;
				state = charging;
				RF_SUPPLY_EN(false);
			}
		}
		else if((voltage.stat_det > STAT_DET_TRESHOLD) && (flags.charging == true))
		{
			flags.charging = false;
			flags.batt_need_charging = false;
			flags.batt_charged = true;
			state = normal_operation;
			CHARGE_CURRENT_SET(false);
			RF_SUPPLY_EN(true);
		}
		else
		{
			// charging succesfully running
		}
	}
	else if((voltage.ext_pwr > EXT_PWR_TRESHOLD) && (voltage.battery_voltage < BATT_CHARGE_TRESHOLD))
	{
		state = charging_err; 
	}
}

</code>

Využitím pravidelného logování (1x za 5 min) byla změřena nabíjecí křivka:
{{ :2017:msedlak:nabijeni.png?direct&400 |}}

Stejným způsobem byla změřena vybíjecí křivka, při připojeném LNA, jehož spotřeba je cca 130 mA:
{{ :2017:msedlak:vybijeni.png?direct&400 |}}


==== Komunikace a ovládání: ====
Komunikace přes USB je realizována pomocí externího FTDI driveru. Ve schématu je komunikace v pravém dolním rohu. Protože FTDI by při napájení napětí 3V3 potřeboval externí krystal, je napájen přímo z USB. FTDI a celá komunikace je tedy aktivní pouze v případě, že dojde k připojení USB konektoru. Vzhledem k tomu, že procesor je napájen 3V3, bylo nutné využít level shifter (3V3 <-> 5V), který je opět napájen pouze v případě, že je připojen USB konektor. Komunikace je nastavena na 9600 Bd, 8N1 a je využito kruhových bufferů pro RX a TX. 
Handler zajišťující detekci připojení k PC:
<code c>
extern void PC_detection_handler(void)
{
	if(voltage.usb_voltage > USB_VOLTAGE_TRESHOLD && (!flags.uart))
	{
		flags.uart = true;
		Chip_UART_Init(LPC_USART);
		RF_SUPPLY_EN(false);
		state = pc_connected;
	}
	else if((voltage.usb_voltage < USB_VOLTAGE_TRESHOLD) && ((state == pc_connected) || (state == batt_need_charging)))
	{
		flags.uart = false;
		Chip_UART_DeInit(LPC_USART);

		if(flags.charging)
		{
			state = charging;
			RF_SUPPLY_EN(false);
		}
		else if(flags.batt_need_charging)
		{
			RF_SUPPLY_EN(true);
			state = batt_need_charging;
		}
		else if(flags.charging_err)
		{
			RF_SUPPLY_EN(true);
			state = charging_err;
		}
		else
		{
			state = normal_operation;
			RF_SUPPLY_EN(true);
		}
	}
}
</code>

Je-li USB připojen, řídící DPS začne posílat pravidelnou zprávu (aktuálně po 1s), obsahující informace o aktuálním stavu. Součástí této zprávy je synchronizační znak (AA 11), dále struktura obsahující jednotlivá napětí [mV] (napětí externě připojeného adaptéru, detektor nabíjecího obvodu pomocí jeho pinu STAT, napětí USB, napájecí napětí nízkošumového předzesilovače, napětí akumulátoru), IAP kód určující, zda bylo správně zapsáno do pamětí EEPROM, aktuální hodnotu nastaveného útlumu digitálního atenuátoru, hodnoty všech flagů. 
Příklad takové zprávy je např:<code>
11 AA 11 02 C4 0B 8A 13 14 00 47 20 00 00 1A 04 C9 00 
</code>
Rozparsováním lze získat zpětně jednotlivé informace:

{{ :2017:msedlak:ramec.png?direct&300 |}}

V budoucnu tato data budou rozparsována a prezentována pomocí jednoduché PC aplikace.

Vytváření informační zprávy:
<code c>
extern void Uart_handler(void)
{
	static uint16_t start_byte[] = {0xAA11};
	static uint16_t buff[BUFF_LENGTH];
	static uint8_t rx_buff[CMD_RX_LENGTH];

	if(flags.uart)
	{
		uint16_t *p_buff = buff;
		memcpy(p_buff,start_byte,sizeof(start_byte));
		p_buff += (sizeof(start_byte) / sizeof(start_byte[0]));
		memcpy(p_buff, &voltage, sizeof(voltage));
		p_buff += sizeof(voltage)/sizeof(uint16_t);
		memcpy(p_buff,&eeprom,sizeof(eeprom));
		p_buff += sizeof(eeprom)/sizeof(uint16_t);
		memcpy(p_buff,&flags,sizeof(flags));
		Chip_UART_SendRB(LPC_USART,&txring.data,&buff,sizeof(buff));
		Chip_UART_ReadRB(LPC_USART, &rxring.data, &rx_buff, sizeof(rx_buff));
		Uart_cmd_processing(rx_buff);
	}
}
</code>
Posláním zprávy (např. pomocí programu Terminal) lze nastavit externí atenuátor (http://www.skyworksinc.com/uploads/documents/201355C.pdf). Například, pro nastavení hodnoty útlumu 11,5 dB je nutné poslat sekvenci 11150, kde 1 je příkaz pro nastavení atenuátoru, 11 je hodnota celočíselného útlumu v dB a 50 je hodnota desetinné části útlumu. Pomocí logického analyzátoru lze po zadání tohoto příkazu vidět data, která odpovídají požadovanému nastavení dle katalogového listu:
{{ :2017:msedlak:spi_com.png?direct&400 |}}

Tato nastavená hodnota je současně uložena do vnitřní EEPROM paměti, která je přístupná pomocí IAP. Pro její využití byly využity a lehce upraveny zdrojové soubory dostupné na https://os.mbed.com/users/okano/code/IAP/ Hodnota nastaveného útlumu uložená v EEPROM je pak při resetu vyčtena z paměti a atenuátor je nastaven na hodnotu útlumu vyčteného z EEPROM. Není tak třeba vždy po resetu nutné nastavovat požadovaný útlum stále znovu. 

==== Signalizace: ====

Pro signalizaci jsou aktuálně využity 2 smd LED (zelená a červená). Na budoucí verzi (která je i ve schématu), bude využito RGB led, nicméně signalizace bude stejná. 
  * Zelená led bliká, červená zhasnutá - stav nabíjení. LNA je odpojeno, akumulátor se nabíjí
  * Červená led bliká, zelená zhasnutá - stav nízkého napětí akumulátoru. LNA je napájeno, akumulátor je třeba dobít
  * Zelená i červená led bliká - při pokusu o nabíjení došlo k chybě. LNA je napájeno.
  * Zelená led svítí, červená zhasnutá - normální stav, značící běžnou funčknost. LNA je napájeno, UART a nabíjení neaktivní.
  * Zelená i červená led svítí - k DPS je připojeno USB. LNA je odpojeno, komunikace s PC je aktivní
  * Zelená led bliká, červená svítí - k DPS je připojeno USB. LNA je odpojeno, komunikace s PC je aktivní a dochází k nabíjení akumulátoru
  * Žádná led nesvítí - defuaultní stav

<code c>
extern void Signalization_handler(void)
{
	switch(state)
	{
		case charging:
			LED_GREEN_BLINKING;
			LED_RED(false);
			break;
		case batt_need_charging:
			LED_RED_BLINKING;
			LED_GREEN(false);
			break;
		case charging_err:
			LED_GREEN_BLINKING;
			LED_RED_BLINKING;
			break;
		case normal_operation:
			LED_GREEN(true);
			LED_RED(false);
			break;
		case pc_connected:
			if(flags.charging)
			{
				LED_GREEN_BLINKING;
				LED_RED(true);
			}
			else
			{
				LED_GREEN(true);
				LED_RED(true);
			}
			break;
		default:
			LED_GREEN(false);
			LED_RED(false);
			break;
	}
}
</code>

==== Videoukázka: ====
Ve videoukázce je LNA nahrazen vývodovou LED, která svítí v případě že má být napájeno. Opačně je LED zhasnuta. 

{{youtube>23a6nrlqmTg?medium}}
==== Projekt včetně zdojových kódů: ====

{{ :2017:msedlak:mcu_board_lpcxpresso.zip |}}
 
===== Závěr =====
Byl navržen HW a napsán FW umožnující automatické ovládání externě připojeného nízkošumového předzesilovače. Hlavní činností je kontrola napětí akumulátoru, jeho řízené nabíjení, odpojování nízkošumového předzesilovače v situacích, při kterých není nutné jeho napájení (se kterou je spojen jeho velký proudový odběr). Prostřednictvím USB umožňuje jednotka ovládat digitální atenuátor, který je součástí nízkošumového předzesilovače. Stejně tak dochází k pravidelným informačním zprávám z MCU_board.

Vzhledem k faktu, že je využit procesor umožňující využití USB bez přídavného driveru (FTDI), bude snaha o rozchození USB bez použití FTDI. Stejně tak bude v blízké době napsána PC aplikace umožňující zobrazování informací o aktuálním stavu zařízení.
Individální projekty MPOA

Uživatelské nástroje

Nástroje pro tento web

Nástroje pro stránku
