+1
а чиркните примерчик, мы и сравним размер кода

Пример чего?

Если меряться размером кода – то есть смысл опуститься до уровня ассемблера и использования всяких извратов типа размещения кода в области векторов прерываний. На хабре была статья, где мигание светодиодом на AVR свели к одной инструкции.

Идея ООП – это повышения уровня абстракции, а не экономия бит. И, при грамотном использовании, этот инструмент позволяет исключать накладные расходы.
  • avatar
  • e_mc2
  • 31 октября 2014, 01:07
0
смотри, насколько я знаю принцип работы кода, скомпиленного из класса, в любом случае вызов метода — это вход в функцию, причем как правило будет использоваться стэк.

Это не так. Метод можно заинлайнить (как заметил Vga ), метод может быть статический и т д. И есть оптимизатор, который должен эффективно сгенерировать код. Накладные расходы однозначно возникают при использовании полиморфизма, но никто не заставляет его использовать. Плюс, есть возможность использования шаблонов…

не знаю, как обойтись без метода в ООП.
В смысле? Так и пишите:

void main() {
	TCCR1A |= ((1<<COM1A1) | (1<<COM1A0) | (1<<WGM11) | (1<<WGM10));
        TCCR1B |= ((1<<WGM13) | (1<<WGM12) | (1<<CS11));
	…
} 

Никто не заставляет вас создавать классы (если они вам не нужны). Можно использовать исключительно синтаксис С.
  • avatar
  • e_mc2
  • 31 октября 2014, 00:45
+1
Касательно
2. Ну и конечно в ООП для этого есть наследование и переопределение.

Это прям какой-то антипаттерн программирования. Для каждого объекта, который отличается только значением пары полей (адресами регистров) создавать свой тип (класс).

Так мы дойдем до такого:

class AplusB
{
public:
        int GetSum() {
	return GetA() + GetB();
	}
        virtual int GetA()=0;
        virtual int GetB()=0;
};

class OnePlusTwo : public AplusB {
	int GetA() {return 1};
	int GetB() {return 2};
}	

class TwoPlusTwo : public AplusB {
 …
}

А потом будем удивляться размеру кода.

и так для каждого канала. Работаешь, само-собой с наследниками.

Если уж работаешь с только с наследниками, а не через базовый класс – зачем полиморфизм, зачем метод объявлять виртуальным? Чтобы увеличить размер кода?
  • avatar
  • e_mc2
  • 30 октября 2014, 22:16
0
int* pulse_width;


Т. к. в этой переменной хранится адрес регистра периферии – добавьте в объявление volatile, иначе оптимизатор может выбросить код обращения к этому регистру (переменной).

Как можно сделать чтобы получить независимую инициализацию для каждого обьекта (канала) PWM — если регистры конфигурации разные для каждого таймера?

Я бы сделал отдельный класс-обертку для таймера. Можно их использовать отдельно от класса Servo, можно связать, инкапсулировать 2 канала PWM в класс таймер. Тогда получим 3 экземпляра таймера, каждый из которых предоставляет интерфейс для двух «своих» PWM каналов.
  • avatar
  • e_mc2
  • 29 октября 2014, 12:58
+5
Выскажу свое ИМХО.

А когда уже лучше вникаешь во все постепенно, в один момент понимаешь, что SPL адово мозолит глаза, да и регистры вроде как уже почти наизусть помнишь все =)…

Да, Вы правы, если постоянно (или регулярно) работаешь с определенной платформой – запоминаешь регистры, биты в них, особенности использования. Это не проблема.

Проблемы начинаются, когда работаешь с несколькими платформами, причем поочередно. Я, например, лет 6 назад активно использовал AT91SAM7 и тоже, на тот момент, «помнил наизусть» если не все, то многое из низкоуровневой работы на уровне регистров. А теперь практически все забылось, т к. я перешел на другую платформу и новые девайсы делаю на ней. Но часто приходится поддерживать старый код, и рассчитывать, что ты будешь помнить все регистры и тонкости для разных платформ – не вариант.

Вариант – оборачивать обращения к регистрам в макросы/инлайн функции/функции/методы и давать этому осмысленные имена. Что такое
ResetTimer(TIM0);
Вы поймете всегда, а что такое
TIM0->BLABLA = BITAA | BITGG;

вы достаточно быстро забудете.

Поэтому, настоятельно рекомендую делать такие обертки с осмысленными именами. А вот делать свои обёртки или использовать готовые (например, SPL) – это уже другой вопрос.
  • avatar
  • e_mc2
  • 28 октября 2014, 22:01
