Дата последнего обновления файла 09.10.2005

Использование функций в языке программирования С-51*

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

Функция — это совокупность объявлений и операторов, обычно предназначенная для решения определенной задачи. Термин функция в языке программирования С эквивалентен понятию подпрограммы. Действия, выполняемые основной программой в других языках программирования такие как очистка внутреннего ОЗУ и присваивание начального значения переменным, выполняются автоматически при включении питания. После завершения этих действий вызывается подпрограмма с именем main. Каждая функция должна иметь имя, которое используется для ее объявления, определения и вызова.

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

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

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

С использованием функций в языке С-51 связаны три понятия - определение функции (описание действий, выполняемых подпрограммой-функцией), объявление функции (задание формы обращения к функции) и вызов функции.

Определение подпрограмм

Определение функции состоит из заголовка и тела. Определение функции записывается в следующем виде:

[спецификатор класса памяти] [спецификатор типа] имя функции ([список формальных параметров]) //Заголовок функции
{                                                                                             //тело функции   
}

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

Тело функции - это составной оператор, содержащий операторы, определяющие действие функции. Тело функции начинается с фигурной скобки '{' и состоит из объявления переменных и исполняемых операторов. Именно эти операторы, входящие в тело функции, и определяют действие функции. Завершается тело функции закрывающей фигурной скобкой '}'.

Пример определения функции:

bit SostKnIzm(void)//Заголовок функции
{//---------------начало тела функции--------------
 bit tmp=0;
 if(P0!=0xff)tmp=1;
 return tmp;
}//---------------конец тела функции-----------------

//================== Вызывающая подпрограмма ==========
  ...
  if(SostKnIzm()) //Вызов подпрограммы SostKnIzm
    DecodSostKn();

В приведенном примере показано как при помощи функции, возвращающей битовую переменную можно повысить наглядность исходного текста программы. Оператор if(SostKnIzm()) DecodSostKn(); практически не требует комментариев. Имя функции SostKnIzm показывает что контролирует эта функция.

Необязательный спецификатор класса памяти задает класс памяти функции, который может быть static или extern.

При использовании спецификатора класса памяти static функция становится невидимой из других файлов программного проекта, то есть информация об этой функции не помещается в объектный файл. Использование спецификатора класса памяти static может быть полезно для того, чтобы имя этой функции могло быть использовано в других файлах программного проекта для реализации совершенно других задач. Если функция, объявленная с спецификатором класса памяти static, ни разу не вызывалась в данном файле, то она вообще не транслируется компилятором и не занимает места в программной памяти микроконтроллера, а программа-компилятор языка программирования С-51 выдает предупреждение об этом. Это свойство может быть полезным при отладке программ и программных модулей.

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

Спецификатор типа функции задает тип возвращаемого значения и может задавать любой тип. Если спецификатор типа не задан, то по умолчанию предполагается, что функция возвращает значение типа int. Функция не может возвращать массив или функцию, но может возвращать указатель на любой тип, в том числе и на массив и на функцию. Тип возвращаемого значения, задаваемый в определении функции, должен соответствовать типу в объявлении этой функции.

Функция возвращает значение если ее выполнение заканчивается оператором return, содержащим некоторое выражение. Указанное выражение вычисляется, преобразуется, если необходимо, к типу возвращаемого значения и возвращается в точку вызова функции в качестве результата. Пример определения подпрограммы-функции:

#include <reg51.h>    //Подключить описания внутренних регистров микроконтроллера

char getkey ()       //Заголовок функции, возвращающей байт, принятый по последовательному порту
{while (!RI);         //Если последовательный порт принял байт,
 RI = 0;              //то подготовиться к приёму следующего байта
 return (SBUF);       //и передать принятый байт в вызывающую подпрограмму.
}

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

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

void putchar (char c)  //Заголовок функции, передающей один байт через последовательный порт
{while (!TI);          //Если передатчик последовательного порта готов к передаче байта
 SBUF = c;             //то занести в буфер передатчика последовательного порта байт
 TI = 0;               //и начать передачу
}

