0
В основном все на IAR'е
Ещё Keil есть.
Eclipce сидят
Eclipse — не компилятор вообще, а IDE поддерживающая разные языки (Java/PHP/C++ и тд). Может и для CLang версию сделают.
  • avatar
  • artjom
  • 28 ноября 2014, 16:51
0
Упс, не успел.
:)
  • avatar
  • artjom
  • 28 ноября 2014, 15:56
0
По выходу имеем обратный процесс: {TIMSK |= 1<<bit; cli();}
Правильнее так:

cli();
TIMSK |= 1<<bit; 
  • avatar
  • artjom
  • 28 ноября 2014, 15:41
0
Скорее всего нет либ,
Да, наверное.
'hard' даёт на 5-10% более быстрый код.
Не слишком большая разница… Интересно почему так. Чем эти опции отличаются?
  • avatar
  • artjom
  • 26 ноября 2014, 16:58
0
А с какой опцией -mfloat-abi компилировалось, 'softfp' или 'hard'?
Попробовал собрать проект с опцией 'hard' — вообще не собралось… Что бы это значило? Тулчайн (или его либы) не поддерживает данную опцию?
Тулчайн — Yagarto.
  • avatar
  • artjom
  • 26 ноября 2014, 16:42
0
Смотря как оформить.
Для меня вобщем-то вопрос — как кооперативку наглядно оформить. Всё как-то хуже RTOS выглядит.
  • avatar
  • artjom
  • 21 ноября 2014, 12:20
0
Правильно это когда все работает и удовлетворяет требованиям ТЗ
Ну это да, ТЗ это главное.

А как оно реализовано совершенно неважно.
Ну не совсем уж неважно, программу как правило надо бывает дорабатывать, исправлять ошибки и тд.
  • avatar
  • artjom
  • 21 ноября 2014, 12:06
0
Вытесняйка, по моему, в avr & stm8, перебор.
АВРы разные бывают: ОЗУ до 8-16кБ, FLASH — до 256 кБ и можно ешё и внешнюю RAM подключить. Вполне себе достаточно для вытесняющеё ОСи.

Вполне хватает кооперативки
У кооперативки код не такой наглядный.

кооперативки аля DI,
Где на неё можно посмотреть?

рам жрет мало.
Рамы хватает.
  • avatar
  • artjom
  • 21 ноября 2014, 12:02
0
А начал я, как следует из заголовка, с самого простого и необходимого модуля — программных таймеров.

Возникает резонный вопрос — а зачем, собственно, это нужно?
Правильная постановка вопроса. Не нужно это…

Почему не использовать ОС с вытеснением? Ну неправильно это — в прерывании функции по списку вызывать — пережаваёте это дело задаче с соответствующим приоритетом.
  • avatar
  • artjom
  • 21 ноября 2014, 01:41
0
В свойствах проекта должна быть галка «Generate List files». Или у вас нету такой? Расширение файла — LLS.
Или у вас ассемблер?
  • avatar
  • artjom
  • 31 октября 2014, 16:39
+1
если уже написаны библиотекы дле переферии на С++
Да кто ж их писать-то будет. Как правило производители МК на С++ библиотек не делают. Остаётся только самому писать.
а логику делать на С++ — мне кажеться так будет удобней.
Да, на плюсах логику делать удобней.
P.S. Для С++ лучше xmega подходит — у неё периферия удобнее сделана.
Приведу пару примеров для периферии.
SPI на Си++:

#ifndef spi_template_h__
#define spi_template_h__


#include <ioavr.h>
#include "avr_compiler.h"

template <char port> struct xm_spi_t;

template<> struct xm_spi_t<'C'>
{
	enum {
		SPI_BASE = 0x8C0
	};
	enum {
		SS_PORT_BASE = 0x0640
	};
};

template<> struct xm_spi_t<'D'>
{
	enum {
		SPI_BASE = 0x9C0
	};
	enum {
		SS_PORT_BASE = 0x0660
	};
};

template<> struct xm_spi_t<'E'>
{
	enum {
		SPI_BASE = 0x9C0
	};
	enum {
		SS_PORT_BASE = 0x0680
	};
};

