Добрый день господа форумчане.

У меня возникла проблема - очень надеюсь на вашу помощь.

Пишу программу под PIC16F876 на PICC от HT-PICC.

В программе захотел сделать функцию антидребезг.
unsigned char do_antiripple_pin(volatile struct data_unit * data , char time_conversion);
В эту функцию передаю время проверки на дребезг и
указатель на структуру в которой содержиться иформация о ножке процессора.

volatile struct data_unit
{
volatile unsigned char pin_addres; // Адрес пина на цоколевке процессора.
unsigned char time_to_end; // Показывает сколько времени до конца преобразования
unsigned char temp_pin_value; // Сохраняет временное значение на меняющимся пине проца.
unsigned char changing_data; // Переменная с которой прграмма работает как с ножкой проца
unsigned char diferences_counter; // Счетчик несовпадений пина и значения переменой за интервал
};
Проблема с полем pin_addres - это у меня просто имя пина ( допустим RA0), я объявил глобальный экземпляр структуры volatile struct data_unit button_data = {0,0,1,1,0};потом в main(); присвоил полю pin_addres значение RA0

button_data.pin_addres = RA0;

ниже вызываю функцию do_antiripple_pin(&button_data,100);
и надеюсь что у меня в функцию передасться значение с ножки порта, причем не просто значение
а мгновенное, так как я везде где можно поставил volatile.

Но этого не происходит. Программа как один раз зафиксировала в памяти значение

button_data.pin_addres = RA0;

так больше его не меняет, хотя значение на ножке меняется (это я вижу через IDC2).

Выкладываю программу , там в листинге более понятно, чем я тут объясняю.

Программма как следует не работает, но если закоментировать стр 31, и раскоментировать стр 92
тогда все работает нормально. Нормально так же все работает если передавать в функцию просто
назвние ножки порта.

Но вот почему не работает как мне надо??? (Т.е в том виде в котором выложил!)

Помогите пожалуйста разобраться.

При вызове функции do_antiripple_pin квалификатор volatile относится непосредственно к указателю, а не к полям структуры, указатель на которую передается. Я не пойму зачем вам этот геморрой с указателями, если у вас структура глобальная? Обращайтесь в функции do_antiripple_pin непосредственно к ее полям, типа

Если же вы хотите разнести работу со структурой по разным модулям, то создайте новый тип со всеми нужными volatile квалификаторами. И используйте этот тип в применении как к структурам, так и к указателям на них.

объявление структуры

функция

А вообще, советую вам пересмотреть алгоритм и отказаться от бездумного использования квалификатора volatile где попало.

Уважаемый rezident.

Я попробовал сделать как вы советовали. Результат тот же - ничего не получается. Поле pin_addres не обновляеися согласно со значением ножки RA0.

А вот насчет того что истользовать volatile где попало не следует, я с вами согласен.

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

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

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

Прикладываю новую версию программв с изменениями которые советовал внести г-н rezident.

Да потому, что вы никак не можете понять, что указатель это тоже переменная, которая содержит адрес переменной к которой вы обращаетесь с помощью этого указателя. Так вот значение адреса не меняется. Меняется содержимое переменной, которую вы адресуете с помощью указателя. Так что квалификатор volatile в определении указателя никак не влияет на считывание значения переменной с помощью этого указателя.
Пример.
Имеем условный 8-ми битный порт M по адресу 0x0010.
Его определение в хидерах скорее всего такое
portsdef.h

main.c

Вне зависимости от того, как мы объявили указатель

или

У нас содержимое самого указателя не меняется и всегда равно 0x0010. А меняется содержимое порта PORT_M по адресу 0x0010, адрес которого содержит указатель.
Так, что для считывания реальных данных с порта нужно использовать специальную конструкцию заложенную компилятором (см. выше) и его непосредственный адрес.
Либо попробовать симмитировать ее, как-то так

Уважаемый Илья!

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

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

Уважаемые господа, sergeeff и rezident.

То что указатель содержит адрес ячейки памяти, в которой храниться значение переменной
на которую этот указатель указывае - это азы Си. И они мне уверяю вас известны.

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

Вот цитата из прервода документации по компилятору HT-PICC:


"Чтобы четче определить поведение и особенности указателя и объекта на который он
указывает можно комбинировать различные квалификаторы. К наиболее часто употребимым
квалификаторам относятся const, volatile, persistent. Применяя комбинации этих
квалификаторов необходимо следить за соответствием (отсутствием противоречий)
квалификаторов, оказывающих воздействие на свойства собственно указателя и объекта на
котрый он указывает. Правила, которые помогут сделать все правильно, просты: если
квалификатор находится слева от “*” в описании указателя, то он воздействует на объект,
адресуемый указателем. Если квалификатор находится справа, то он воздействует на
собственно указатель. Проиллюстрируем это примерами:
volatile char * nptr;
объявляет указатель на volatile символ. Другими словами в этом примере квалификатор
воздействует на объект, адресуемый указателем nptr.
char * volatile ptr;
так как квалификатор располагается справа от “*”, то он будет воздействовать на
собственно указатель ptr, а не на объект. И заключительный пример по этому поводу:
volatile char * volatile nnptr;
теперь будет описан volatile указатель на volatile переменную.
Рассмотрим некоторые аспекты применения константных указателей. Они применяются
для косвенного обращения к переменным описанным как const. В общем их поведение
(константных указателей) не отличается от поведения обычных указателей, но компилятор
препятствует выполнению операций записи с использованием этих указателей. Вот
несколько примеров:
const char * cptr;
при этом выражение:
char ch = *cptr;
абсолютно легально, в то время как выражение:
*cptr = ch;
недопустимо и вызовет ошибку"

