Ми

Вечером, пока шёл домой, промок .-. Но мороженое купил и съел<<

Доделал светомузыку. Ну, первый вариант. Для проверки притащил линейку светодиодную, где все RGB-пиксели управляются независимо.
Изучил, так сказать, быстрое преобразование Фурье на практике и на железе. Скорость на меге32 при 16 МГц, прямо говоря, не впечатляющая: при выборке в 256 точек оно выдаёт менее 10 fps.

Всё-таки решился посмотреть видео с феста>< Ну, всё не до того было. Надеюсь, это камера так голоса исказила, а не микрофоны ОО
Эх, так бы перед выступлением каждым снимать, чтоб каждый мог посмотреть на себя со стороны и понять, что же не так и как надо сыграть, было бы здорово ^^'

Вспомнил старую песенку, которая мне нравится и отсутствует в плейлисте и исправил несправедливость. Нашёл новую хорошую (то есть интересную) книжку. Почему же интересные книжки такие маленькие — кончаются за 2 дня? Хоть там и три части, но блин... ><
Ну да спать пора, как чай закончится.

Ради интереса просматривал каталог канекалона: он даже светящийся в темноте бывает =DD

@темы: мии, электроника

---

Погода разгулялась и стала офигенной. Я бы даже сходил погулять, было бы время:3

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

@темы: мии

---

Закрытая запись, не предназначенная для публичного просмотра

---

Закрытая запись, не предназначенная для публичного просмотра

---

Закрытая запись, не предназначенная для публичного просмотра

---

Пригшла какая-то тётка, сказала — освобождайте полку с продуктами и посудой, завтра сниму ==

И куда их девать прикажете — в шкаф на одежду, да? Или под кровать?=D

@темы: мии

---

Фест прошёл, пора и дипломом заняться=D

Интересно, будет ли хоть одна нормальная фотка?=)

@темы: мии

---

Язык С - заметка номер четыре.

Часто требуется обрабатывать пачки однородных данных. Например, для осреднения измерений АЦП, преобразования их с помощью Фурье для получения спектра, для обработки изображений как набора точек, обработки звука (набор амплитуд), файлов (как набор байт), строки и всякое такое.
И чтобы их представлять и обрабатывать есть две штуки в языке: массивы и указатели.
Начнём с простого. Массив – это когда мы размещаем в памяти целую кучу однородных переменных одну за другой. Одну, две, десять, сто, тысячу, миллион – сколько памяти хватит и сколько нам надо.
uint8_t array[10]; // Так записывается массив из 10 элементов uint8_t
uint32_t array2[10]; // То же самое, но элементы другого типа.

По сути, каждый элемент массива – отдельная переменная. Они никак друг с другом не связаны.
В качестве типа может быть всё то же, что и для обычных переменных – численные типы, структуры и всё, что угодно. Компилятор выделит под массив ровно столько памяти, сколько надо: array займёт, скорее всего, 10 байт (10 элементов по 1 байту), а array2 – 40 байт (10 элементов по 4 байта).
После того, как массивы объявлены, их можно использовать в программе:
array[1] = 10; // Поместить в 1 элемент массива число 10

Тут ещё такое дело, что элементы нумеруются с нуля =) Последний элемент имеет номер, на один меньший, чем общее количество элементов. То есть для array и array2 этот номер 9 (10 - 1).
array[0] = 0;
array[2] = array[1] + 1;
array2[9] = array[9] * 2;

// А вот так уже делать совсем не здорово:
array[10] = 0;
// Компилятор ругаться не будет – по синтаксису тут всё хорошо.
// Но этот элемент уже за пределами массива.
// Опять же, объясню чуть попозже, чем это грозит.

// Заполнить массив нулями:
for(i = 0; i < 10; i++) array[i] = 0;

Вот, как-то так. Попробую ближе к концу объяснить, как такое получается, что первый элемент имеет индекс 0, когда упомяну про указатели.
Дальше… Указатели – это такая хорошая штука, которая указывает (как неожиданно) куда-то в память. По сути, это переменная с адресом чего-то. Например, другой переменной.
Объявление выглядит так: <тип, на что указываем> * <название>;
uint8_t * pointer; // Объявили указатель на переменную типа uint8_t
// Если нам надо указатель на указатель, то так и пишем, не стесняясь:
uint8_t ** pointer_to_pointer;
// Указатель на указатель на переменную типа uint8_t.
// То есть указатель на переменную типа (uint8_t *).
// Только скобочки не обязательны.