+3
Коллега, спасибо за статью. Я хотел написать к первой версии статьи, но не успел, Вы ее спрятали в черновики. Первая версия была скучна и уныла, отсылка на описание языка АЛМИР-65 мало кому интересна, ибо практической ценности не имеет.

Вы доработали статью – появилось больше «жизни». Не пишите официальную информацию о тех ЭВМ (она и так легко гуглится), опишите, лучше, именно субъективную часть – как Вы осваивали данную ЭВМ, как происходил процесс ввода – вывода данных, отладки. Как «машинное время» распределялось между студентами, какие именно задачи решали на этой ЭВМ и т. д. Именно это (по крайней мере, лично для меня) вызывает интерес.

Вот например:
На вопросы преподавателей «А где ваши расчёты?» им просто отдавались перфолента и распечатка программ.

Преподаватели как-то проверяли код? Просто я учился намного позже (тогда уже появились IBM PC, DOS, и даже MathCAD) но не один из преподавателей не принял бы работу в виде распечатки MathCAD. Работу нужно было подавать «от руки», никакие распечатки и численные методы вычислений (мягко говоря) не приветствовались…
  • avatar
  • e_mc2
  • 24 октября 2014, 22:49
+1
У AVR асмовская вставка объявлена как volatile, а у Вас нет. Это конечно зависит от компилятора, но теоретически оптимизатор может выбросить вашу задержку из кода.
  • avatar
  • e_mc2
  • 24 октября 2014, 11:34
0
Сугубо ИМХО, но (как советуют ниже в комментариях) если есть возможность выбирать инструмент – то лучше подобные вещи делать на С++. Тем более, у Вас есть опыт с Objective-C, и я не думаю, что освоение С++ будет для Вас проблемой.
Реализовать принципы ООП можно и средствами С, но я, честно говоря, не вижу в этом особого смысла.
  • avatar
  • e_mc2
  • 21 октября 2014, 23:04
0
— no previous prototype for 'SystemTemerDidCountTick' [-Wmissing-prototypes]

Да, я забыл про -Wmissing-prototypes
Но, по моему, этот ворнинг по умолчанию отключен и в –Wall не входит? Или я ошибаюсь?

Кстати, при имплементации протокола в Objective-C тоже есть опасность использования неправильного имени метода, и мы можем увидеть тоже только warning.

Подобные вещи иногда встречаются. В С++ из за опечатки можно создать новый метод вместо переопределения родительского. Но от этого стараются уходить, в С++11 уже можно детектировать такие вещи средствами языка.
  • avatar
  • e_mc2
  • 21 октября 2014, 00:49
+2
Weak – очень опасная штука.

Пример:

void SystemTemerDidCountTick(systemTimerTick_t tick)
{
        LedOn();
}

Я сознательно допустил опечатку в названии метода (Temer). Код скомплится? – да без ошибок и варнингов. И даже работать будет. Но не так как Вы ожидаете, «делегат» вызываться не будет. Удачной отладки в большом проекте :) Особенно весело, когда над проектом работает много человек. Я отрефакторил кусок кода с объявлением делегата, а у кого-то что-то перестало вызываться, что раньше работало.

Если нужен подобный функционал – я бы сделал по старинке, через указатили на функции и явное назначение «делегатов-калбеков». Плюс, такой подход более гибкий – можно в рантайме переназначать «делегатов». Вызов функции по указателю – очень незначительные накладные расходы.
  • avatar
  • e_mc2
  • 21 октября 2014, 00:00
+3
Таким образом, можно увидеть, что простые макросы особо не нагружают ни процессор, ни память, и их использовать можно везде, где удобно и семантично)
Такое утверждение не совсем корректно, т. к. макросы – это просто синтаксическая конструкция, которая обрабатывается препроцессором. А потом уже полученный после подстановки код компилируется. По факту
uint8_t c = max(a,b);

препроцессор развернет в
uint8_t c = a > b ? a : b;

и уже этот код будет во что-то скомпилирован. Во что – зависит от многих факторов. Например, от типа переменных (для переменных с плавающей точкой результат будет далеко не так тривиален как получилось у Вас в примере), от оптимизатора, от самого компилятора (разные компиляторы могут генерировать разный код).
  • avatar
  • e_mc2
  • 17 октября 2014, 22:33