Все переменные, объявленные в теле функции без указания класса памяти, имеют класс памяти auto, т.е. они являются локальными. Так как глубина стека в процессорах семейства MCS-51 ограничена 256 байтами, то при вызове функций аргументам назначаются конкретные адреса во внутренней памяти микроконтроллера и производится их инициализация. Управление передается первому оператору тела функции и начинается выполнение функции, которое продолжается до тех пор, пока не встретится оператор return или последний оператор тела функции. Управление при этом возвращается в точку, следующую за точкой вызова, а локальные переменные становятся недоступными. При выходе из функции значения этих переменных теряются, так как при вызове других функций эти же ячейки памяти распределяются для их локальных переменных.

Если необходимо, чтобы переменная, объявленная внутри подпрограммы сохраняла своё значение при следующем вызове подпрограммы, то ее необходимо объявить с классом памяти static.

Параметры подпрограмм.

Список формальных параметров - это последовательность объявлений формальных параметров, разделенная запятыми. Формальные параметры - это переменные, используемые внутри тела функции и получающие значение при вызове функции путем копирования в них значений соответствующих фактических параметров.

Пример определения функции с одним параметром:

int rus (unsigned char r)  //Заголовок функции
{//---------------начало тела функции--------------
 if (r>='А' && c<=' ')        
      return 1;
    else
      return 0; 
}//---------------конец тела функции-----------------

В данном примере определена функция с именем rus, имеющая один параметр с именем r и типом unsigned char. Функция возвращает целое значение, равное 1, если параметр функции является буквой русского алфавита, или 0 в противном случае.

Если функция не использует параметров, то наличие круглых скобок обязательно, а вместо списка параметров рекомендуется указать слово void. Например:

void main(void)  
{P0=0;      //Зажигание светодиода
 while(1);  //Бесконечный цикл
}

Порядок и типы формальных параметров должны быть одинаковыми в определении функции и во всех ее объявлениях. Поэтому желательно объявление функции поместить в отдельный файл, который затем можно включить в исходные тексты программных модулей при помощи директивы #include. Типы фактических параметров при вызове функции должны быть совместимы с типами соответствующих формальных параметров. Тип формального параметра может быть любым основным типом, структурой, объединением, перечислением, указателем или массивом. Если тип формального параметра не указан, то этому параметру присваивается тип int.

Для формального параметра можно задавать класс памяти register, при этом для величин типа int спецификатор типа можно опустить. Однако все известные мне компиляторы языка программирования С-51 игнорируют этот спецификатор, так как расположение параметров в памяти микроконтроллера оптимизируется с точки зрения использования минимального количества необходимой внутренней памяти.

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

Таблица 1

Номер аргумента char, однобайтовый указатель int, двухбайтовый указатель long,float Нетипизированные указатели
1 R7 R6,R7 R4 - R7 R1 - R3
2 R5 R4,R5 R4 - R7 R1 - R3
3 R3 R2,R3 R1 - R3

Поскольку при вызове функции значения фактических параметров копируются в локальные переменные, в теле функции нельзя изменить значения переменных в вызывающей функции. Например нужно поменять местами значения переменных x и y:

/*    Неправильное использование параметров функции   */
void change (int x, int y)
{int k=x;
     x=y;
     y=k;
}

В данной функции значения локальных переменных x и y, являющихся формальными параметрами, меняются местами, но поскольку эти переменные существуют только внутри функции change, значения фактических параметров, используемых при вызове функции, останутся неизменными.

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

/*     Правильное использование параметров функции     */
void change (int *x, int *y)
{int k=*x;
     *x=*y;
     *y=k;
}

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

  change (&a,&b);

Предварительное объявление подпрограмм.

