0
Не, так не интересно. Это отдельный девайс, который нужно таскать с тобой. С таким же успехом можно таскать и обычный мультиметр. Таскать лень, а когда он вдруг неожиданно понадобится – окажется, что вы его забыли дома. А в формате часов – это «устройство, которое всегда с тобой» (естественно, ели вы имеете привычку носить часы).
  • avatar
  • e_mc2
  • 21 ноября 2013, 13:03
+2
Здесь, кстати, я полностью не согласен с автором оригинальной статьи.

Я с ним согласен в пунктах

— скорее всего код (или его часть) была сгенерированна автоматически, из какой-то специфической высокоуровневой среды.
— каждая глобальная переменная — это источник потенциальной опасности.

А вот когда он доходит до тех самых юнит-тестов — я не понимаю логику автора.

Начиная где-то со слов

 В общем, static-переменные в embedded C-программировании – это совершенно необходимая штука, без которой нормально ничего не получается.

И дальше по тексту

И вот, оказывается, при юнит-тестировании С-«модулей», в которых в static-переменные упрятаны локальные для модуля данные, в которые гарантированно не может «залезть» код других модулей, приходится выносить в… глобальные переменные.

Вот зачем юнит-тестам лезть во внутреннюю реализацию, в то, что инкапсулированно в модуль. Юнит-тесты работают с интерфейсом модуля, с тем, что он экспортирует. В высокоуровневых языках юнит-тесты тоже не имеют доступа к защищенным методам и членам класса, и ведь никто не предлагает выносить все наружу, делать все методы и члены public.
  • avatar
  • e_mc2
  • 20 ноября 2013, 21:47
0
Во время обработки глобальных переменных, изменяемых в прерываниях, прерывания обычно блокируются. Иначе можно нарваться на ошибки обработки. 


Вопросы атомарности доступа, блокировок и прочих радостей синхронизации — это тонкости реализации. Мы реализацию не трогаем, код уже написан (правильно или нет — это мы и хотим выяснить в процессе тестирования). Мы говорим о тестировании, конкретно, о покрытии кода unit test'ами. И наличие глобальных переменных очень мешает этому процессу.
  • avatar
  • e_mc2
  • 20 ноября 2013, 21:01
+2
Ну, не знаю. Нормально работать с таким устройством не удобно (слишком все мелкое, да и характеристики «не фонтан»). Скорее всего, для нормальной работы придётся покупать еще один осциллограф. Как идея «осциллограф, который всегда с тобой» — прикольно, не понятно насколько это действительно нужно за $150

Вот я бы, наверное, не отказался от мультиметра в подобном исполнении (естественно за адекватные деньги). Необходимость померять напряжение или что-то прозвонить в «полевых условиях» возникает достаточно часто.
  • avatar
  • e_mc2
  • 20 ноября 2013, 17:36
0
Ну а если с ними соревновался еще и программист Ваня, который принес решение O(N^2) через год?

Ели рассматривать только 2 выбранные нами критерия (алгоритмическая сложность и время реализации) то да, безусловно, Ваня не отсвечивает на фоне других.

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

В реальность так часто бывает. Например, человек отличный архитектор, но совершенно не умеет работать в команде и т. д.
  • avatar
  • e_mc2
  • 19 ноября 2013, 12:31
0
Даже не так :)

Изначально речь шла о сравнении «кто лучше пишет?». Пусть соревнуются программист Дима и Петя.

Предположим, что им поставили одинаковую задачу. Дима через месяц принес решение О(N). Петя работал над задачей пол года, зато нашел решение О(1).

Дык вот, кто из них лучший программист? Мы не можем однозначно ответить, т. к. Дима решил задачу быстрее, а Петя — оптимальнее.
  • avatar
  • e_mc2
  • 19 ноября 2013, 02:46
0
Извиняюсь, может я непонятно выразился.
Я хочу сказать, что реальные проекты имеют вполне осязаемые скрои и бюджет. И более предпочтительным, с этой точки зрения, может быть решение O(n!) «но сегодня», чем решение O(0) «но потом». Естественно, алгоритмически О(0) — более правильное решение.

Какой именно алгоритм является самым эффективным — зависит от конкретной задачи. Это как вопрос: какой из алгоритмов сортировки является «самым правильным»? Однозначно (без понимания контекста и конкретной задачи) на него нельзя дать ответ.
  • avatar
  • e_mc2
  • 19 ноября 2013, 02:28