Размер переменной-указателя зависит от платформы, для которой пишем код. Например, в AVR это 2 байта, для PC x86 и ARM это 4 байта, для PC x64 это 8 байт.
Массив – это не тип! Не надо указывать в объявлении указателя, что указываем на массив. Указателю пофиг, на что указывать.
Например:
pointer = &array[0]; // Теперь он указывает на начало массива array

Значок амперсанда является операцией получения адреса переменной. Почти все переменные находятся в памяти и, естественно, у них у всех есть свой адрес.
Так. Имея указатель на что-то, можно это что-то читать или записывать:
*pointer = 10; // По адресу, хранящемуся в pointer, запишем 10.
// То есть в array[0], так как сейчас pointer указывает на него.

Звёздочка сообщает, что мы работаем с переменной, адрес которой хранится в переменной, к которой этот оператор применяется (Оо).
Читается точно так же:
uint8_t a = *pointer; // Прочитали то, что записано по адресу...

Другой способ, аки доступ к массиву:
pointer[0] = 20; // В array[0] сидит теперь 20

Массив – это как раз по типу указатель и есть. Просто объявление массива ещё и выделяет память для него.
Адрес, который хранится в массиве, – это, по сути, обычное число. Например, 0x80123010. Потому можно применять к нему различного рода математические операции.
Начнём с простых и общеупотребительных:
Сложение. <указатель> + число (pointer + 3). Обратите внимание, что число трактуется как количество элементов, на сколько надо сдвинуть адрес! Если размер переменной 4 байта, а прибавляем к указателю три, то адрес увеличится на 12 (3 * 4 – три элемента по три байта).
Примеры:
pointer += 2; // Теперь он будет указывать на array[2],
// вне зависимости от того, какого типа array бы ни был.
// Компилятор адрес посчитает правильно.
pointer++; // Перейти на следующий элемент.
// То есть теперь указатель показывает на array[3].

Вычитание аналогично:
pointer -= 2; // Аналогично
pointer--;

Умножение и деление обычно прямо к указателю не применяют – это не имеет смысла, хотя и не запрещено.
Вот, как раз теперь можно показать, почему массивы нумеруются с нуля. Оператор [] может быть представлен через указатели таким образом:
// array[index] и *(array + index) — одно и то же.

А так как array уже указывает на начало массива уже, то, естественно, прибавлять к адресу ничего не нужно: array[0] = *array.
Отсюда же следует и то, почему не стоит переходить за границы массива.
uint16_t myarray[20]; // Какой-то массив
uint32_t myvar; // Какая-то переменная

Первая запись говорит компилятору о том, что нужно в памяти выделить массив на 20 элементов типа uint16_t и создать указатель myarray типа (uint16_t *), который, правда, не может менять адрес, на который указывает. Указателю всё равно, на что указывать и какого размера массив был создан!
Легко написать такой код:
for(i = 0; i < 30; i++) myarray[i] = 123;

При этом он честно запишет 123 в 20 элементов массива и ещё 10 элементов вне этого массива, где, скорей всего, будут располагаться какие-то другие переменные, как, например, myvar! Указатель о них ну ничего не знает. И поназаписывает, как если бы там продолжался массив. И хорошим это никак не закончится – программа обязательно где-то налажает, так как данные уже побиты.
Потому указателями надо пользоваться осторожно.
Пример копирования массивов через указатели:
// Два массива
uint16_t array1[10];
uint16_t array2[10];

// Указатели
uint16_t * p1;
uint16_t * p2;

// Счётчик
int i;

// Заполним массив array1 номерами элементов
for(i = 0; i < 10; i++) array1[i] = i;

// Скопируем поэлементно
for(i = 0; i < 10; i++)
{
array2[i] = array1[i];
}

// Сначала присвоим указателям адреса начала массивов
// Крутим, пока не дойдём до конца массива array1
// Прибавляем по 1 элементу к указателям
for(p1 = &array1[0], p2 = &array2[0]; p1 < &array1[10]; p1++, p2++)
{
*p2 = *p1;
}

// Иначе:
for(p1 = &array1[0], p2 = &array2[0]; p1 < &array1[10])
{
*p2++ = *p1++;
}
// В итоге у нас будет два одинаково заполненных массива

@темы: программизмы, C

---

Меня сегодня автобус затроллил .з.

Надо было проехать воот сюда...

Надо было проехать воот сюда:

Ну я подумал...

Ну я подумал, что раз они на одной улице, то если поехать вниз, то я и приеду .з.

Я и сел на него...

Я и сел на него, а этот нехороший транспорт уехал в сторону Электросилы=D

Эх. А, как я потом понял, надо было сесть на обратный.

Эх. А, как я потом понял, надо было сесть на обратный:


Наружный транспорт коварен и хитёр... Нужно быть осторожнее><

@темы: мии

---