template<> struct xm_spi_t<'F'>
{
	enum {
		SPI_BASE = 0xAC0
	};
	enum {
		SS_PORT_BASE = 0x06A0
	};
};

template<char port> struct Spi;

template<char port>
struct Spi
{
	enum { SPI_BASE = xm_spi_t<port>::SPI_BASE };
	
	static struct
	{
		SPI_t* operator-> () { return (SPI_t *)SPI_BASE; }
	} SPIx;

	enum { SS_PORT_BASE = xm_spi_t<port>::SS_PORT_BASE };
	static struct 
	{
		PORT_t* operator-> () { return (PORT_t *)SS_PORT_BASE; }

	} SS_PORTx;

	static void SendByte(unsigned char byte_for_send)
	{
		SPIx->DATA=byte_for_send;
		WaitWhileBusy();
	}
	static unsigned char ReadByte()
	{
		SPIx->DATA=0;
		WaitWhileBusy();
		return SPIx->DATA;
	}
	static void WaitWhileBusy() {
		while ((SPIx->STATUS & SPI_IF_bm) == 0) ;
	}
	static void SendBuffer(unsigned char *data_for_send, unsigned short data_length)
	{
		do {
			SPIx->DATA=*data_for_send++;
			data_length--;
			WaitWhileBusy();
		} while (data_length);
	}
	static void TranceiveData(unsigned char *data_for_send, unsigned char send_data_length, unsigned char * data_buffer_for_read, unsigned short read_data_length)
	{
		SendBuffer(data_for_send, send_data_length);

		do {
			SPIx->DATA=0x00;
			read_data_length--;
			WaitWhileBusy();
			*data_buffer_for_read++=SPIx->DATA;
		} while (read_data_length);
	}
	static void ClearSS()
	{
		SS_PORTx->OUTCLR=PIN4_bm;
		nop();
		nop();
	}
	static void SetSS()
	{
		SS_PORTx->OUTSET=PIN4_bm;
		nop();
		nop();
	}
	static void InitSpiMaster(SPI_PRESCALER_t prescaler)
	{
		/* Init SS pin as output with wired AND and pull-up. */
		SS_PORTx->DIRSET = PIN4_bm;
		SS_PORTx->PIN4CTRL = PORT_OPC_TOTEM_gc;
		/* Set SS output to high. (No slave addressed). */
		SS_PORTx->OUTSET = PIN4_bm;

		/* MOSI and SCK as output. */
		//SS_PORTx->DIRSET  = SPI_MOSI_bm | SPI_SCK_bm;
		SS_PORTx->DIRSET  = PIN5_bm | PIN7_bm;

		/* Instantiate pointer to ssPort. */
		SPIx->CTRL   = 
			SPI_MASTER_bm |
			SPI_CLK2X_bm |
			SPI_ENABLE_bm |prescaler;
		SPIx->INTCTRL=SPI_INTLVL_OFF_gc;
	}
};

#endif // spi_template_h__

ДМА:

#ifndef DMA_TEMPLATE_H_
#define DMA_TEMPLATE_H_

#include "avr_compiler.h"

class critical_section_t
{
public:
	critical_section_t() : StatusReg( SREG ) { cli(); }
	~critical_section_t() { SREG = StatusReg; }

private:
	unsigned char StatusReg;

};

#define CRITICAL_SECTION() critical_section_t cs