0
Ну, по крайней мере, никому не понятную реализацию с затратами O(n!) с этими двумя можно сравнить и без контекста.

Ну, тоже не факт. Предположим, что решение нужно было, как часто бывает, «на вчера». И программист моментально «родил» (пусть даже непонятное для всех) решение O(n!), и оно работает.

Такой вариант тоже имеет право на жизнь, ибо решение нужно сейчас, пусть даже «быдлокод» со сложностью O(n!). Ибо, завтра, пусть даже самое правильное решение, уже никому не интересно, оно было нужно было вчера.
  • avatar
  • e_mc2
  • 19 ноября 2013, 01:14
0
Писать лучше многих довольно легко

Хм, а что значит «лучше»? Коллега, я бы не стал применять к написанию программ (абстрактно) критерии «лучше» или «хуже». Безусловно, есть количественные параметры оценки. Например, производительность, или потребление ресурсов. Но как, в общем случае, оценить, что лучше — простая и всем понятная реализация с затратами по ресурсам О(2n), или, понятная только создателю реализация с затратами О(n)? ИМХО, все зависит от контекста.
  • avatar
  • e_mc2
  • 19 ноября 2013, 00:45
+5
Суть не в количестве глобальных переменных, а в недостаточном тестировании конечного продукта. 


Как ни странно, эти две вещи связанны. Глобальные переменные — это зло для тестирования. Наличие глобальных переменных мешают покрытию кода тестами.

Если упростить, то вот пример:

int foo(int a, int b) {
	if(а или b выходят за допустимый диапазон) 
		return ERROR;
	else
		return (что-то там, в зависимости от а и b);
}

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

int a;
int b;

int foo(void) {
	if(а или b выходят за допустимый диапазон) 
		return ERROR;
	else
		return (что-то там, в зависимости от а и b);
}


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

if(а или b выходят за допустимый диапазон)


условие может выполнятся, а вот на момент вычислений

return (что-то там, в зависимости от а и b);


значение глобальных переменных может неконтролируемо изменится.

Поэтому, в первом случае, мы можем гарантировать однозначное поведение функции, а во втором — проверку диапазона входных значений можно выбрасывать, она ничего не гарантирует.

Посему наличие глобальных переменных усложняет (мягко говоря) написание unit test'ов
  • avatar
  • e_mc2
  • 18 ноября 2013, 23:20
+1
Спасибо за статью. И ждем продолжения цикла.
  • avatar
  • e_mc2
  • 18 ноября 2013, 21:40
0
На первой остановиться и все.:)
Нет, естественно, так нельзя :) Vga прав — это скорее спираль, чем падение. Если вы только пришли в программирование, осваиваете первый этап, вас будет непременно тянуть на второй. Вы будете подсознательно стремится к лучшему.

Понять прелесть первого этапа и наслаждаться его красотой можно только достигнув пятого… и разочаровавшись в нем :)
  • avatar
  • e_mc2
  • 18 ноября 2013, 00:38
+6
ИМХО, есть несколько стадий погружения в программирование

Стадия первая. Работа на результат. Здесь все просто — вы пишете свою ПРОГРАММУ. Главное, чтобы программа выполняла свои функции. Перед вами лежит книга «Как стать программистом за 21 день»

Вторая стадия. Вы понимаете, что просто достигнуть работоспособности программы — это не предел мечтаний. И есть некие правила, которые позволяют писать код «более правильно». Вы начинаете осмысленно называть переменные, выносить одинаковый код в функции. На столе у вас лежит книга «язык программирования ы «ЯП» для профессионалов»

Третья стадия. Вы понимаете, что написание кода — рутина. И открываете для себя архитектурную ценность. В голове у вас появляются критерии уровня «плохая декомпозиция», «удачное применение шаблона», «сильная связанность кода». Вы прочитали книгу «банды четырех», скорее всего, в оригинале.

Стадия четвертая. Архитектура — удел теоретиков. Вы понимаете, что идеально выстроенная и соответствующая всем канонам архитектура вашего приложения разбивается о волны действительности через пару месяцев разработки. Наступает переосмысление — вся соль в методологии. Вы, на данном этапе, оперируете терминами «agile», «рефакторинг», «процент покрытия кода тестами». На столе у вас куча брошюрок вида «TDD – это круто и перспективно», «SCRUM – это наше все».