Новый десятик

На второе апреля анонсировали новый десятик: Воронеж.


Вот ^^ А пока ждём 100500 лет, оно уже через пару-тройку недель должно бы:3

UPD от 01.04.2012:
- в железном виде оно появилось

вчера

30.03.2012! (правда, пока не у меня .з.)

UPD от 09.04.2012: в Питере оно тоже уже есть, инфа 100%.

---

Закрытая запись, не предназначенная для публичного просмотра

---

Язык С - пример 1. Компаратор.

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

Допустим, мы хотим из контроллера сделать компаратор. Есть вход АЦП и вывод с логическим уровнем 0 - 1.

Если измеренная величина превышает 123, то на ножке будет 1, если не превышает - 0.

Как такое сделать?

У нас есть 2 инструмента: АЦП, и цифрово вывод. Для каждого сделаем свой файл. Сделаем так, чтобы на других платформах потребовалось заменить только их.

Три модуля будет у нас:

1. Модуль АЦП. Инициализация и измерение

2. Модуль GPIO. Настройка и управление выводом.

3. Главный модуль - где и будет алгоритм работы сидеть.

Пример для atmega32. Но подойдёт и для ряда других =)

main.c:

---

//

// Пример 1: Компаратор

//

// Обратите внимание: здесь нет никаких зависимых от платформы заголовочных файлов а ля avr/io.h, stm32f10x.h, lpc17xx.h и т.д.

// Модуль АЦП

#include "drivers/adc.h"

// Цифровые выводы на порту B

#include "drivers/gpiob.h"

int main(void)

{

// Инициализация АЦП

adc_Init();

// Нулевой вывод на порту B назначить на выход

gpiob_SetOut(1 << 0);

// Бесконечный цикл - прибор работает, пока включён.

while(1)

{

// Измеряем напряжение на нулевом канале АЦП

uint16_t Value = adc_GetValue(0);

// Если величина превышает 123,

if(Value > 123)

{

// то устанавливаем высокий логический уровень;

gpiob_High(1 << 0);

}

else // если же нет,

{

// то устанавливаем низкий логический уровень.

gpiob_Low(1 << 0);

}

}

}

---

Всё просто и понятно.

drivers/adc.h:

---

//

// Модуль АЦП.

//

#include <stdint.h>

#ifndef _ADC_H

#define _ADC_H

// Инициализация АЦП

void adc_Init(void);

// Измерение напряжения

uint16_t adc_GetValue(uint8_t Channel);

#endif

---

Тоже всё просто.

drivers/adc.c:

---

//

// Модуль АЦП.

//

#include "adc.h"

#include <avr/io.h>

// Инициализация АЦП

void adc_Init(void)

{

// Включаем АЦП

ADCSRA = (1 << ADEN) | // ADC включён

// Предделитель: 16

(1 << ADPS2) | (0 << ADPS1) | (0 << ADPS0);

}

// Измерение напряжения

uint16_t adc_GetValue(uint8_t Channel)

{

// На неверный номер канала получите 0

if (Channel > 7) return 0;

// Ножку на порту A настраиваем на вход:

DDRA &= ~(1 << Channel);

// Выбор канала и опорноо напряжения (с чем сравнивать)

// REFS: 01 (AVCC с внешним конденсатором на выводе AREF)

ADMUX = (0 << REFS1) | (1 << REFS0) |

// Номер канала:

Channel;

// Возможно, здесь нужна небольшая задержка

// ...

// Запуск преобразования

ADCSRA |= (1 << ADSC);

// Цикл крутится, пока бит установлен.

// Он снимается автоматически по завершению преобразования

while (ADCSRA & (1 << ADSC));

// Вернуть результат измерения (регистр ADC двухбайтный)

return ADC;

}

---

drivers/gpiob.h:

---

//

// Модуль GPIO

//

#include <stdint.h>

#ifndef _GPIOB_H

#define _GPIOB_H

// Назначить выводы на выход

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние цифровых выходов

void gpiob_SetOut(uint8_t Mask);

// Назначить выводы на вход

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние цифровых входов

void gpiob_SetIn(uint8_t Mask);

// Высокий логический уровень на ножках

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние логической единицы, если порт назначен на выход

void gpiob_High(uint8_t Mask);

// Низкий логический уровень на ножках

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние логического нуля, если порт назначен на выход

void gpiob_Low(uint8_t Mask);

#endif

---

drivers/gpio.c:

---

//

// Модуль GPIO

//

#include "gpiob.h"

#include <avr/io.h>

// Назначить выводы на выход

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние цифровых выходов

void gpiob_SetOut(uint8_t Mask)

{

DDRB |= Mask;

}