Судя по тому что написано в описании, я совершенно правильно использовал квалификатор volatile,
а то что сам указатель не меняется так это тоже верно.

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

Так вот я мог бы пердавать в функцию явно номер пина RA0 или RC5 и это бы работало.
А если передавать структуру, в которой одним из полей будет номер пина (RA0 или RC5)
то функция работает некоретно. И вот вопрос ПОЧЕМУ???

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

Хотя быть может вы меня переубедите, если предложите другие аргументы.

Уважаемый Илья volatile тут вообще не причем ваша программа работает строго так, как вы написали.

"volatile unsigned char pin_addres " - Какой же это адрес ?!? Если адрес должен выглядеть как
"volatile unsigned char * pin_addres".


"button_data.pin_addres = RA0;" - как раз ОДИН РАЗ присваивает байтовой переменной pin_addres (которая адресом только называется и застряла в вашем воображении) ЗНАЧЕНИЕ пина RA0.
а должно быть что-то вроде

"button_data.pin_addres = &RA0;".

Отсюда вывод - учить букварь по Си. А еще лучше учиться писать на Ассемблере, чтобы начать действительно понимать Си


А вообще (я именно про PIC не в курсе) - возможно для PIC такое косвенное обращение к портам ввода-вывода вообще невозможно, либо делается другими средствами.

Аргумент у меня только один, но зато он железобетонногранитнобронзовый - ваша программа НЕ РАБОТЕТ так, как вам нужно.
Кстати, вы так и не привели выдержку о том, что представляет из себя символьное обозначение RA0.

Дедуктивно предположу, что это разыменованный указатель на volatile переменную типа bit. Этот тип является расширением языка HI-TECH компилятора для пиков. И если компилятор позволяет делать указатели на такие типы (в чем я сомневаюсь, зная систему команд пика), то поле структуры должно быть объявлено как bit volatile * pin_address; или volatile bit * pin_address;, что одно и то же.

А это как-то поможет с реализацией задуманного автором при использовании его структуры?

Если бы архитектура пиков поддерживала указатели на биты (о чём Сергей и сказал), то помогло бы.
Просто надо было бы так.


Аналогично и Ваш пример

можно изменить так
Или вообще сразу объявить pPortM как volatile unsigned char *



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

Можно ещё вот так:

Можно и так. Причём в зависимости от архитектуры и прочего может оказаться, что это будет работать даже быстрее (косвенный вызов против сдвига в цикле деинички для создания маски).
Что характерно, после этого возникает вопрос - а что там за споры были про С++? Неужели С-шная ручная эмуляция виртуальной функции опроса вывода кардинально эффективнее встроенной в язык поддержки?


Она будет эффективнее, так как в С++ идёт рассчёт на возможное большое количество таких функций и в каждом экземпляре хранятся не непосредственно указатели на функции, а указатель на таблицу виртуальных функций класса, будет не просто выборка из структуры адреса функции и вызов, а выборка указателя на таблицу, выборка из неё указателя на функцию и только потом вызов.
Но для большинства архитектур это не будет жутким перерасходом ресурсов.

Ну, маску можно сделать членом структуры:-) Но выигрыш будет всё равно мизерный.



Это не ко мне, я-то как раз за Си++ :-)

Добрый день господа форумчане.

Ваши советы, деийствительно дельные и очень помогают. Всем большое спасибо за это.

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

Извините, за лиричиское отступление (Остапа, как говориться, понесло....)


Итак к делу:

1) Для большей ясности для начала отвечаю на вопрос г-на residenta:
"Кстати, вы так и не привели выдержку о том, что представляет из себя символьное обозначение RA0."

Вот ответ: static volatile bit RA0 @ (unsigned)&PORTA*8+0;
static volatile unsigned char PORTA @ 0x05;

и еще выдержка из описания к компилятору:
"2.9 Статические переменные
Глобальные или статические переменные могут располагаться по абсолютному адресу.
Для этого в описании переменной используется специальная конструкция “@ <адрес>”.
Например:
volatile unsigned char Portvar @ 0x06;
Такое описание дает возможность обращаться к абсолютному адресу 0х06 посредствам
переменной Portvar. Надо учитывать, что в этом случае компилятор не резервирует память
под размещение этой переменной. С точки зрения ассемблера это описание выглядит
следующим образом:
Portvar equ 06h"

2) Прав г-н Олег Хохлов написав:
""volatile unsigned char pin_addres " - Какой же это адрес ?!? Если адрес должен выглядеть как
"volatile unsigned char * pin_addres"."

Вводя в структуру поле pin_addres я имел ввиду что мне нужна переменная , входящая, которая
будет содержать тоже что и переменная RA0 в любой момент времени. А то что надо просто связать
мое поле структуры и ножку RA0 через адрес у меня в голове на тот момент четко не оформилось.

3) И вот тут я подошел к тому о чем писал г-н Сергей Борщ :
"И если компилятор позволяет делать указатели на такие типы (в чем я сомневаюсь, зная систему команд пика), то поле структуры должно быть объявлено как bit volatile * pin_address; или volatile bit * pin_address;, что одно и то же"
Да, компилятор не прозволяет делать указатели на переменные типа бит и следует, ввести структуру
поле - адрес номера порта, и поле - номер бита в порте, тогда проблема решается. Но об этом же
написал г-н ReAl

И вот тут я пришел к тому, что нехочется мне в структру вводить дополнительное поле и я решил сделать по другому - см. прикрепленные файлы.

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

Г-ну AHTOXе хочу сказать что его вариант конечно интересный, но писать одинаковые функции для каждой ножки порта я нахожу громоздким. А если ножек 80 как в PIC18f87j10? Я же хочу написать универсальную функцию.