Стадия пятая. Методология работает, но не оправдывает ваших ожиданий. Красивые лозунги, хорошие идеи. Но вы осознаете, что серебренных пуль не бывает. И вам хочется вернутся на первую стадию. :)
  • avatar
  • e_mc2
  • 17 ноября 2013, 15:29
0
времена остаются заданными по умолчанию

Все верно, но не факт, что при первом вызове тайминги остаются по умолчанию, ибо не факт, что FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct равна NULL. Сама структура выделяется в стеке, не инициализируется компилятором. Часть полей мы инициализируем явно, остальные, потенциально, содержат мусор.

На момент первого вызова инициализации FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct может содержать любое значение, которое будет интерпретировано как указатель на FSMC_NORSRAMTimingInitTypeDef. Если повезет и указатель будет NULL – останутся дефолтные тайминги. В противном случае – установятся значения вычитанные из «левого» адреса памяти.
  • avatar
  • e_mc2
  • 15 ноября 2013, 12:54
+1
Насколько понимаю, uint16_t или uint8_t это не сами ключевые слова, а define какого-нибудь unsigned int?
Да, это просто синонимы, но они не зависят от платформы. Грубо говоря, uint8_t — на любой платформе, это беззнаковая переменная размером 8 бит. uint16_t, по аналогии, это беззнаковая переменная, 16 бит. А вот размер int может изменятся от платформы к платформе, битовая размерность int стандартом языка не определена. Ровно как и битовая размерность других типов (char, short, long)
Для данной платформы, uint16_t это синоним unsigned short

Я тоже увидел, что код повторяется. 

Хм, а попробуйте, в порядке эксперимента, закоментровать первый вызов
FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);

и проверить работоспособность.

По логике, от этого ничего изменится не должно. Либо, действительно, есть неочевидные моменты.
  • avatar
  • e_mc2
  • 15 ноября 2013, 00:43
0
Стандарт предписывает фиксированную паузу t3.5 на скоростях от 38400

Согласен, здесь я погорячился.

А почему 38400? Вроде как фиксированные тайминги при скоростях выше 19200

For baud rates greater than 19200 Bps, fixed values for the 2 timers should be used: it is
recommended to use a value of 750µs for the inter-character time-out (t1.5) and a value of 1.750ms for inter-frame delay (t3.5).
  • avatar
  • e_mc2
  • 14 ноября 2013, 23:49
0
Ели не затруднит, выложите код, так будет понятней.

Ели у вас реализован таймаут между соседними байтами в 1 мс, то например, на скорости 115200 пауза в  t3.5 будет незаметна, не вызовет таймаута. Пакеты, для такого приемника будут идти сплошным потоком. Наверное, это сработает, если мастер будет слать пакеты с интервалом более 1 мс. Но, согласно стандарту, минимальный интервал —  t3.5.

В принципе, раз Вы все-же как-то следите за таймингами приема — почему бы не сделать «честную» реализацию MODBUS, в соответствии со спецификацией? Это не намного усложнит реализацию, но это будет «честная» реализация стандарта, которая будет гарантированно работать в любых условиях.
  • avatar
  • e_mc2
  • 14 ноября 2013, 22:40
0
Можете выложить пример кода? А где гарантия, что после таймаута мы не попадем на середину очередного пакета, проверки не пройдут и ситуация с переполнением буфера не повторится опять (и далее, по кругу)?
  • avatar
  • e_mc2
  • 14 ноября 2013, 21:36
0
О, другое дело, дело. Дополнительная проверка
if ((buf[6] == num<<1)&&(len == (num<<1) + 9))

снимает второй вопрос. А как Вы решили проблему с ошибкой при передаче и последующим восстановлением «синхронизации»?
  • avatar
  • e_mc2
  • 14 ноября 2013, 21:04
0
Спасибо за статью.

Есть вопрос:

Вы заполнили NORSRAMTimingInitStructure первый раз, затем вызвали
FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &FSMC_NORSRAMTimingInitStructure;
  FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);


Затем поменяли тримминги и вызвали

FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &FSMC_NORSRAMTimingInitStructure;
  FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);   


Но ведь на момент второго вызова и
FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct и FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct ссылаются на одну и туже структуру, и второй вызов переопределит и ReadWriteTiming и WriteTiming …

Это ошибка, или какая-то неочевидная особенность?

И еще (хоть это и не очень принципиально) – почему у вас в коде все переменные int? ИМХО, логичнее, в данном случае, использовать uint16_t.
  • avatar
  • e_mc2
  • 14 ноября 2013, 19:51