// Назначить выводы на вход

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние цифровых входов

void gpiob_SetIn(uint8_t Mask)

{

DDRB &= ~Mask;

}

// Высокий логический уровень на ножках

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние логической единицы, если порт назначен на выход

void gpiob_High(uint8_t Mask)

{

PORTB |= Mask;

}

// Низкий логический уровень на ножках

// Mask: маска. Все установленные биты переведут соответствующие ножки

// в состояние логического нуля, если порт назначен на выход

void gpiob_Low(uint8_t Mask)

{

PORTB &= ~Mask;

}

---

Тут тоже логика достаточно проста. В АРМах практически то же самое, только что регистров побольше и они немного другие.

Архив с примером в AVR Studio 5 тут.

@темы: программизмы, C

---

Язык С - заметка номер три.

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

Что же такое функция? Я бы сказал, что это такая маленькая вспомогательная программка, которая делает какое-то законченное действие. Ей можно передавать параметры, – например, числа, которые надо как-то перемножить или строку, которую надо куда-то вывести. Аргументов может и не быть, если действие какое-то конкретное. Например, сбросить какой-то таймер.

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

Ну на этом лирика заканчивается и начинается более практическая часть:

<тип возвращаемого значения> <название функции>(<список аргументов>)

{

// А тут код, который что-то делает.

}

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

Если функция ничего не возвращает, то возвращаемое значение имеет тип void. И да, если у функции нет аргументов, то в списке аргументов пишем это же слово:

// Функция сбрасывает счётчик таймера в 0.

void timer_Reset(void)

{

// Тут код сброса таймера.

// Параметры функции не нужны, возвращать ей тоже нечего.

}

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

Вот пример объявления функции об опросе какого-то канала АЦП (то есть измерить напряжение на какой-то ножке):

// Функция возвращает результат измерения с заданного канала АЦП:

// Channel – номер канала (от 0 до 11)

uint16_t adc_GetValue(uint8_t Channel)

{

// Код измерения напряжения

}

В качестве типа для номера канала используется uint8_t - больше незачем. Так как номера от 0 до 12 туда вписываются. Тип результата выбирается такой, чтобы все значения могли быть в нём представлены. Например, тип uint16_t хорош для результатов измерения с не дифференциального входа (то есть который меряет от 0 до максимального значения) АЦП разрядности более 8, но не более 16.

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

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

// Функция выставляет на заданном канале ЦАП напряжение

// пропорциональное величине Value.

// Channel – канал ЦАП (0 - 1)

// Value - величина напряжения (0 – 1023)

void dac_SetValue(uint8_t Channel, uint16_t Value)

{

// Правильно ли задали параметры:

if (Channel > 1)

{

// Номер канала не верен, выходим: так как такого канала

// нет физически, то в функции больше делать нечего

return;

}

if (Value > 1023)

{

// Слишком много просят – обрежем до корректной величины

// Это не критическая ошибка в аргументах, так что

// продолжим с этим.

Value = 1023;

}

// А тут код, который напряжение выставляет.

}

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

// Функция возвращает максимальное значение из двух

uint8_t max(uint8_t A, uint8_t B)

{

if (A > B)

{

// Раз A больше, то вернём его

return A;

}

else

{

// Если же А меньше или равно B, тот вернём B.

return B;

}

}

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

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

// Функция возвращает максимальное значение из двух

uint8_t max(uint8_t A, uint8_t B);

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

С объявлением разобрались, теперь вызов функций. Тут тоже всё просто. Чтобы вызвать функцию, запишите её название, а в скобочках список аргументов в том порядке, как они требуются:

// На нулевом канале АЦП выставим напряжение, величиной 512 (из 1023).

dac_SetValue(0, 512);

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

// В переменной c будет храниться меньшее значение из a и b.

uint8_t c = min(a, b);

// Так же можно вызовы функции пихать в формулы:

uint8_t mm = min(a, b) + 10;

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

// Максимальное число среди переменных a, b, c.

uint8_t max3 = max(a, max(b, c));

Пока с функциями закончим.

Несмотря на то, что мы код разбили на законченные небольшие функции, при их большом количестве код будет плохо читаться – попробуй найди функцию в пять строчек в файле из двадцати тысяч строк. Не здорово. Потому надо проект разбивать на небольшие, и желательно, обособленные модули. Один из которых занимается АЦП, второй – ЦАП, третий ещё чем-то.

В любом почти проекте встречаются файлы с расширениями h (header, заголовочный файл) и c (файл с кодом). Рассмотрим их поподробнее.

