Есть функция


каким-то непостижимым образом в data изначально появляются данные. Каждый раз одинаковые. Даже если ничего не писать в data, а по выходу из функции прочитать то, что она возвращает.

Как вычислить с помощью отладчика?
Контроллер - STM32F103VGT6

data у Вас - локальная переменная, то место ей выделяется в стеке, а там какой-нибудь мусор - вот и результат.
Объявите

и data будет инициализирована нулём.
Вам надо почитать учебники по С.

Вроде как по стандарту локальные переменные должны инициализироваться нулём в C. Но если у вас такая беда, то можете явно проинициализировать. Выносить в глобальные переменные смысла особого нет - читается один байт и при возврате из функции будет происходить копирование этого байта, то есть у вас всё правильно написано.

А если непосредственно по вопросу темы, то в окне "Breakpoints" в поле "Expression" необходимо ввести что-то типа "data==0"
При этом data должна быть глобальной

А если совсем по теме то КЕИЛ может делать такие чудеса с переменными которые не глобальные, что диву даешься. Всегда использовал отладку печатью в порт. Но тут уговорили жетагом попробовать, типа как удобно, сначала я думал что сошел с ума и ничего не понимаю в программировании, потом нашел на сайте кейла ремарку. У него есть ограничение на отображения переменных и иногда он показывает полную чушь.

Типа в окне переменная равна 5, а условие если переменная равна нулю проходит верно... это очень сбивает

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

Спасибо за советы, но я немножко не об этом хотел узнать. Проблема то решена принудительным обнулением.
Но - по логике вещей в data ничего не должно писаться без ведома программы, так собственно и происходит с остальными пермененными.

Дело в другом - я недавно бился над подобной проблемой - у меня напротив, после записи в массив через какое-то время информация в нем затиралась. Как выяснилось, массив у меня был без указания размера, а по сему пользовался "ничейной" областью памяти. И когда программа хотела в эту облатсь записать еще что-то, ей это удавалось.

Так вот у меня опасения, что причина проблем с переменной data схожая, боюсь что словлю глюк где-нибьудь еще и понять его причину будет сложно.

Так что смысл вопроса, смысл темы объяснить на пальцах как решить эту проблему KEILовским отладчиком.

Мой первый проект еще на AVR был с дисплеем, я привык отлаживать, выводя нужную информацию на экран, так что к своему стыду, отладчиком пользоваться не умею. Копнул недавно на теу отладки в KEIL, добавил в окно мониторинга пару переменных и был разочарован - чтобы узнать их значение, программу нужно останавливать. Куда удобнее выводить на экран.

А вот ловлю обращений к памяти выводом на экран не организуешь.


Если делать переменную глобальной, проблема исчезает, так что смысл в отладке теряется. Зато появляется ощущени нерациональности программы.

Как сделать две вещи - определить адрес в памяти, выделенный под data и как определить "клиента" который на этот адрес покушается?


Никогда похожих проблем не было с выводом на экран или запись в порт. Как-то расхотелось пользоваться житагом.

zheka, возьмите в привычку: объявил переменную, проинициализируй её.
Даже для локальных переменных.
Для любых компиляторов.

В проектах, где "поджимает" объем кода, отключаю инициализацию глобальных переменных.
Один фиг, аналогичные по функционалу функции в моём коде есть, которые и использую при запуске.

P.S. Имя "data" лучше изменить на хотя бы "Data", а лучше на что-то подлиннее, более содержательное, например "readData".

Когда только начинал программировать, так и делал. При изучении чужих программу меня сложилось ощущение, что принудительная инициализация - это паранойя.

То есть вы хотите сказать, что при объявлении переменной программа не заботится о том, чтобы она равнялась нулю, а на практике она равна нулю только потому, что ко времени выделения памяти под переменную в ней находятся нули чисто физически, потому что память обнуляется при старте?

Так и есть.

Название data для переменной тоже нормальное, так как область видимости очень короткая.


Ничё там не обнуляется при старте. При старте там мусор, а за обнуление отвечает специальный код, который чистит секцию init. richie пишет о том, что он всё принудительно инитит, поэтому отключил очистку секции init.

А почему компилятор должен эту переменную инициализировать, собственно? По коду она просто задекларирована, а потом сразу начинает использоваться, без инициализации (!!!!). Все законно. Что к моменту использования было, то и получили. Из стека. А вот с count все как надо с самого начала.

