Открытый проект универсального зарядника
Урок №7 (Переменные)
Теперь, когда приблизительно ясно что такое процессор, что такое язык, что такое ход выполнения программы, т.е. есть общий взгляд на картину, начинаем приближаться и рассматривать ее более детально, но все же не до самой тонкости.
Где-то выше мы отмечали, что всему в мире можно присвоить код и этот код можно хранить в памяти компьютера в виде напряжений в ячейках памяти, которые устроены как конденсатор (заряжен/незаряжен) или как триггер из 6ти транзисторов (который соединяет выход либо с землей либо с +5в питания) или это домен (маленький магнит) в магнитном слое на винчестере/дискетке/ленте или это дырка в перфокарте как это было на заре цивилизации.
Итак все вышеперечисленное это 1 бит информации - да/нет, инь/янь, земля/+5в, дырка/недырка, север/юг магнита, мужчина/женщина, нолик/единичка, день/ночь, порядок/хаос.
Всего 2 состояния, поэтому и двоичная система исчисления. В двоичной системе всего две цифры 0 и 1. В двоичной системе нет цифры 2, но есть число 2 и оно записывается так: 10.
Просмакуем ситуацию с десятичной системой исчисления.
В десятичной системе исчисления 10 цифр: 0,1,2,3,4,5,6,7,8,9 и тоже нету цифры 10, но есть число 10 и записывается оно: 10.
В шестнадцатиричной системе исчисления 16 цифр: 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f и тоже нет цифры 16, но есть число 16 и записывается оно: 10
Теперь сделаем важное замечание: при попытке записать число в разных системах исчисления количество предметов не меняется, меняется способ записи, меняется вид, но смысл остается тот же.
В тексте программы мы будем записывать абсолютный смысл числа предметов разными цифрами, имея ввиду одно и тоже количество.
Если вам надо перевести какое то число из одного вида исчисления в другой, воспользуйтесь виндусовым калькулятором (в настройках указать вид-инженерный).
Если мы говорим про ноги процессора, то нам удобнее двоичный вид.
Если мы говорим про целые числа предметов, то нам удобнее десятичный вид.
Если мы говорим про большие адреса или большие двоичные числа, то удобнее 16тиричная система. 16тиричная и двоичная очень похожи и удобны в преобразовании из одной в другую. Двоичная система очень громоздкая, 16тиричная - компактная.
Исторически сложилось что первые нормальные процессоры были 8-битными. Это значит что в одной ячейке информации параллельно хранились 8 битов информации и это значит, что шина данных между процессором и памятью состояла из 8ми проводов. Запрашивая данные из ячейки памяти процессор получал одновременно 8 битов.
8 битов информации могут хранить в себе число от 00000000 до 11111111 или в десятичной от 0 до 255 или в шестнадцатиричной от 00 до ff.
Процессор АТМЕГА32 это 8 битный процессор, значит все вышесказанное относится к нам.
С данными разобрались, теперь адрес. Если данные это содержимое ящичка, то адрес это номер ящичка по порядку. И то и другое есть число. И то и другое записывается в 2,10,16 тиричном исчислении. Необходимо четко понимать в компьютере есть только два вида чисел: данные и адрес. Все остальные слова, придуманные международным сообществом (ссылка, метка, идентификатор, дата …) - это все либо данные либо адрес.
Когда я себе представляю мысленно память компьютера, я вижу следующее:
Адрес Данные
0000 15
0001 2f
0002 ff
0003 67
…
fff9 12
fffa 32
fffb 00
fffc ff
fffd ff
fffe aa
ffff 45
Все данные хранятся в ячейках памяти компьютера, каждая ячейка имеет адрес и в каждой ячейке лежит один байт.
Хотите писать программу с датами, числами с плавающей точкой, с большими целыми числами - выкручивайтесь как хотите. Это ваши проблемы. Компьютер устроен так и не иначе.
Вот мы и будем выкручиваться как хотим, но в соответствии с международными стандартами.
Для того чтобы компилятор понимал с какими данными мы работаем в нашей программе, мы должны явно указать типы всех наших данных. Четко зная тип данных компилятор выделит строгоопределенные ячейки данных и будет в них хранить наши данные-переменные.
Некоторые компиляторы неСи не требуют описания переменных, тогда они сами догадываются о типе из текста программы или во время работы программы меняют тип, но это излишние затраты памяти и быстродействия, а это произвол и нам это не подходит. Наш компилятор предсказуем, отсебятину не несет, делает строго то что мы просим и требует от нас исчерпывающей однозначно понимаемой информации. В противном случае компилятор сигнализирует о неполноте программы.
ТИПЫ ДАННЫХ:
-------------------------------------------------------------------------------------------
“BYTE” - тип данных один байт - маленькое целое беззнаковое число от 0 до 255.
“unsigned char” - это тоже самое по смыслу выражение и также будет понято компилятором.
ВНИМАНИЕ! Язык Си, если не указано в настройках, различает большие и маленькие буквы. Т.е. написание букв большии или маленькими важно и отслеживается.
Пример использования в Си:
BYTE x=7, y=0x45, z=b00010010;
В этой строке мы сказали компилятору выделить гденибудь где удобно в памяти 3 ячейки. В одной ячейке будет храниться переменная “x” в другой “y” в третей “z”. Компилятору абсолютно все равно как вы назовете переменные, для него важно, что везде где встретится x в программе он будет вспоминать о том месте где он выделил память и будет оттуда брать саму переменную или записывать ее туда. Название переменной не попадет в текст машинного кода, значит длинна названия переменной никак не повлияет на экономию памяти машинного кода.
Переменные могут называться только латинскими буквами и цифрами из 32 знаков причем первая обязательно должна быть буква.
Когда компилятор выделяет память - это значит что у себя он где-то просто запомнил адрес который он выделил, а с памятью непосредственно он ничего делать не будет. Слово “выделил” ничего такого волшебного не подразумевает.
При описании переменной мы поставили знак “=”, этим мы сказали компилятору вписать в программу на машинных кодах небольшой код по инициализации переменных. Это значит, что после того как ЗУ включится, первым делом программа на машинных кодах впишет в ячейку с адресом переменной (которую мы называли x) число 7.
В переменную “y” мы попросили записать 0x45 (таким образом мы сказали компилятору, что 45 это 16тиричное число).
В переменную “z” мы попросили записать b00010010 - двоичное число. Мне именно необходимо двоичное число, чтобы видеть на какой ноге будет +5в. Каждый знак в двоичной записи соответствует ноге АТМЕГА32 - это очень удобно (это только если реч идет о порте ввода вывода A,B,C,D).
Разные компиляторы по разному требуют запись двоичного числа. Тот компилятор который я использовал глючил в этом вопросе, поэтому для своего удобства я поправил ситуацию самодельщиной - добавил в программу команду препроцессора “#define b00010010 0x12”, т.е. перед компиляцией заменить все b00010010 на 0x12.
BYTE будем использовать для маленьких целых для организации циклов, для работы непосредственно с памятью, для хранения всяческих маленьких настроек ЗУ.
-------------------------------------------------------------------------------------------------
“int” - это 2 байта. В памяти хранится сначала младший байт потом старший байт. Когда мы говорим об адресе в памяти для переменной int, то говорим об адресе младшего байта, т.е. первого из двух.
Два байта может вместить в себя беззнаковое число от b0000000000000000 до b1111111111111111 или от 0 до 65535 или от 0x0000 до 0xffff. Думаю уже понятно что есть что.
А если число знаковое, то вот что придумали программеры.
они как бы перекинули половину диапазона в отрицательную часть числа. Получилось, что знаковый int может принимать значения от -32768 до 32767 это ровно такое же количество чисел как и было. Никто не пользуется отрицательными двоичными и шестнадцатиричными числами это может привести к путанице. 2ичные и 16тиричные используются в контексте реальных адресов и данных и непонятно что такое отрицательный адрес. Но заметим одну важную особенность: у отрицательного числа самый старший бит 1. Больше на эту тему распространяться пока не буду. Хотите поточнее узнать - играйтесь с калькулятором.
int - это знаковое целое (-32768 до 32767)
unsigned int - это беззнаковое целое (0-65535)
unsigned int писать очень долго поэтому сделаем #define WORD unsigned int и будем везде писать WORD
Этот тип переменных мы будем использовать для счетчиков циклов, для средних целых, для ШИМ счетчиков, для контрольных сумм, для АЦП суммирования.
--------------------------------------------------------------------------------------------------------
Заметьте уже второй тип переменных строго ограничен в своих значениях. С одной стороны мы точно знаем что потратили только 2 байта при использовании переменной, а мы по жмотски будем экономить каждый байт, но с другой стороны мы получили головную боль по переполнению переменных и жесткому отслеживанию рамок. Например если к WORD(65535) добавить 1 то получится 0. А если от WORD(0) отнять 5, то получится 65531 и компилятор вам не поможет в этом вопросе, т.к. вычисления производятся уже после того как прога с машинными кодами уже во всю заряжает и разряжает.
По личному опыту, будьте внимательны, очень часто совершаются ошибки с переполнением или со сравнением разных типов. Эти ошибки очень трудно найти, только с отладчиком, но какой отладчик в ЗУ при зарядке? В принципе можно и отладчик, но это такие сложности с дополнительным железом. Легче писать правильно и иметь опыт.
Тоже самое эмуляторы и симуляторы - очень неудобны, отнимают много времени. Мне кажется, что наиболее эффективны 2 способа: внимательно проверить программу и спросить специалиста о камнях или исправить программу с целью поставить опыт прямо на ЗУ с выводом необходимой инфы на экран ЗУ. К сожалению, это поможет, если вы уже переправились и захватили плацдарм в виде хотябы одной отзывчивой прошивки и от нее можете танцевать.
Все что сказано про int (integer - целое число без дробной части) справедливо и для других двух типов: short (короткий 1 байт) и long (длинный 4 байта).
unsigned short это тоже самое что и BYTE, за одним маленьким исключением: некоторые стандартные функции требуют именно short, а не BYTE.
long - это ооочень много - это можно считать сотые доли секунды в течение всего дня и long не переполнится.
------------------------------------------------------------------------------------
Ну и наконец float это число с плавающей точкой занимает 4 байта. Как хранится в памяти мне не известно да и не надо знать.
Все точные вычисления до 4 знака после запятой будем делать в переменных типа float (токи, напряжения, сопротивления, балансировочные коэффициенты, интегралы-суммы, диференциалы-наклоны). Это самые медленные операции. Одна графическая карта ATI или nVIDEA может пережевать милионы операций с плавающей точкой, а АТМЕГА32 не более 100 операций в секунду и это сильно тормозит все остальные операции ЗУ.
Поэтому перед тем как программировать надо ооочень хорошо подумать как сократить количество вычислений как упростить все формулы, а что можно вычислить заранее и ввести в формулу в качестве коэффициента.
------------------------------------------------------------------------------------
Последний тип который нам понадобится - bool от слова boolean тип логической переменной, которая может принимать два значения true (правда) и false (лож), т.е. это и есть один бит информации. Хранить один бит информации в памяти где все хранится по 8 бит это у компилятора вызывает трудности: либо наплевать на экономию и хранить бит как байт (0-лож, >0-правда) либо заморачиваться с запоминанием в каком байте какой бит соответствует нашей переменной.
Мы то точно будем заморачиваться на эту тему, т.к. мы жадные, а bool переменных (флагов) у нас много. Но об этом потом.
------------------------------------------------------------------------------------
В заключение скажем, что меньшая банка помещается в большую легко. Например long=int компилятор спокойно преобразовывает. А вот в обратную сторону могут происходить чудеса. Нужно быть внимательными.
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
В общем сказка стала суховатой и скучной. На следующем этапе будем ставить эксперименты с ЗУ, будем писать маленькие очень понятные программки и гонять их на ЗУ. Конечно примем меры чтобы не спалить транзисторы. Заодно будем наращивать мышцы.
Скажите пожалуйста, подойдет ли для этого проекта ATmega32A-AU?
28.07.2008
Выпущены новые микросхемы ATmega16A и ATmega32A - на замену микросхемам ATmega16 и ATmega32. В новых ATmega16A и ATmega32A переработана топология металлизированных слоев кристалла таким образом, чтобы уменьшить энергопотребление микросхемы, но при этом сохранить полную совместимость с популярными ATmega16 и ATmega32. Новые микросхемы имеют меньший ток потребления как в активном режиме работы микросхем, так и в режимах энергосбережения.
В отличии от ATmega16 и ATmega32 новые микросхемы не будут иметь модификаций с суффиксом “L” - новые ATmega16A и ATmega32A будут работать в диапазоне напряжений питания от 2.7В до 5.5В, обеспечивая максимальную производительность 16МГц при напряжении питания 4,5…5,5В и 8МГц - при напряжении питания 2.7В.
Ниже для сравнения приведены значения энергопотребления микросхем ATmega32 и ATmega32A
Ниже для сравнения приведены значения энергопотребления микросхем ATmega16 и ATmega16A
Да подходит.
Забыл сказать важную вещь про вычисления с плавающей точкой: необходимо таким образом составлять формулу, чтобы компилятор на каждом этапе вычислений находился в среднем диапазоне чисел это повысит точность вычислений. На каждом этапе вычислений точность падает до велечины округления. Т.к. мы используем float (4 байта на хранение и вычисление переменной), а не double (8 байт на хранение и вычисление переменной), точность с каждым вычислением будет уплывать и уплывать, особенно если мы будем выскакивать в +бесконечность или будем приближаться к нулю.
Поэтому правило: стараться чтобы каждое вычисление внутри формулы приводило к результату от 0.001 до 1000 (по модулю) и хранилось в этом же диапазоне и только в самом конце (перед отображением) приводилось к истинному порядку величины. Такие простые правила позволят не потерять точность на стадии вычислений, хотя бы точность уже была потеряна на стадии помех в схеме ЗУ.
Урок №8 (операторы)
До сих пор я много говорил про команды процессора (управляющие ноги процессора, мостов, памяти, устройств ввода/вывода), говорил про команды машинных кодов, говорил про функции (подпрограммы и программы).
При упоминании про команды сразу представляется, что есть некий исполнитель и есть некая последовательность действий (команда) которую надо исполнить.
Как видите мы утопаем в количестве информации про которую надо говорить и употребление слова команда приводит в замешательство: в каком смысле оно используется, поэтому при описании языка Си, имея ввиду команды, мы будем использовать слово ОПЕРАТОР.
Оператор - это то, что должен исполнить процессор при выполнении программы.
Оператор это как бы логическая единица выполнения.
Оператор это одно выражение, заканчивающееся “;”.
Оператор может быть сложным, состоящим из множества функций.
Оператор может состоять из одной функции. Функция и оператор это почти одно и тоже.
Программа Си - это последовательность операторов.
В ассемблере программа это последовательность машинных команд. В Си оператор - это более емкое понятие более приближенное к жизни. В ассемблере мы должны помнить из чего состоит переменная и работать с каждой ее частью. В Си мы работаем целиком с переменной как с единой сущностью, не переживая как там все устроено.
Операторы - это тело программы.
Оператор - это кусок программы.
При написании программы операторы могут располагаться в одной строчке или каждый оператор на новой строчке.
Оператором может называться как все выражение от “;” до “;” так и самое главное слово или знак, отражающий смысл оператора.
Например:
x=47*y; // Здесь оператор “=”
goto qqq; // Оператор перехода goto
for(int i=0; i<45; i++) // Оператор цикла for
{
break; // Оператор выхода из цикла
if(x<y)e=4; // Оператор сравнения if
…
}
if(x<y)e=4; // Оператор сравнения if
Всегда вернёт true. 😉 Должно быть “==”.
Воизбежание подобных радостей надо ставить константу вперёд.
if 4=(x<y)e компилятор не пропустит. 😉
Это я просто бессмыслицу писал чтоб про операторы сказать.
Урок №10 (Первая настоящая программа на Си для АТМЕГА32)
#include <avr/io.h> // Общая муть
#include <avr/iom32.h> // Мега 32
#include <avr/wdt.h> // Стандартные описатели собаки
#include <util/delay.h> // Стандартные описатели задержек
#include "bit.h" // Обращение к битам портов по названию
//------------------------------------------------------------------------------
// Главная программа запускается по ресету
int main(void)
{
// Это магические слова, чтобы ЗУ себя не спалило
cli(); // Запрет всех прерываний
WDTCR=15; // Инициализация сторожевого таймера
WDTCR=15; // Инициализация сторожевого таймера
PORTA=0; // В порту A все нули 0000 0000
PORTB=0x1c; // В порту B все нули 0001 1100 кроме PB2 PB3 PB4 (клавиатура подтянута на +)
PORTC=0x80; // В порту C все нули 1000 0000 кроме PС7 (клавиатура подтянута на +)
PORTD=0x02; // В порту D все нули 0000 0010 кроме PD1 (подтяжка TXD на +)
DDRA=0; // Задаем направление работы ног порта A 0000 0000
DDRB=0x43; // Задаем направление работы ног порта B 0100 0011
DDRC=0x7f; // Задаем направление работы ног порта C 0111 1111
DDRD=0xfe; // Задаем направление работы ног порта D 1111 1110
// Этот цикл выполняется бесконечно. То что нам надо!
while(true)
{
wdt_reset(); // Сброс собаки
_delay_us(10000); // Задержка 0.01 секунды
PORTD_Bit7=1; // Подать напряжение на динамик
_delay_us(10000); // Задержка 0.01 секунды
PORTD_Bit7=0; // Убрать напряжение с динамика
}
// Хотя сюда программа никогда не доберется, мы обязаны закрыть все скобки и соблюсти все правила хорошего тона.
}
// Конец главной программы
//------------------------------------------------------------------------------
После запуска этой программы мы услышим тарахтение динамика.
Для того чтобы ехать быстро, приходится очень долго запрягать. Вот и в нашем случае, мы будем ставить эксперименты на ЗУ и, чтобы его не спалить, приходится писать лишний код (слэнг программеров обозначает программировать). А также в начале программы мы подключили очень много файлов описателей. Просто не обращайте на них внимание. В зависимости от того какие вы используете операторы в своей программе, необходимо подключать соответствующие файлы описателей. Этот вопрос решается экспериментально или читая хелп на операторы.
Самое интересное в этой программе, то из-за чего все было затеяно, это внутренности оператора while
АТМЕГА32 будет бесконечно выполнять все операторы внутри цикла, т.к. условие while(true) всегда истинно, значит дойдя до нижней скобки цикла “}” и проверив условие (true), программа начнет цикл заново от верхней скобки “{”.
Внутри цикла выполняются последовательно оператор wdt_reset(); - сброс собаки, _delay_us(10000); ничего не делать (выполнять пустой код, растрачивая время) в течение 10000 микросекунд, т.е. 0.01 секунды, потом установить на 16 ноге проца 5в PORTD_Bit7=1;, потом опять подождать и сбросить в 0в
В этом месте можно спросить нестесняясь любой вопрос. Иногда какая-то мысль или недоразумение мешает, потому что захватывает на себя сознание и мешает понимать дальше.
WDTCR=15; // Инициализация сторожевого таймера
WDTCR=15; // Инициализация сторожевого таймера
К логопеду пора… 😃
Вопрос в точку, я про это стал забывать уже, а в коментах не написал.
Здесь тонкий момент однако присутствует. Во избежание случайной записи в настройки таймера собаки, производится обращение к регистру таймера и непозднее чем через 4 такта производится запись значения. Точно не помню надо даташит смотреть. Но внешне это выглядит как задводвоение.
И про
if(x<y)e=4;
здесь все верно написано. Это не Си-шный изворот это простая конструкция
if(x<y)
{
e=4;
}
Урок №11 (Вычисления выражений)
- Особенности вычисления длинных выражений:
Рассмотрим пример:
x= (…) / ((…) + ((…) * (…)));
Как бы, вы, вычисляли данное выражение? …
Компилятор это делает немного иначе, но в целом тоже самое! Компилятор находит самые внутренние скобки и в них два операнда (т.е. числа слева и справа от знака операции (слагаемых, вычитаемых, умножаемых, деляемых) далее выполняет над ними операцию и получает результат. Результат хранится во временной переменной. Таким образом выражение упрощается вместо двух операндов и операции осталось вычисленное значение - временная переменная. Теперь опять компилятор ищет самые внутренние скобки и т.д. В конце концов от всего выражения остается одно значение - результат, лежащий во временной переменной, который вписывается в память где у нас должна располагаться переменная “x”. Само вписывание и есть оператор присваивания.
НО возникает два вопроса про детали вычислений:
- Если компилятор нашел внутренние скобки, а там a+b*c, то сначала складывать или умножать? То чему нас учили в школе в принципе компилятору известно, но жизнь и все возможные ситуации не укладываются в школьные представления, потому что есть и другие операции кроме ±/* и определить порядок вычислений на все случаи жизни бывает очень трудно, да и запоминать тот порядок который принят у компилятора трудно.
Выход есть! Самый высокий приоритет у скобок. Если вы скобками подскажете компилятору порядок, то однозначно будете уверены, что все будет сделано правильно. Чем больше скобок, тем лучше. Скобки не отразятся на длине машинного кода. Совсем все скобками заполнять не надо, только там где вы не уверены.
- А как компилятор будет складывать 5 груш и 4 яблока? Или, например, сколько будет 5/4? Что происходит с типами при вычислениях?
Напоминаю, что если в вашей программе где либо встретится выражение 5/4, значит ваша программа неэкономная. Все что можно вычислить заранее, надо вычислить и вписать готовое в программу. В программе должны быть только переменные и несокращаемые коэффициенты. Я пишу 5/4 как пример, чтобы сразу было видно тип числа целое/целое.
Отвечаю компилятор выполняет только те операции которые у него описаны внутри его создателями, все непонятки компилятор приводит к понятным типам “по умолчанию” (т.е. как попало, как было в памяти случайно, как предсказал Билли, как вы предсказали заранее не зная что будет, как считает правильным международное сообщество программеров Си). В данном случае последний вариант.
Если операнды (слагаемые…) разных типов, то надо их привести к одному типу, а как складывать одинаковые типы ясно. Существует список из 20 правил по которым неодинаковые типы приводятся к одинаковым. Приводить эти правила я не буду, потому что разные компиляторы имеют некоторые отличия, но в целом можно сказать, что более простой тип из двух приводится к более сложному и операция выполняется над двумя сложными.
И опять есть выход который позволит нам точно быть уверенными что компилятор все сделает правильно: мы можем явно подсказать компилятору что делать с типами. Например int(x) - превратит x в целое число, просто отбросит дробную часть без округления, а остатки как может запихает в целое число.
После вычисления правой части выражения результат оказывается во временной переменной (без имени), которая может отличаться по типу от переменной слева x. Перед записью в x временная переменная тоже трансформирует свой тип в тип переменной x.
- Как понимать выражение “x=x+1” ? Это не уравнение. Это запись обычного выражения Си. И вообще в Си нет никаких уравнений. За уравнениями обращайтесь в маткад. Все выражения в Си - это порядок вычислений. Порядок “строго” задан все данные в наличии имеются, никаких колдований с решениями уравнений в программе нет. Вы уже все сколдовали заранее и в программу поместили готовые формулы расчета корней. Поэтому, компилятор, увидев x=x+1, делает следующее:
достает из адреса где лежит x содержимое (значение х) добавляет 1 и кладет это значение назад в x.
Кому может понадобиться добавлять 1 к переменной? Очень часто используется такое выражение, например перебирая массив данных, работая с каждым элементом, мы указываем номер элемента или меняем переменную цикла чтобы цикл выполнился ровно 100 раз. Для упрощения записи, только в Си, придумали записывать x=x+1 несколько иначе:
x=x+1; или
x++; или
++x; или
x+=1;
Все эти выражения означают одно и тоже x=x+1;
Например если вам надо цикл выполнить 100 раз, то пишем:
for(int x=0; x<100; x++)
{
Внутренности скобок выполнятся 100 раз и при каждом прохождении цикла переменная х будет содержать
число от 0 до 99 по порядку
}
А если надо добавить 2, то:
x=x+2; или
x++; x++; или
++x; x++; или
x+=2;
если в вашей программе где либо встретится выражение 5/4, значит ваша программа неэкономная.
Вроде бы практически все компиляторы, такие вещи обрабатывают такие вещи на этапе прекомпиляции… А для программера бывает наглядее иной раз написать именно a=2/2; вместо a=1;// a=2/2=1;
Вы правы, если компилятор сможет увидеть, то он это сделает.
Но иногда в формулах может быть достаточно сложное выражение и неоднозначно сокращение.
Когда приходится экономить каждый байт лучше надеяться только на себя.
В конце концов можно поставить эксперимент: попробовать так и так и сравнить длину кода.
Если длина несущественна, то конечно понятийная сторона должна брать верх.
все таки постинкремент и преинкремент разные вещи:
a = 5;
b = a++;
в результате: а=6, b=5;
a=5;
b=++a;
в результате: a=6, b=6;
Ага до этого еще не добрался.
Хотел отдельно тему завести “выпендроны Си”.
Урок №12 (философия Си)
Создатели языка Си очень экстравагантные люди. Это видно по тем конструкциям, которые они придумали. Например чего стоят a++; или того хуже b=a++; или совсем плохо b=(a=a+1); или a=b=c=d+1; Таких конструкций нет ни в одном языке программирования. Подобного рода конструкции осуществляют присваивание справа на лево, т.е. сначала осуществляется расчет выражения и присвоение справа а потом все левее и левее.
На этом создатели Си не остановились. В каком то ветхом году уже был придуман язык Си++ (поэтому названия файлов с кодом *.cpp) в котором была совершена революция в обобщении типов переменных и операций над ними.
Было введено понятие “класса” и “объектно ориентированного программирования”, которое потом было подхвачено другими языками, но так изящно не было реализовано ни у кого.
Обо всем можно говорить просто и также просто мы скажем о классах, но сначала подытожим наши знания о Си и языках программирования.
Итак есть железяка - ЗУ или винчестер или флэшка или комп или замок с таблетками или жпс навигатор или любая другая железка с процессором внутри. Сама по себе железка ничего делать не умеет, в ней заложена возможность, но она недоступна без программы. Без программы мозг железки пуст. Чтобы она ожила, необходима программа. Программа формирует поведение устройства. Устройство либо спит и ждет команды человека, либо дежурит выполняя монотонные действия, ожидая сигналов от датчиков, кнопок клавиатуры, сигналов из сетки и т.д. Потом появляется человек, передает команды, устройство выполняет и возвращает результат в виде изображения, звуков или других воздействий на наши органы чувств. И нам кажется, что мы общаемся с искусственным разумом, который реагирует на наши команды и выдает нам результаты. А на самом деле мы общаемся с тенью программиста, который когда-то сформулировал все модели поведения программы.
Для реализации всех возможных моделей программист мысленно как бы проделал все возможные жизненные ситуации и подсказал программе как надо вести себя в каждой. При этом требуемая информация лежала в массивах памяти и переменных, преобразовывалась и записывалась в другие переменные и воздействовала на внешний мир через порты ввода вывода.
Сама работа программы - это продвижение по ее тексту, как ребенок водит пальцем по тексту книги, и в том месте где палец, те команды непосредственно в данный момент выполняются. Текст программы ветвится логическими конструкциями в зависимости от содержимого переменных, но в целом ходит кругами и петлями, пока устройство не отключат от питания.
Старый способ программирования (до “классов”) подразумевал, что есть строго ограниченное количество типов переменных и операций над ними. Например целые числа можно складывать делить умножать вычитать и т.д. при этом получаются тоже целые числа. Все многообразие мира описывается через эти переменные и типы которыми задаются свойства всех объектов мира.
Например дерево имеет столько то веток, оно столько то весит, оно имеет коричневый ствол и зеленую листву с рисунком из жилок. Дерево растет со скоростью плавающей точки и потребляет кислород и вырабатывает его же. Весь образ дерева хранится в памяти программиста и он вписывает программу о дереве в отдельные файлы.
В языке Си++ можно создать класс Деревья (как тип переменной) объект Дерево (как саму переменную), описать все операции которые можно выполнять с деревом (как сложение вычитание и т.д.) Описать события, которые случаются с деревом (посадили, выросло до 3 метров, спилили, сожгли), описать свойства дерева (рост, вес, цвет и т.д.) Таким образом существует новый подход к описанию мира и созданию образов в программировании, более близкий к тому как думает человек, дающий новые возможности и удобства.
В языке Си++ есть еще одна возможность - “наследование”. Чтобы создать новый образ “березы” мне не надо заново описывать все что присуще березам, мне достаточно сказать компилятору, что березы это наследник деревьев и все что присуще деревьям присуще березам, но есть новые свойства, методы и события которые присущи только березам.
Программы, написанные на Си++ и использующие классы имеют несколько другой облик. Они как набор подпрограмм которые выполняются при наступлении событий всех объектов, описанных в программе. Например есть лес, состоящий из уникальных деревьев-объектов. Вот как выглядит программа на Си++
- Тишина, лес погружен в дремоту.
- Ветерок пробежался по листве и где то падают листья.
- Дятел прилетел и раздолбал дупло.
- Старое сгнившее дерево упало и придавило 3 куста
Объектно ориентированное программирование - это как бы сборник обработчиков всех возможных событий. А внутри этих событий выполняются методы/операции над объектами и их свойствами (создаются, уничтожаются, перекрашиваются, увеличиваются и уменьшаются). Чтобы все это многообразие однозначно описать для компилятора, понадобилось некоторое количество служебных слов и знаков типа “->”, “::” и т.д.
А теперь о грустном:
Это конечно все хорошо, но не годится для маленького проца. А все эти возможности можно реализовать и в простом Си, но с несколько более тяжелой грамматикой и орфографией. Нам придется отказаться от классов из экономии, хотя как бы легко было программировать на Си++ например ЖКИ:
LCD->Restart();
LCD->SetLine(3);
LCD->Print(“Welcome!”);
LCD->Clear();
LCD->LoadSymbol(0x04, 14, 45, 44, 1, 3, 6, 7, 1);
В данном примере к объекту LCD применяются методы, а в результате программа посылает на LCD различные данные.
Но это все прекрасно работает на большом компе на его Си++.
Больше про классы пока говорить не буду.
Сконцентрируемся например на ЖКИ и на использовании прерываний.
Иметь аппарат для удобной работы с ЖКИ это полдела при написании программы для ЗУ.
Еще несколько слов про Си++. Есть такой Си - микрософт Си++. После борланда он мне показался нелогичным, запутанным вобщем наверное я применил мало усилий чтобы разобраться. Так вот весь виндоус написан на этом Си++ и именно с применением классов. Все окна, все поля ввода, все диски, принтеры все устройства и драйвера и вообще все в виндоусе это классы. И у всех классов есть методы, свойства и события. Все эти объекты в виндоусе перевязаны между собой сообщениями. Сама операционная система это огромный генератор сообщений, все что вы ни делаете с клавиаторой мышкой и дисками и сетками, все это порождает тысячи сообщений от операционной системы всем открытым окнам и самому верхнему окну-программе. Сообщения принимаются окном и обрабатываются. Сообщение - это событие для окна. Система сообщила окну, что драйвер клавиатуры получил код нажатой кнопки. Окно вызвало обработчик события “кнопка нажата” и послала сообщение строке ввода там где сейчас моргает курсор, а строка приняла сообщение и послала сообщение драйверу видюхи отображай текст по адресу. Попутно все это было залогировано, попутно антивирус проверил нет ли вируса внутри кода кнопки (это конечно шутка, но если бы это был диск или сетка то это так).
Все очень просто, но мне все больше в последнее время кажется, что это все суета.
ИМХО методологически неправильно объяснять про классы (даже вскользь), не разобравшись и даже не упомянув структуры. А ведь классы это всего лишь логическое развитие идеи структурирования, просто инкапсулировать туда еще и функции…
Идеологию ООП вполне можно применять и в простом C, достаточно написать функции (методы), для которых в одном из параметров передавать указатель на структуру, описывающую объект.
Так же неплохо дать представление о асме, и пару простейших примеров как конструкции C выглядят на асме. Для контроллера это представление мягко говоря будет не лишним…
А вообще все-таки здорово у Вас получается!
но мне все больше в последнее время кажется, что это все суета.
Увы… как и вся наша жизнь…
Я просто хотел дать общий взгляд с высоты птичьего полета, так сказать перевязать знания о программировании, хотя и примитивном, с общими тенденциями и сложнейшими мировыми программами. Я помню как обычно дается язык Си в книжках в строгом изложении. Читаешь, читаешь, читаешь. Инфа горами скапливается в голове, связей нет или мало, начинаешь писать, много непоняток, опытов. Через несколько лет программирования со многими ошибками и глюками вдруг прояснение и виденье общей картины. Вот попытался дать картину.
Связь между мировыми тенденциями и тем что уже описано есть - она проста. И каждому человеку все по силам. Каждый человек знает как добраться в любую точку земли, зная про материки и моря. А потом нырнуть в глубоко частную задачу из которой мы вероятно уже не вынырнем, затерявшись в деталях.
Что касается суеты это я просто вечером писал и на меня напал грех уныния. Неээ, думаю (хотя наверняка доказать не могу) смысл есть и он вне жизни и вне материи возможно. Каков смысл жизни Эйнштейна? Для нас очень даже большой: его идеи и его работа. Какой смысл, какая материальная выгода, для самого Эйнштейна никакой, все равно он умер. Если б не было Эйнштейна, что другой человек бы не добрался до этой мысли? Добрался бы рано или поздно. Значит смысл жизни Эйнштейна и не в том что он сделал, придумал раз это мог сделать другой. То что Эйнштейн сделал для своего тела ради выгоды - не известно и забыто, а то что делал для всех помнится. Где то здесь спрятан ответ. А еслиб он был вторым, что смысл потерян? Думаю нет. Смысл все время ускользает на следующий уровень за пределы жизни в материи. Может все таки есть еще вселенные: вселенная информации/мысли, вселенная непреклонной воли, вселенная доброты. Может быть что то есть внутри нашего тела или в пятом измерении нашего тела, может ради него и существует тело.
Если так думать, то смысл есть и это не только смысл но и силы жить и оставаться человеком добрым, отзывчивым, сострадающим, любящим, не помешанным на вещах и удовольствиях и жертвующим ради них всем остальным. Как приятны открытые, чистые, душевные люди, которым ничего не надо, но если они попросят, то помочь не жалко и которые неподдельно могут позаботиться о нас. Что в этом притягательного? Почему мне трудно стать таким человеком? Почему приходится делать выбор в пользу выгоды для своих, отказываясь от роли доброго. А может выгода и мое личное здоровье и безопасность это вторично. Мать бросается спасать ребенка в горящий дом почему? Почему не думает о себе? Что ее движет? Какая главная сила? Эйнштейн зачем сидел дома и писал формулы? Ради славы? Ради денег? У нас есть примеры по телику кто живет ради славы, ради денег и ради власти. С такими людьми приятно дружить? Почему Эйнштейн не поехал на Канары, а продолжил копаться в формулах? Может им двигала сила та же, что движет матерью. Может эта сила, та которой делаются все хорошие дела на земле.
Вывод: Смысл есть, смысл сложный (нам его не понять из понятий выгоды) и простой (все могут его искать). Жить надо. И стараться улучшать себя. Выследить, разобраться, сменить курс, приложить усилие и выплывать упорно в нужном направлении. Легко не будет, но помощь точно придет, а главное какая то наша часть вечная и нас ждет бесконечно много интересного и бесконечный рост.
А те люди, которые смертны - спешите жить, не болейте и по больше копите и берегите себя и обороняйтесь лучше. Побольше получайте удовольствий, а то скоро старость. Это я позлорадствовал. Извините. Просто такую форму выбрал чтоб показать …
Нет не так! Наоборот откройтесь, отдавайте, работайте ради всех и всех любите даже врагов. Все что нужно для жизни приложится само, как у Эйнштейна. На всем человечестве лежит общая задача. “Бог не играет в кости”. Где то здесь смысл, но точно не знаю.
Опять же увы… Но для меня пока ничего не опровергает, что человек всего лишь биологический робот, работающий по весьма сложной программе, но имеющую простейшую конечную цель- выживание вида. Иногда эта программа заходит в досточно причудливые ветки, как-то моделизм, создание ЗУ итп, но только на беглый взгляд это не относится впрямую к той-же конечной цели. И в этом (конечной цели) человек ничем не отличается от любой другой твари (не в отрицательном смысли) или какой-нибудь плесени (не в отрицательном смысли)…
Много тыщ. (миллионов?) лет назад оказалось, что для успешного выживания возможно два пути- деструктивный/конструктивный. Вы активно пропагандируете второй вариант, который мне тоже ближе и кажется более перспективным. Хотя природа требует равновесия и белое без черного, увы, не бывает, законы развития требуют.
Мир на столько реален, а наш образ мыслей настолько впечатан в нашу нейронную сеть, сформированную социальными установками и “научными верованиями” взглядами, что ГИПЕР тяжко оторваться от “своего” био-восприятия, самоосознавания и самозаблуждения что я это я и я умный и я все делаю правильно.
Простейший, небольшой пост сразу показывает кто хозяин в моем теле. Я и мое тело настолько притерлись что считаем себя одним лицом. Но как только тело заболело, все становится ясно, что я полностью зависим. Простая зубная боль и вся деятельность парализована.
А теперь идем дальше. А что касаемо моих мыслей? А может и там есть я и не я. Я, осознающий правильный путь, и я, подверженный полной зависимости от удовольствий и сделавший их смыслом жизни. Даже сама мысль что я откажусь от какого то конкретного удовольствия парализует меня и кричит НЕТ. Вот он сигнал, что я в полной зависимости в рабстве от этого удовольствия. Я не могу отвернуться от него. Я в ловушке в своем теле и в своем разуме. Я должен выплывать и освобождаться от рабства. Когда я сыт, я не чувствую рабство. Я могу вещать о своей свободе и напрочь не видеть всей тяжести положения.
Тот кто не чувствует своего желудка, утверждает, что желудка нет. Тот кто не чувствует своего рабства и шаткости положения, тот находится в полной зависимости и действует как робот и обманывает себя, скрывая страшную правду от себя. Западный, технологический путь развития - путь потворства своим слабостям - закоболяет человека до крайнейшей зависимости, несмотря на правовое общество и провозглашенные “свободы”.
Телевизор и дебильник(плайер с музыкой дунц-дунц) вырубает мозги людей, настраивает на псевдозанятость, чтобы фривольно не думали не беспокоили себя страшными вопросами не думали о смерти не думали смысле жизни, а больше развлекались, увеличивали оборот средств и больше работали на работе, поработал - отдохнул развлекся, чтоб приходили и падали и спали на следующий день опять.
Восточный путь - путь исследования себя, само исцеления и подлинного освобождения. Россия - где то посередине.
Не пугайтесь Выход есть.