Как я уже сказал, функциями можно пользоваться лишь после того, как компилятор о них узнал. А узнаёт он всё сверху вниз – от начала файла и к концу. И естественным образом (чтоб все вызываемые функции оказались выше тех мест, откуда их вызывают) функции бывает разместить весьма затруднительно, да и не надо. Для каждого модуля заводят по два файла: <название модуля>.h и <название модуля>.c.

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

---

// Описание модуля – что в нём содержится.

// Например, модуль работы с АЦП.

// Здесь идут подключение библиотек, если таковые требуются

// с используемыми типами данных (stdint.h, stdbool.h и т.д.)

#include

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

// включалось в элемент компиляции только один раз. Я потом

// расскажу как это.

#ifndef _ADC_H // Название даётся с потолка и я его обычно

#define _ADC_H // делаю из имени файла “adc.h”, добавляя

// спереди черту и вместо точки её же. Ну и капс.

// Функция инициализации АЦП (настройка портов и всего прочего)

void adc_Init(void);

// Функция возвращает результат измерения с заданного канала АЦП:

// Channel – номер канала (от 0 до 11)

uint16_t adc_GetValue(uint8_t Channel);

#endif // Тут файл заканчивается.

// И постарайтесь оставлять одну пустую строку в конце (Enter’ом)

---

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

adc_Init – можно прочитать как функция инициализации (Init) из модуля adc (adc.h).

dac_SetValue – можно прочитать как «Установить значение» (SetValue) из модуля dac (dac.h).

И так далее.

Второй файл содержит всю реализацию этих функций и не только. Примерное содержание файла adc.c:

---

// Описание модуля – что в нём содержится.

// Например, модуль работы с АЦП.

// Подключение библиотек.

// Сначала подключаем библиотеку именно от этого модуля:

#include "adc.h"

// Потом уже все остальные, нужные для реализации. Например,

#include

// Дальше объявляются внутренние типы, постоянные, макросы и функции:

// ...

// Потом переменные.

// ...

// Ну а в самом конце пишем реализацию всех наших функций.

// Желательно те функции, которые выписаны в заголовочном файле

// разместить рядом. Ну а все вспомогательные уже как удобно.

// Функция инициализации АЦП (настройка портов и всего прочего)

void adc_Init(void)

{

// Настройка портов, периферии и прочего.

}

// Функция возвращает результат измерения с заданного канала АЦП:

// Channel – номер канала (от 0 до 11)

uint16_t adc_GetValue(uint8_t Channel)

{

// Если канал неверный вернём 0

if (Channel > 11) return 0;

// Дальше меряем.

// ...

}

---

Сразу замечу – все заголовочные файлы из этого проекта пишутся в кавычках "adc.h". А все стандартные заголовочные файлы в угловых скобках: . Содержимое всех заголовочных файлов как бы впишется вместо этих строк: #include "…". То есть получится такой длиннофайл, который компилятор и будет обрабатывать.

В модуле могут быть различного рода вспомогательные функции, которые снаружи (из других модулей) никто не должен видеть. Такие функции объявляются точно так же, как и обычные, только не пишутся в заголовочном файле (а только сверху в фале с кодом) и имеют атрибут static:

// Функция измеряет заранее известное напряжение и вычисляет

// коэффициенты перевода числа в милливольты.

static void Calibrate(void);

Этот можификатор ограничивает область видимости только модулем, где функция расположена. В других модулях может быть и своя функция Calibrate, но при таком объявлении они не подерутся.

Теперь я расскажу, как, по моему мнению, стоит разбивать код программы на модули. Основной принцип я уже рассказал – по функциональному назначению. Все функции SPI – в модуль spi.h, I2C – в i2c.h и т.д.

Чем это хорошо?

Во-первых, этот код потом можно будет без особых проблем перенести на другой контроллер. Если там регистры настройки SPI немного не такие, что ж, нам потребуется лишь чуть-чуть подправить файл spi.c, не трогая остальные. Или вообще на другую платформу – с AVR на ARM. Тогда потребуется всего лишь переписать соответствующие функции периферии, в то время как логика работы останется той же.

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

@темы: программизмы, C

---

Язык С - заметка номер два.

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

if(<условие1>)

{

    // блок, если условие1 истинное

}

else if(<условие2>)

{

    // блок, если условие2 истинное, а первое ложное

}

...

else

{

    // блок, если все проверки завершились неудачей

}

По сути программа выполняется так: проверяется первое условие, если оно истинное, то выполняется блок, следующий прямо за ним. Если нет — проверяется следующее условие, коих может быть сколько угодно. Если ни одно условие не выполнилось, программа исполняет код в блоке после одинокого else. Всех дополнительных блоков с else может и не быть, если они не нужны. Пример:

if(D < 0)