В языке С-51 нет требования, чтобы определение функции обязательно предшествовало ее вызову. Определения используемых функций могут следовать за определением функции main, перед ним, или находится в другом файле. Однако для того, чтобы компилятор мог осуществить проверку соответствия типов передаваемых фактических параметров типам формальных параметров и, если необходимо, выполнил соответствующие преобразования, до вызова функции нужно поместить объявление (прототип) функции.

Если объявление функции не задано, то по умолчанию строится прототип функции на основе анализа первого вызова функции. Тип возвращаемого значения создаваемого прототипа int, а список типов и числа параметров функции формируется на основании типов и числа фактических параметров используемых при данном вызове. Однако такой прототип не всегда согласуется с последующим определением функции. При размещении функции в другом файле или после оператора ее вызова рекомендуется задавать прототип функции. Это позволит компилятору либо выдавать диагностические сообщения, при неправильном использовании функции, либо правильным образом преобразовывать типы аргументов при её вызове.

Прототип - это явное объявление функции, которое предшествует определению функции. Тип возвращаемого значения при объявлении функции должен соответствовать типу возвращаемого значения в определении функции. Если прототип задан с классом памяти static, то и определение функции должно иметь класс памяти static. Объявление (прототип) функции имеет следующий формат:

[спецификатор класса памяти] [спецификатор типа] имя функции ([список формальных параметров]);

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

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

int rus (unsigned char r);

При этом в объявлении функции имена формальных параметров могут быть опущены:

int rus (unsigned char);

Вызов подпрограмм

Вызов функции имеет следующий формат:

имя функции ([список выражений]);

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

DecodSostKn();
VypFunc();

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

y=sin(x);                //sin - это имя подпрограммы-функции
if(rus(c))SvDiod=Gorit;  //rus - это имя подпрограммы-функции

Выполнение вызова функции происходит следующим образом:

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

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

int (*fun)(int x, int *y);

Здесь объявлена переменная fun как указатель на функцию с двумя параметрами: типа int и указателем на int. Сама функция должна возвращать значение типа int. Круглые скобки, содержащие имя указателя fun и признак указателя *, обязательны, иначе запись

int *fun (int x,int *y);

будет интерпретироваться как объявление функции fun возвращающей указатель на int.

Вызов функции возможен только после инициализации значения указателя:

float (*funPtr)(int x, int y);
float fun2(int k, int l);
   ...
   funPtr=fun2;         /* инициализация указателя на функцию */
   (*funPtr)(2,7);      /* обращение к функции                */

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

Рассмотрим пример использования указателя на функцию в качестве параметра функции вычисляющей производную от функции cos(x).

Пример:

float proiz(float x,float dx,float(*f)(float x));
float fun(float z);

int main()
{float x;               /*  точка вычисления производной */
 float dx;              /*  приращение                   */
 float z;               /*  значение производной         */

 scanf("%f,%f",&x,&dx);  /*  ввод значений x и dx         */
 z=proiz(x,dx,fun);      /*  вызов функции                */
 printf("%f",z);         /*  печать значения производной  */
}

float proiz(float x,float dx,float (*f)(float z))/* функция вычисляющая производную  */
{float xk,xk1;
 xk=fun(x);
 xk1=fun(x+dx);
 return (xk1/xk-1e0)*xk/dx;
}

float fun( float z)       /* функция от которой вычисляется производная  */
{return (cos(z));
}

Для вычисления производной от какой-либо другой функции можно изменить тело функции fun или использовать при вызове функции proiz имя другой функции. В частности, для вычисления производной от функции cos(x) можно вызвать функцию proiz в форме

z=proiz(x,dx,cos);

а для вычисления производной от функции sin(x) в форме

z=proiz(x,dx,sin);

Рекурсивный вызов подпрограмм

В стандартном языке программирования С все функции могут быть вызваны сами из себя или использоваться различными программными потоками одновременно. Для этого все локальные переменные располагаются в стеке. В микроконтроллерах семейства MCS-51 ресурсы внутренней памяти данных ограничены, поэтому в языке программирования С-51 для функций локальные переменные по умолчанию располагаются не в стеке, а непосредственно во внутренней памяти микроконтроллера. Если же подпрограмма должна вызываться рекурсивно, то ее необходимо объявить как программу с повторным вызовом (reentrant):