0
Понятно. Просто загрузив таким образом elf в отладку, Вы увидели внутреннюю реализацию, которая до этого была скрыта.

ардуине-то в принципе люди кодят потому, что им не нравится С, а тут сплошь С и С++ ))
Ну, на самом деле они кодят на С++. Только не знают этого :) Просто, для снижения порога вхождения, там используются самые простые средства данного языка.
  • avatar
  • e_mc2
  • 16 октября 2014, 20:44
0
амая печаль отражена на этом фото:

Честно говоря, не совсем понял что за печаль. Ошибок в коде я не вижу…
То, что объекты создаются для всех доступных УАРТ даже если Вам они не нужны?
Или я чего не замечаю?
  • avatar
  • e_mc2
  • 16 октября 2014, 19:39
0
Включите CodeGuard в свойствах проекта

Честно говоря, что CodeGuard, что встроенный в VS механизм отлова утечек очень лажают. Не знаю почему (задача кажется достаточно простой, достаточно переопределить/перехватить функции выделения и освобождения памяти, и запросто можно найти утечку, по крайней мере установить факт утечки) но эти механизмы, на практике, работают очень плохо.

Я для себя не придумал ничего лучше чем запуск в цикле unit-тестов. Запускаем наночь тесты — утром смотрим, сколько приложение «съело» памяти, хендлов и других ресурсов. Такой тест, хоть и примитивный, выявляет утечки намного лучше чем встроенные в среду разработки функции.

Может кто знает эффективные автоматизированные средства выявления утечек ресурсов для С++, и поделится опытом?
  • avatar
  • e_mc2
  • 07 октября 2014, 21:06
0
И да, нужно несколько сообщений, т. к. ОС оптимизирует кучу. Попробуйте, например, прогнать 10 сообщений (по «10 МБ») без delete [] и замерьте объем памяти, потом запустите приложение заново, и проверьте с delete.
  • avatar
  • e_mc2
  • 06 октября 2014, 23:52
0
Да проверил, только написал сначала delete Buf; 

Так можно, но т. к. выделяется массив нужно писать

delete [] Buf;


тогда будет вызван деструктор для каждого элемента массива. Но в данном случае разницы не будет, т. к. вы выделяете массив из char, это простой встроенный тип, и у него нет деструктора.

Погонял данные что с это строкой что без нее ничего не меняется размер занимаемой памяти один и тот же.

Диспетчер — очень грубый инструмент. Плюс, ОС своеобразно оптимизирует работу с кучей. Потерю в несколько байт вы не заметите. Хотите удивить разницу — попробуйте выделять не несколько байт, а например, 10 МБ.

void __fastcall TForm1::NMUDP1DataReceived(TComponent *Sender,
int NumberBytes, AnsiString FromIP, int Port)
{//пришли данные по UDP отправим из в RS232 (433Mhz)
char* Buf=new char[10000000];
//Выставляем порт и IP куда надо слать
NMUDP1->RemoteHost=IP;
NMUDP1->RemotePort=PORT;
NMUDP1->ReadBuffer(Buf,NumberBytes,NumberBytes);
IP=FromIP;
PORT=Port;
ComPort1->Write(Buf,NumberBytes);
} 


тогда эффект должен быть наблюдаем и в диспетчере.
  • avatar
  • e_mc2
  • 06 октября 2014, 23:45
0
А как правильно ее освободить?

После того как записали данные в порт
ComPort1->Write(Buf,NumberBytes);

добавить строку
delete [] Buf;

Это освободит память, которую Вы выделили через new()
  • avatar
  • e_mc2
  • 06 октября 2014, 23:07
0
Тогда память теряется.

Метод TcomPort::Write(), судя по описанию, записывает данные в порт, но не освобождает буфер. Поэтому выделенная память будет теряться.

Ведь это не Java, здесь нет «сборщика мусора».
  • avatar
  • e_mc2
  • 06 октября 2014, 22:59
0
Упс…

Какой класс скрывается ComPort1

Какой класс скрывается за ComPort1 … Каков тип переменной ComPort1?
  • avatar
  • e_mc2
  • 06 октября 2014, 22:49
0
Вы выделили память

char* Buf=new char[NumberBytes];


кто ее освободит?

Вы уверенны, что

ComPort1->Write()


освобождает выделенную память. Такое теоретически возможно, но я сомневаюсь. Какой класс скрывается ComPort1? Что-то стандартное или это Ваша реализация?
  • avatar
  • e_mc2
  • 06 октября 2014, 22:42