{

    // Если дискриминант меньше нуля, то корней нет

}

else if(D == 0)

{

    // Если же a равно нулю (первое условие тут уже считается

    // ложным - иначе бы даже до проверки (D == 0) бы не дошли.

    // Есть одно решение квадратного уравнения

}

else

{

    // Здесь можно быть уверенным, что D заведомо больше нуля и

    // 2 корня есть.

}

В качестве логической переменной может выступать любое целое число. Ложь — когда число равно нулю, истина — когда не равно. В циклах это используется часто. Покажу ниже.Любые логические операторы (например, сравнения) на выходе дают результат выражения: 0(ложь) и 1(истина). Что можно без проблем использовать в обычных вычислениях. Но не стоит так делать из-за того, что это плохо читается.

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

Условие	Описание
X	Условие выполнено, если число не равно нулю.
!X	Оператор НЕ, превращает ложь в правду и наоборот. Выполнится, когда число равно нулю.
X == Y	Выполняется, если числа равны друг другу.
X != Y	Выполняется, когда числа не равны друг другу.
X > Y	Выполняется, когда X больше Y.
X < Y	Выполняется, когда X меньше Y.
X >= Y	Выполняется, когда X больше или равно Y.
X <= Y	Выполняется, когда X меньше или равно Y.

Пример:

if(x > 5)

{

    // Сюда попадём, только если x окажется больше пяти.

}

Условия можно комбинировать и проверять, так сказать, «пачками»:

Оператор	Описание
X && Y	Логическое И. Условие истинно, если оба аргумента истинны.
X || Y	Логическое ИЛИ. Условие истинно, если хотя бы один аргумент истинный.
!X	Логическое НЕ. Как я уже говорил, условие истинно, если аргумент ложен.

Все аргументы в таких выражениях постарайтесь обёртывать в скобочки, если они сложнее одной сущности (то есть выражения). Вот примерно так:

if((X > 0) && (Y > 0))

{

    // Сюда попадём, если X больше нуля и Y больше нуля.

}

Код аналогичен этому:

if(X > 0)

{

    if(Y > 0)

    {

        // Сюда попадём, если X больше нуля и Y больше нуля.

    }

}

Ещё пример с ИЛИ:

if((X < 0) || (X > 255))

{

    // Сюда попадём, если X меньше нуля или X больше 255

}

Второй способ условного выполнения полезен при выборе измножества вариантов:

switch(<условие>)

{

case <вариант1>:

    // какой-то код

    break;

    // Этим словом показываем, что всё сделали и

    // конструкцию покидаем

case <вариант2>:

    // какой-то код

    break;

...

default:

    // если ни один вариант не подошёл

    // Данной позиции может и не быть, если она не нужна.

}

Тут проверяются конкретные значения и ничего более:

// В переменной key хранится, допустим, код нажатой кнопки от 1 до 3.

switch(key)

{

case 1:

    // Нажали первую кнопку

    break;

case 2:

    // Нажали вторую кнопку

    break;

case 3:

    // Нажали третью кнопку

    break;

}

Достаточно полезная конструкция - куда как читабельнее, чем 100500 if-else if. Ладно, с этим пока закончим. Теперь циклы.

Первый тип циклов: for.

for(<выполняется перед циклом>;<условие продолжения>;<код после каждого блока перед проверкой>)

{

    // Блок кода, который повторяется много раз

}

Думаю, мало кто понял, о чём тут речь, если не встречали конструкцию ранее.Пример. Есть переменная i, которую нам надо прогнать от 0 до 99 с шагом 1. Например, посчитать сумму всех этих чисел:

uint8_t i; // Счётчик

uint16_t sum; // Сумма

sum = 0; // Обнулим перед сложением.

// Перед циклом сделаем i равным 0 - начальному значению.

// i = 0 - вот тут.

for(i = 0; i < 100; i++)

{

    // Сначала в каждой итерации цикла идёт проверка значения i < 100.

    // Если проверка проваливается (получаем ложь), то

    // цикл тут же заканчивается

    // После чего идёт блок кода

    sum += i;

    // после итерации и перед очередной проверкой

    // происходит изменение счётчика: i++

}

// Таким образом кодвнутри цикла выполнится при всех i от 0 до 99

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