return_type funcname ([args]) reentrant 

Классический пример рекурсии - это математическое определение факториала n!:

   n! = 1   при n=0;
   n*(n-1)! при n>1 .

Функция, вычисляющая факториал, будет иметь следующий вид:

long fakt(int n) reentrant
{return ((n==1)?1:n*fakt(n-1));
}

Подпрограммы обработки прерываний

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

interrupt N;

где N-любое десятичное число от 0 до 31.

Число N определяет номер обрабатываемого прерывания. При этом номер 0 соответствует внешнему прерыванию от ножки INT0, номер 1 соответствует прерыванию от таймера 0, номер 2 соответствует внешнему прерыванию от ножки INT1 и так далее. Пример подпрограммы-обработчика прерывания от таймера 0:

void IntTim0(void) interrupt 2
{TH0=25; TL0=32;  //Задать новый интервал времени таймера T0
 TF=0;            //Сбросить флаг таймера T0 для разрешения следующего прерывания от данного таймера
}

При работе с прерываниями определяющим фактором является время реакции на прерывание. Для того, чтобы не сохранять содержимое используемых регистров микроконтроллера в стеке, в микроконтроллерах предусмотрено использование отдельных регистровых банков. В языке программирования С-51 для этого необходимо в объявлении подпрограммы указать используемый ею банк регистров. Для этого служить атрибут using:

void IntTim0(void) interrupt 2 using 1
{TH0=25; TL0=32;  //Задать новый интервал времени таймера T0
 TF=0;            //Сбросить флаг таймера T0 для разрешения следующего прерывания от данного таймера
}

Понравился материал? Поделись с друзьями!


Литература:

  1. Микушин А.В. Занимательно о микроконтроллерах. СПб, БХВ-Петербург, 2006.
  2. Микушин А.В., Сажнев А.М., Сединин В.И. Цифровые устройства и микропроцессоры. СПб, БХВ-Петербург, 2010.
  3. Keil uVision3 V3.51 для платформы MCS51

Вместе со статьей "Использование функций в языке программирования С-51" читают:

Языки программирования для микроконтроллеров
http://digteh.ru/Progr/progr.php

Операторы языка программирования C-51
http://digteh.ru/MCS51/C51/op_c51.php

Многомодульные программы
http://digteh.ru/MCS51/C51/manymod.php


* Для тех читателей что вышли на эту страницу по поиску прошу обратить внимание, что здесь рассматривается не стандартный язык программирования С, а язык, адаптированный к микроконтроллерам серии MCS-51. Имеются отличия!

Автор Микушин А. В. All rights reserved. 2001 ... 2023

Предыдущие версии сайта:
http://neic.nsk.su/~mavr
http://digital.sibsutis.ru/

Поиск по сайту сервисом Яндекс
Поиск по сайту сервисом ГУГЛ
Об авторе:
к.т.н., доц., Александр Владимирович Микушин

Кандидат технических наук, доцент кафедры САПР СибГУТИ. Выпускник факультета радиосвязи и радиовещания (1982) Новосибирского электротехнического института связи (НЭИС).

А.В.Микушин длительное время проработал ведущим инженером в научно исследовательском секторе НЭИС, конструкторско технологическом центре "Сигнал", Научно производственной фирме "Булат". В процессе этой деятельности он внёс вклад в разработку систем радионавигации, радиосвязи и транкинговой связи.

Научные исследования внедрены в аппаратуре радинавигационной системы Loran-C, комплексов мобильной и транкинговой связи "Сигнал-201", авиационной системы передачи данных "Орлан-СТД", отечественном развитии системы SmarTrunkII и радиостанций специального назначения.

А.В.Микушин является автором 130 научных и научно-методических работ, в том числе 21 монография и 26 учебников и учебных пособий.

Top.Mail.Ru

Яндекс.Метрика