template<char channel_number> struct dma_channel
{
	enum {
		DMA_CH0_BASE = 0x110,
		DMA_CH1_BASE = 0x120,
		DMA_CH2_BASE = 0x130,
		DMA_CH3_BASE = 0x140,
	};
	static struct
	{
		DMA_CH_t* operator-> () {
			switch (channel_number) {
			case '0':
				return (DMA_CH_t *)DMA_CH0_BASE;
				break;
			case '1':
				return (DMA_CH_t *)DMA_CH1_BASE;
				break;
			case '2':
				return (DMA_CH_t *)DMA_CH2_BASE;
				break;
			case '3':
				return (DMA_CH_t *)DMA_CH3_BASE;
				break;
			}
			while (1) ;
			return 0;
		}

	} DMA_CH;
	
	INLINE static void ResetChannel()
	{
		DMA_CH->CTRLA = DMA_CH_RESET_bm;
	}
	INLINE static void SetSrcAddress(uint16_t address)
	{
		CRITICAL_SECTION();

		DMA_CH->SRCADDR0=address & 0xFF;
		DMA_CH->SRCADDR1=address>>8;
		DMA_CH->SRCADDR2=0;
	}
	INLINE static void SetDestAddress(uint16_t address)
	{
		CRITICAL_SECTION();
		
		DMA_CH->DESTADDR0=address & 0xFF;
		DMA_CH->DESTADDR1=address>>8;
		DMA_CH->DESTADDR2=0;
	}
	INLINE static void SetTransferSize(uint16_t length)
	{
		CRITICAL_SECTION();
		DMA_CH->TRFCNT=length;
	}
	INLINE static void SetRepeatCount(uint8_t block_number)
	{
		DMA_CH->REPCNT=block_number;
	}
	INLINE static void SetTriggerSource(DMA_CH_TRIGSRC_enum trigger)
	{
		DMA_CH->TRIGSRC=trigger;
	}
	INLINE static void SetAddressControl(DMA_CH_SRCRELOAD_enum src_reload, DMA_CH_SRCDIR_enum src_dir, DMA_CH_DESTRELOAD_enum dest_reload, DMA_CH_DESTDIR_enum dest_dir)
	{
		DMA_CH->ADDRCTRL= 0
			| (uint8_t)src_reload
			| (uint8_t)src_dir
			| (uint8_t)dest_reload
			| (uint8_t)dest_dir
			;
	}
	INLINE static void StartPeripheralTransfer(DMA_CH_BURSTLEN_enum burst_size, bool repeat_enable)
	{
		DMA_CH->CTRLA= 0
			| (1<<DMA_CH_ENABLE_bp)
			| (0<<DMA_CH_RESET_bp)
			| (repeat_enable ? (1<<DMA_CH_REPEAT_bp) : (0<<DMA_CH_REPEAT_bp))
			| (0<<DMA_CH_TRFREQ_bp)
			| 1<<DMA_CH_SINGLE_bp
			| (uint8_t) burst_size
			;
	}
	INLINE static void StartRamToRamTransfer(DMA_CH_BURSTLEN_enum burst_size)
	{
		DMA_CH->CTRLA= 0
			| (1<<DMA_CH_ENABLE_bp)
			| (0<<DMA_CH_RESET_bp)
			| (0<<DMA_CH_REPEAT_bp)
			| (1<<DMA_CH_TRFREQ_bp)
			| (0<<DMA_CH_SINGLE_bp)
			| (uint8_t) burst_size
			;
	}
	INLINE static void ClearIntFlags(bool clear_error_flag, bool clear_trnif)
	{
		CRITICAL_SECTION();

		uint8_t ctrlb = DMA_CH->CTRLB;
		ctrlb = ctrlb 
			| (clear_error_flag ? (1<<DMA_CH_ERRIF_bp) : (0<<DMA_CH_ERRIF_bp))
			| (clear_trnif ? (1<<DMA_CH_TRNIF_bp) : (0<<DMA_CH_TRNIF_bp))
			;
		DMA_CH->CTRLB =ctrlb;
	}
	INLINE static void SetInterruptLevel(DMA_CH_ERRINTLVL_enum error_int_level, DMA_CH_TRNINTLVL_enum complete_int_level)
	{
		DMA_CH->CTRLB = 0
			| (1<<DMA_CH_ERRIF_bp)
			| (1<<DMA_CH_TRNIF_bp)
			| (uint8_t) error_int_level
			| (uint8_t) complete_int_level
			;
	}
	INLINE static void ClearIntFlags(DMA_CH_ERRINTLVL_enum error_int_level, DMA_CH_TRNINTLVL_enum complete_int_level)
	{
		DMA_CH->CTRLB = 0
			| (1<<DMA_CH_ERRIF_bp)
			| (1<<DMA_CH_TRNIF_bp)
			| (uint8_t) error_int_level
			| (uint8_t) complete_int_level
			;
	}
	INLINE static bool TransferComplete()
	{
		return (DMA_CH->CTRLA & DMA_CH_ENABLE_bm) ? false : true;
	}
	INLINE static void SetSrcAddressFast(uint16_t address)
	{
		DMA_CH->SRCADDR0=address & 0xFF;
		DMA_CH->SRCADDR1=address>>8;
		DMA_CH->SRCADDR2=0;
	}
	INLINE static void SetDestAddressFast(uint16_t address)
	{
		DMA_CH->DESTADDR0=address & 0xFF;
		DMA_CH->DESTADDR1=address >> 8;
		DMA_CH->DESTADDR2=0;
	}
	INLINE static void SetTransferSizeFast(uint16_t length)
	{
		DMA_CH->TRFCNT=length;
	}
	INLINE static bool MultiBlockTransferComplete()
	{
		return DMA_CH->REPCNT ? false : true;
	}
};