for(;

{

    // Код, который будет выполняться вечно (условия выхода нет),

    // если только изнутри не произойдёт насильного прерывания цикла.

}

Второй тип циклов: while.

while(<условие>)

{

    // Блок кода

}

Цикл будет выполняться, пока условие истинно.

a = 50;

while(a--)

{

    // Код будет выполняться, пока a не станет 0.

    // Поясняю:

    // Сначала происходит сравнение переменной a с 0.

    // Если не равно - цикл выполнится.

    // Вне зависимости от результата проверки сразу после неё

    // a уменьшится на 1.

}

Бесконечный цикл здесь записывается так:

while(1)

{

    // Единица, как мы помним, тождественна истине, как и

    // любое ненулевое число

}

Третий тип циклов: do-while.В них проверка условия продолжения цикла осуществляется после блока кода, а таквсё то же самое.

do

{

    // Блок кода. Выполнится хотя бы один раз в любом случае.

} while(<условие>);

В циклах работают два специальных оператора: break и continue.

Оператор break тут же прерывает цикл. Вне зависимости от тип цикла, условийи чего угодно.

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

for(i = 10; i > 0; i--)

{

    if(i == 5) continue;

    // Если i будет равно пяти, то весь последующий код будет пропущен

    // Ну, не совсем весь, а только до концатекущего блока.

    if(i == 2) break;

    // Если i будет равно 2, то цикл будет с этого места прерван.

    // Какой-то полезный или бесполезный код

}

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

for(uint8_t i = 0; i < 300; i++)

{

    // По идее, цикл должен прекратиться, если i станет равным 300

    // Но такого произойти не может, так как тип uint8_t может

    // хранить числа только от 0 до 255! И сразу после 255 будет 0.

    // И условие продолжения никогда не будет нарушено.

}

Или так:

uint8_t i = 10;

while(i >= 0)

{

    // Вроде бы всё в порядке, но цикл опять жени когда не закончится.

    // Число i беззнаковое и никогда меньше нуля не станет.

    i--;

}

Так что внимательнее.

@темы: программизмы, C

---

Язык С - заметка номер раз.

Кто-то начинает изучать микроконтроллеры с ассемблера - это очень хорошо.

Однако, на одном ассемблере далеко не уедешь, посему надо знатьхотя бы основы Си.



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

1. Не зависит от конечного набора инструкций процессора.

2. Переносим - если правильно организовывать проект, выделяя не универсальные части в отдельный, зависящий от платформы модуль (файл).

3. Читаем, если правильно организовывать код истиль оформления. Это очень важно для поддержки своих старых и чужих проектов.

Ну пока хватит.

Итак, мы открыли среду разработки, создали проект и смотрим единственный несчастный файлик main.c (или как там его среда обозвала) с куцым содержимым:

void main(void)

{

    // Какой-то комментарий о том, что дальшевы сами

    // Все комментарии начинаются с двух косыхчёрточек

    /* Есть ещё такие, но я избегаю ихиспользования */

}

Вот у нас есть код, но он ничего не делает.

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

В языке есть встроенные типы переменных (char, int, short,long и т.д.), но я предпочитаю их не использовать ввиду того, что их размер в памяти не очевиден. Есть замечательная библиотечка stdint.h, в которой перечислены типы конкретных размеров и свойств - а в каждом компиляторе они пересчитываются в стандартные типы нужной размерности. Вот самые такие из них:

Тип	Размер (бит)	Знак?	Описание
uint8_t	8	нет	Может хранить числа от 0 до 255.
int8_t	8	да	Может хранить числа от -128 до 127.
uint16_t	16	нет	Может хранить числа от 0 до 65 535.
int16_t	16	да	Может хранить числа от -32 768 до 32 767.
uint32_t	32	нет	Может хранить числа от 0 до 4 294 967 295.
int32_t	32	да	Может хранить числа от 0 до -2 147 483 648 до 2 147 483 647.
char	8	*	Используется для хранения однобайтных символов (character).

* Зависит от компилятора

Объявление переменных выглядит следующим образом: <тип> <название переменной>;

Напимер:

uint8_t somevar; // Здесь будет храниться 8битное беззнаковое число

uint8_t varno2; // Ещё одно

char nya; // Здесь будем хранить символ какой-либо

Желательно переменные объявлять в начале блока — то естьчтоб перед ними была открывающая фигурная скобка и ничего более. Это уточним в примерах позднее.

Самое такое важное, наверное, — это оператор присваивания. То есть мы можем присвоить переменной какое-то значение. Числом ли, каким-то расчётом или из другой переменной —всё равно. Например:

somevar = 0; // Теперьв somevar записан 0.

varno2 = somevar; // В varno2 тоже. Они одного типа, всё хорошо.

nya = -2;

Вы можете без опасений присваивать переменные одинакового типа (одного размера и наличия знакового разряда), в остальных случаях стоит знать, что вы делаете и зачем. Это пойдёт отдельной заметкой о преобразовании типов. Числа можно представлять аж в трёх разрядностях: десятичной, шестнадцатиричной и восьмеричной.

Записывается это так.

Разрядность	Префикс	Пример
8	0	01, 0777, 0234.
10		0, 1, 1234, 999.
16	0x	0xFF, 0x1234, 0x44.

В компиляторе gcc есть поддержка двоичной разрядности: 0b11010101, но лучше это не использовать. И да, всегда перед использованием значения переменной убедитесь, что вы записали туда что либо. Иначе никто не поручится, что код будет работать правильно. Вот тут уже и можно кое-что попробовать.

Для начала посмотрим, какие есть в языке логические и математические операторы:

Оператор	Описание	Пример
X + Y	Сложение.	somevar + 1
X - Y	Вычитание.	3 - 1
X * Y	Умножение1.	somevar * 4
X / Y	Деление1.	somevar / 4
X % Y	Остаток от деления1.	somevar % 1
X | Y	Логическое ИЛИ2 (OR).	somevar | 0xF0
X & Y	Логическое И2 (AND).	somevar & 0x0F
X ^ Y	Логическое исключающее ИЛИ2 (XOR).	somevar ^ 0x55
-X	Изменение знака числа (0 - X).	-nya
~X	Инвертирование всех бит числа2 (NOT).	~somevar

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

²) Остерегайтесь применять логические операции на знаковых типах.

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