Перечитайте стандарт. Только глобальные и статические переменные.
А проблемы не было. У вас 8-битовая переменная и вы 8 раз в нее вдвигаете биты. Все ваши обнуленные биты "выталкиваются" из переменной во время исполнения функции. Поэтому начальное значение data на результат не влияет. А в нее ничего специально и не пишется. Просто двоичная система не имеет состояния "ничего не записано". Поэтому изначально там случайный набор битов.Наоборот. Это вы писали за границы своего массива нулевой длины и портили другие переменные, а потом пытались эти переменные считать как содержимое своего массива.
С переменной data проблем нет. И чудес не бывает и нет. Проблема в том, что вы пытаетесь пользоваться инструментом (языком C) не изучив его. Вы же не пытаетесь методом "тыка" использовать лекарства из домашней аптечки - здесь вы имеете такой же летальный для вашей программы результат.

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


1)прочитать описание языка и из него узнать, где размещаются локальные переменные
2)посмотреть дизассемблированный код функции и узнать смещение переменной в стековом кадре или имя регистра (компилятор имеет право расположить ее и в регистре).
3) на шаге 1 понять, что никто никуда не покушается и ничего не портит.

"Ну дык, еб тыть" - сказали суровые русские мужики и пошли валить лес двуручными пилами.

хм... об этом я как-то не подумал.
ПРосто когда методом тыка разбирал функцию по косточкам, я пытался понять откуда там берутся лишние биты.
Когда увидел, что какой-то мусор присутствует изначально, и что программа работает после принудительного обнуления data, радости после трехдневных мук не было предела, я свалил все на изначальный мусор.

А вообще, проблема гадкая, напоминает ситуацию, когда в какой-то функции уберешь одну фигурную скобку, то компилятор выдает ошибку в километре от этого места, приводя в недоумение. Боюсь что и здесь что-то подобное, болит голова, а причина где-то в пятке.

При входе в отладчик в кейле в менюшке (View кажется) есть пункт периодического обновления данных.
Если установить ему галку в процессе выполнения данные о переменных обновляются примерно раз в секунду.

А ведь правда)) Спасибо.

а еще



всегда считал что все переменные до инициализации содержат мусор, не знал про статик и глобальные. А кто их нулит? Ведь есть системы где память после загрузки не 0, процы на плисах к примеру, 9 Кбайтные блоки памяти у них не нулятся при старте, даже если просить...

а еще 16 битные переменные в 8 битных контроллерах умеют во время прерывания на половину изменятся, не говорят про 32 и 64 битные переменные... Что же вы теперь программу будете всю отладчиком шерстить? Лучше уже писать безопасный код ИМХО.

Доказательство лучше проверки...

Обычно это специальный так называемый стартап код, который выполняется перед запуском main(). В стандарте сказано просто что-то вроде "переменные обнуляются". Чем и как - вроде бы не оговаривается.

Если бы все были этакими сферическими программистами в вакууме, способными писать код сразу без ошибок... Часто проход по шагам небольшого кусочка кода, исполняющегося не так, как ожидал автор, позволяет за один проход найти ошибку. Все остальные методы отладки, включая медитацию над исходником, требуют гораздо больше времени.

Что есть startup?
кусок кода, который, обычно:
1. Содержит вектора прерываний
2. Содержит кусок кода, который выделит и укажет стек(и)
3. Отправит в __main

Что есть __main? это библиотека, при компиляции собранная с заданными параметрами:
1. Обнулить область ZEROINIT
2. Перенести код, если указан, в нужную область
3. Передать управление в точку main()

Сделать тоже самое просто в C можно спокойно и не напряжно. Без всяких библиотек. Что мешает сделать код инициализации переменных самому? Что позволяет надеяться на абсолютно рандомное содержимое области стека?
По факту топика - реализация сдвига на C (сколько ни сталкивался) всегда записывала 0 в освобожденный разряд. Это не циклический сдвиг на ASM
Про состояние локальных переменных уже все сказали

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

Я не про отладку в целом, я про фразу человека что он сделал массив без размера, фактически указатель, а потом загадив им память начал тыкать отладчиком во все функции и смотреть как локальные переменные объявляются, и не приводит ли это к чему... так проверить все я уверен нельзя. Потому считаю что лучше объявить переменную явно если от ее значения сразу что-то зависит, либо писать код учитывая что в начале она имеет любое значение.