Программирование на Си в среде CCS

объектный исполняемый код
Широкое распространение
Очень большая поддержка

слагаемого
int b; // описание второго слагаемого
int c; // описание результата

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

*/
{
/* текст программы – подсчёт суммы двух чисел */

Функция «main» является главной функцией программы. Она обязательно должна присутствовать в проекте. После того,
как будет выполнен код инициализации микроконтроллера и глобальных переменных программы, управление будет передано этой функции. Можно сказать, что выполнение пользовательской программы начинается с этой функции.

того существует понятие «составного присваивания»: выполнить действие с переменной и

x = x + 5 можно записать как x+=5
y = y – 2 можно записать как y-=2

b; // описание второго слагаемого
int c; // описание результата (суммы)
/*

Сначала указывается тип переменной, затем её имя.

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

случае, к началу выполнения программы (функции «main») её значение будет

«_» считается буквой
Строчные буквы для имен переменных
Заглавные для символических констант
Нельзя

объявления массива: сначала указывается типа элементов массива, затем имя, а

// Объявление массива «a» из 100 элементов типа "int"
int a[100];

void fillBuf (void){
a[0] = 5; // Записать число "5" в первый элемент массива
a[1] = 6; // Записать число "6" во второй элемент массива
}

структуры могут быть указатели на переменные и указатели на функции.

// Пример описания структуры с элементами разных типов
struct myStruct {
int mem1;
unsigned long mem2;
long *pmem3;

void (*someFunc)();
};

свойства. Например – каналы АЦП, которые имеют коэффициент усиления, смещение

// Структура-описатель канала АЦП
struct adcChannel {
// Коэфф. усиления
int gain;
// Смещение сигнала
int offset;
// Результат оцифровки
int result;

// Функция очистки данных
void (*clear)();
};

void main (void) {
// Создать структуры для обработки АЦП
struct adcChannel Udc; // Напр. ЗПТ
struct adcChannel Ia, Ib, Ic; // Фазные токи

// Настройка канала АЦП
Udc.gain = 540;
Udc.offset = 0;
}

всем элементам одно и то же значение
Значения для инициализации приводятся

// Определение структуры даты
struct Sdate {
int year, month, day, dayOfWeek;
int hour, minute, second;
};

// Создание экземпляра. Каждый элемент инициализирован своим значением
struct Sdate dateOfBirth = {1980, 11, 21, 4, 13, 24, 11};
// Все элементы инициализированы значением "0"
struct Sdate dateOfDeath = {0};

значения переменной на 1
Различают пред-инкремент и пост-инкремент:
x++; //

b = a++;
// Сначала в b будет

Постинкремент: сначала с переменной производятся все действия, описанные в выражении, после чего её значение увеличивается на 1.

void main(void) {
a = 10;
b = ++a;
// Сначала "а" будет увеличена на 1,
// а затем в "b" будет записано значение переменной "а".
// В результате получится b = 11, a = 11
}

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

ЦЕЛЫЙ, дробная часть отсекается:
void main(void) {
int a =

в зависимости от некоторых условий: если условие верно, поступать одним

выключение,
// остановить привод, иначе пересчитать напряжение фаз

Пример использования:

В общем случае часть «else {…}» может отсутствовать.

В теле оператора «if» или «else» может выполняться одно действие (как в примере выше), а может несколько. Если выполняется только одно действие, то фигурные скобки ставить не нужно, но всё равно рекомендуется.

включение, подготовить и
// запустить привод; иначе, если пришла

Также можно проверять несколько разных условий при помощи дополнительных блоков «else if (…)». Можно использовать сколько угодно таких проверок. В это случае будут выполнены только те действия, которые находятся внутри блока, условие которого истинно. Если истинны условия сразу в нескольких блоках, то будет выполнен только первый.

if (4)
doCase1();
else if (100 / 8)

Более привычным условием для оператора считается результат сравнения двух чисел/переменных:

// Если скорость двигателя меньше 100 об/мин,
// увеличить скорость; а если больше - уменьшить
if (driveSpeed < 100)
driveSpeed += 5;
else if (driveSpeed > 100)
driveSpeed -= 5;

даёт результат «истина», когда оба операнда не равны 0, иначе

Побитовое И («&») даёт результат операции «И» между соответствующими битами переменных. Используется для различных целей, например для наложения маски:

когда какое-то действие нужно выполнить в том случае, когда выполняется

// Если нет аварий, задание скорости не нулевое
// и есть команда запуска - запустить привод
// А если есть авария или команда "стоп" - остановить
if (faultCounter == 0 && speedReference != 0 && commandStart == 1) {
startDrive();
} else if (faultCounter != 0 || commandStop == 1) {
stopDrive();
}

обе они младше операций отношения и равенства.
Выражение вычисляется в порядке

Операции отношения имеют приоритет перед операциями проверки равенства.
Арифметические операции старше операций отношения:
a < b – 1 эквивалентно a < (b – 1)

его значение равно «истине», то выполняется инструкция. Этот цикл будет

// Вычитывание данных из массива до тех пор,
// пока он не опустеет
while (bufferEmptyFlag == 0) {
readDataFromBuffer();
bufferEmptyFlag = checkBuffer();
}

инструкция. Вычисляется выражение. Если его значение равно «истине», то цикл

// Пока не будет заполнен весь массив,
// заполнять его случайными числами
do {
// Записать в элемент с номером "counter" случайное число
buffer[counter] = randomNumber();
// Увеличить счётчик элементов
counter++;
} while (counter < bufferSize);

выполняется только один раз, затем проверяется выражение2, и если оно

известно количество итераций. Наиболее часто для работы с массивами.
В данном

// Очистить массив элементов
int i;
for (i = 0; i < bufferSize; i++) {
buffer[i] = 0;
}

в зависимости от значения переменной. Синтаксис оператора:

switch (переменная){
case значение1:
инструкция1;
break;

case значение2:
инструкция2;
break;

case

driveMode,
// запустить тот или иной алгоритм управления

СИ */
/* Определение и инициализация глобальных переменных */
int x =

на подзадачи, с целью упрощения отладки и возможности распараллелить процесс

степень
// Аргументы: x - число, которое нужно возвести
//

unsigned int powerA = 8;
long res;

//

Чтобы вызвать функцию, необходимо написать её имя и передать соответствующие аргументы. В примере выше функция называлась «power» и принимала два аргумента. Типы переменных которые передаются в функцию должны соответствовать типам аргументов. Это также касается и результата.

меняются внутри функции, как бы она не была устроена внутри.

// Функция умножения числа на 100
int multiple100 (int x) {
// Чтобы не занимать стек локальными переменными,
// не будем создавать переменную "result", а изменим
// само значение аргумента:
x = x * 100;
return x;
}

void main(void) {
int varA = 20;
int varB;

// Умножим переменную varA на 100 и запишем результат в varB
varB = multiple100(varA);
// В результате этой операции varB = 20000,
// А значение varA не изменится: varA = 20
}

*px;
Данная строка кода создаст переменную типа указатель.
То есть px хранит

// Объявить переменную varA и указатель, который пока что
// не указывает ни на какую переменную
int varA = 1;
int *pointerVarA;

void main(void) {
// Записать в указатель "pointerVarA" адрес переменно varA
// Символ "&" означает "получить адрес"
pointerVarA = &varA;

}

и присваивание. Увеличить или уменьшить указатель можно не только операциями

ячейке, на которую он указывает, при помощи оператора « *

// Объявить переменные varA, varB и указатель, который пока что
// не указывает ни на какую переменную
int varA = 1, varB;
int *pointer;

void main(void) {
// Записать в указатель "pointerVarA" адрес переменно varA
// Символ "&" означает "получить адрес"
pointer = &varA;

// Теперь запишем в переменную varB значение, которое хранится
// в ячейке памяти, на которую указывает pointer:
varB = *pointer;

// Так как pointer указывал на переменную varA, то теперь
// varB имеет такое же значение: varB = 1
}

находится по адресу 0x8807,
Указатель «pointer» пока что указывает на какую-то

«varA»

памяти, на которую указывал «pointer». Т.к. он указывал на переменную

Имя массива является указателем на его первый элемент
//

Указатели часто используются для перебора массивов

// Указатель на структуру
void main (void) {
//

Также может быть создан указатель на структуру. В таком случае указатель хранит адрес первого элемента структуры. При обращении к элементам структуры через указатель, используется оператор « -> » вместо « . »

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

// Функция чтения значения из регистра
int readValue (long* x){
// Если буфер пуст, вернуть -1
// Иначе записать значение и вернуть 0
if (bufferEmpty == 1) {
return -1;
} else {
*x = ethernetData;
return 0;
}
}

// Вызываем функция, передавая в неё адрес

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

фирмами удобно создавать различные функции в разных исходных файлах. Такой

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

означает, что в одном из файлов определена переменная « x

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

файла. Имя файла заключается либо в «” ”», либо в

Входными и выходными переменными являются переменные модуля.
// Файл “functions.c”
// Функция

описан интерфейс функций
*/

#ifndef FUNCTIONS_H_
#define FUNCTIONS_H_

long mult (int, int);
long div

к программированию */
/* Подключение заголовочного файла, в котором описаны интерфейсы

version)
Originator:

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

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

// Определить число Пи
#define PI 3.1416

void main (void) {
// Задать радиус и рассчитать площадь круга
float radius = 4;
float square = radius * radius * PI;
}

этой директивы можно определять не только константы, а любые конструкции.

// Макроопределение сложного условия
#define condition (forceRun == 1) || \
((startCommand > 0) && (enableRun == 1) \
&& (faults == 0))

void main (void) {
// Проверить условие запуска двигателя:
// либо есть команда принудительного запуска (forceRun),
// Либо есть команда обычного запуска, при этом нет аварий
// и работа разрешена
if (condition)
startDrive();
}

if (condition)
startDrive();
}
void main (void) {

Исходный файл:

После препроцессинга:

директив #ifdef и #ifndef, что соответ­ственно означает «если определено» и

в регистры
Осуществляет оптимизацию циклов программы
Удаляет неиспользованный программой код

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

оптимизации «-о0», и дополнительно:
осуществляет прямое присвоение локальных констант;
удаляет

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

при оптимизации «-о1», и дополнительно:
осуществляет улучшенную оптимизацию циклов;
удаляет

Оптимизатор использует «–o2» по умолчанию, даже если вы не указали уровень оптимизации. Оптимизация используется если ваш модуль не имеет функций, которые вызываются другими модулями или глобальных переменных, которые изменяются в других модулях

при оптимизации «-о2», и дополнительно:
удаляет все функции, которые не

всегда

зависит от состояния дискретных входов и выходов микроконтроллера. Компилятор видит,

от оптимизации

при выходе из функции (экономия процессорного времени)
не расходуют пространство