varno2 = somevar + 3 * 4; // Сначала умножится 3 на 4, потом уже прибавится

varno2 = (somevar + 3) * 4; // Сначала будет сложение, потом умножение

А ещё операции можно комбинировать с присваиванием, если один из операторов и результат – одна и та же переменная:

a = a + 2; // Эта и следующая операция делают одно и то же

a += 2;

a = a << 1; // То же самое с другим оператором

a <<= 1;

Пример кода со всем этим богатством:

#include

void main(void)

{

    uint8_t a, b, c; // Три беззнаковых однобайтовых переменных

    uint16_t d; // Двухбайтовая переменная

    a = 0; // Присваивание

    b = 0x11;

    c = ~b; // Теперь в c хранится 0xEE

    a += 10; // В a сидит 10

    a *= 2; // В а сидит 20

    b = c & 3; // В b сидит 2 (0xEE & 3 = 0b11101110 & 0b00000011 = 0b10 = 2)

    a = 255; // В а 255 - самое большое число, вмещающееся в эту переменную

    d = 255; // В d 255 - не самое большое число.

    a++; // прибавили 1 - теперь там сидит 0. Старший разряд не влез.

    d++; // прибавили 1 - теперь там сидит 256. Старший разряд перелез во второй байт.

}

А вот так делать не стоит:

#include

void main(void)

{

    uint8_t a, b, c; // Три беззнаковых однобайтовых переменных

    a = 0; // А инициализировали, а про b забыли...

    // В b теперь может быть всё что угодно.

    c = a + b; // Теперь в c хранится фиг знает что.

}

@темы: программизмы, C

---

Упс, когда я воду от макарошек хотел слить, у "кастрюли" (или уже её остатков?) отвалилась-таки ручка и 2/3 макарон попали на пол .з. Ну ещё разбилась единственная тарелка и я пролил кипяток на ногу =D

Впрочем, рыбки было достаточно, был хлеб, да и макарошек чуток оставалось, так что поужинал-таки, благо ещё была Стася и дала мне тарелочку на время запасную :3 А ещё и чай с шоколадкой ^^

@темы: мии

---

Грр, ...

Грр, сосед с девушкой своей уже в течении 6-8 часов сосуться и щупаются без перерыва .з. Достали...

Уже пятый час, спать пора .з.

@темы: мии

---

Ми, ожидаю 50 контроллеров atmega48-au. Чтоб какое-нибудь мелкое электронное барахло на них собирать =)

Может, подпишусь ещё на что по оптовым ценам..

@темы: электроника

---

Оес, 20 марта выйдет новый десясик:3 100500 лет зарождения российской государственности или как-то так :3



Ждём, ждём:3

@темы: монетики

---

О, добавили ещё монетку новую юбилейный к планам: "Эмблема празднования 200-летия победы России в Отечественной войне 1812 года" :3 Жаль, конечно, что не десятик, но тоже ничего ^^"
И уже им пора начать - два месяца года уже прошли .з.

Предварительный план на 13 год по десятикам (не помню, каков он был):
- "XXVII Всемирная летняя универсиада 2013 года в г. Казани" - 2 штуки;
- "Города воинской славы": Вязьма, Кронштадт, Наро-Фоминск, Псков, Козельск, Архангельск, Волоколамск, Брянск.

И биметаллические: "Республика Северная Осетия-Алания" и "Республика Дагестан".

@темы: монетики