INLINE static void DmaReset()
{
	DMA.CTRL=DMA_RESET_bm;
}

INLINE static void DmaEnable(DMA_DBUFMODE_enum double_buffer_mode, DMA_PRIMODE_enum priority_mode)
{
	DMA.CTRL = 0
		| (1<<DMA_ENABLE_bp)
		| (0<<DMA_RESET_bp)
		| ((uint8_t)double_buffer_mode)
		| ((uint8_t)priority_mode)
		;
}

#endif /* DMA_TEMPLATE_H_ */
  • avatar
  • artjom
  • 31 октября 2014, 15:41
+1
Наверное не буду юзать С++ в AVR
Зачем себя ограничивать-то.
Наверное не буду юзать С++ в AVR
А на АРМ будете? Как будто есть какая-то принципиальная разница между этими типами МК…
  • avatar
  • artjom
  • 31 октября 2014, 15:20
0
Там еще FIQ есть
В ARM7 FIQ есть, но там нет SysTick.
Причем емнип на них сидит прерывание систика.
Скорее на FIQ висит прерывание Hard_Fault.
  • avatar
  • artjom
  • 30 октября 2014, 12:28
0
всегда удается выбрать только 2 варианта
Как-то можно и три выбрать. Можно попробывать использовать явную специализацию шаблона. Может что и получится (правда, на 100% я не уверен)…
  • avatar
  • artjom
  • 29 октября 2014, 12:33
0
ровно ничего такого, чего нет в библиотеках, в том-то и дело
C библиотекой разобраться тоже нужно время. А так как задача простая, то можно и сразу без библиотек её решать.
  • avatar
  • artjom
  • 28 октября 2014, 19:48
+3
А вот использование регистров напрямую намекает на недостаточную зрелость адепта.
Но показывает способность программиста разобраться в мануале без костылей.
К тому же никто не запрещает работу с регистрами делать в написанных самим функциях инициализации.
Библиотеки очень сильно повышают читаемость
На все случаи библиотеки не предусмотришь — и тогда никуда не уйдёшь от работы с регистрами.
  • avatar
  • artjom
  • 28 октября 2014, 18:50
0
Да, я забыл написать, что написанное справедливо для gcc.
Для Keil-а тоже справедливо и для IAR ARM. Так что почти стандарт…
  • avatar
  • artjom
  • 21 октября 2014, 11:07
0
Китай может быть «дружественным» до какого-то момент
Угу, тем более что может и не Китай, а Тайвань какой-нибудь, который совсем и не дружественный…
  • avatar
  • artjom
  • 16 октября 2014, 11:17
+1
Ну и обязали бы законодательно
А смогут ли они столько МК сделать, если обяжут?
Наверняка ведь в Китае делают… В РA только корпусируют. Не смогут нарастить выпуск, если понадобится.
  • avatar
  • artjom
  • 16 октября 2014, 10:44
0
Насчёт ST: или пожлобились на двойной фпу, или это результат копипаста из ф4.
Может быть и так… Пока непонятно какой там FPU…
  • avatar
  • artjom
  • 25 сентября 2014, 16:26