Работа с Arduino из C# приложения
В этой статье я хотел бы рассказать о том, как можно считывать данные и управлять платой Arduino, подключенной через USB порт, из .Net приложения и из приложения UWP. Делать это можно без использования сторонних библиотек. Фактически, используя только виртуальный COM порт. Давайте сначала напишем скетч для Arduino.
Мы будем отправлять на порт строку с текстом, содержащим в себе значение переменной, которая у нас будет постоянно изменятся в цикле (таким образом имитируя данные снятые с датчика). Также будем считывать данные с порта и в случае если получим текст «1», то включим встроенный в плату светодиод. Он расположен на 13-ом пине и помечен на плате латинской буквой L.
А если получим «0», то выключим его.int i = 0; // переменная для счетчика имитирующего показания датчика
int led = 13; void setup() { Serial.
begin(9600); // установим скорость обмена данными pinMode(led, OUTPUT); // и режим работы 13-ого цифрового пина в качестве выхода
}
void loop() { i = i + 1; // чтобы мы смогли заметить что данные изменились String stringOne = “Info from Arduino “; stringOne += i; // конкатенация Serial.println(stringOne); // отправляем строку на порт char incomingChar; if (Serial.
available() > 0) { // считываем полученное с порта значение в переменную incomingChar = Serial.read(); // в зависимости от значения переменной включаем или выключаем LED switch (incomingChar) { case '1': digitalWrite(led, HIGH); break; case '0': digitalWrite(led, LOW); break; } } delay(300);
}
WPF приложение
Теперь создадим WPF приложение. Разметку сделаем довольно простой. 2 кнопки и метка для отображения текста полученного с порта это все что необходимо: Нет данных Послать 1 Послать 0
Добавим 2 пространства имен:using System.Timers;
using System.IO.Ports;
И в области видимости класса 2 переменные с делегатом:System.Timers.
Timer aTimer;
SerialPort currentPort;
private delegate void updateDelegate(string txt);
Реализуем событие Window_Loaded. В нем мы пройдемся по всем доступным портам, прослушаем их и проверим не выводится ли портом сообщение с текстом «Info from Arduino». Если найдем порт отправляющий такое сообщение, то значит нашли порт Arduino.
В таком случае можно установить его параметры, открыть порт и запустить таймер. bool ArduinoPortFound = false; try { string[] ports = SerialPort.
GetPortNames(); foreach (string port in ports) { currentPort = new SerialPort(port, 9600); if (ArduinoDetected()) { ArduinoPortFound = true; break; } else { ArduinoPortFound = false; } } } catch { } if (ArduinoPortFound == false) return; System.Threading.Thread.Sleep(500); // немного подождем currentPort.BaudRate = 9600; currentPort.DtrEnable = true; currentPort.
ReadTimeout= 1000; try { currentPort.Open(); } catch { } aTimer = new System.Timers.Timer(1000); aTimer.Elapsed += OnTimedEvent; aTimer.AutoReset = true; aTimer.Enabled = true;
Для снятия данных с порта и сравнения их с искомыми я использовал функцию ArduinoDetected: private bool ArduinoDetected() { try { currentPort.Open(); System.Threading.Thread.
Sleep(1000); // небольшая пауза, ведь SerialPort не терпит суеты string returnMessage = currentPort.ReadLine(); currentPort.Close(); // необходимо чтобы void loop() в скетче содержал код Serial.println(“Info from Arduino”); if (returnMessage.
Contains(“Info from Arduino”)) { return true; } else { return false; } } catch (Exception e) { return false; } }
Теперь осталось реализовать обработку события таймера. Метод OnTimedEvent можно сгенерировать средствами Intellisense. Его содержимое будет таким: private void OnTimedEvent(object sender, ElapsedEventArgs e) { if (!currentPort.
IsOpen) return; try // так как после закрытия окна таймер еще может выполнится или предел ожидания может быть превышен { // удалим накопившееся в буфере currentPort.DiscardInBuffer(); // считаем последнее значение string strFromPort = currentPort.ReadLine(); lblPortData.Dispatcher.
BeginInvoke(new updateDelegate(updateTextBox), strFromPort); } catch { } } private void updateTextBox(string txt) { lblPortData.Content = txt; }
Мы считываем значение с порта и выводим его в виде текста метки. Но так как таймер у нас работает в потоке отличном от потока UI, то нам необходимо использовать Dispatcher.BeginInvoke.
Вот здесь нам и пригодился объявленный в начале кода делегат. После окончания работы с портом очень желательно его закрыть. Но так как мы работаем с ним постоянно, пока приложение открыто, то закрыть его логично при закрытии приложения. Добавим в наше окно обработку события Closing: private void Window_Closing(object sender, EventArgs e) { aTimer.Enabled = false; currentPort.
Close(); }
Готово. Теперь осталось сделать отправку на порт сообщения с текстом «1» или «0», в зависимости от нажатия кнопки и можно тестировать работу приложения. Это просто: private void btnOne_Click(object sender, RoutedEventArgs e) { if (!currentPort.IsOpen) return; currentPort.Write(“1”); } private void btnZero_Click(object sender, RoutedEventArgs e) { if (!currentPort.IsOpen) return; currentPort.Write(“0”); }
Получившийся пример доступен на GitHub. Кстати, WinForms приложение создается еще быстрее и проще. Достаточно перетянуть на форму из панели инструментов элемент SerialPort (при наличии желания можно перетянуть из панели инструментов и элемент Timer). После чего в нужном месте кода, можно открыть порт, считывать из него данные и писать в него примерно как и в WPF приложении.
UWP приложение
Для того чтобы разобраться с тем как работать с последовательным портом я рассмотрел следующий пример: SerialSample Для разрешения работы с COM портом в манифесте приложения должно быть такое вот объявление:
В коде C# нам понадобятся 4 пространства имен:using Windows.Devices.SerialCommunication;
using Windows.Devices.Enumeration;
using Windows.Storage.
Streams;
using System.Threading.Tasks;
И одна переменная в области видимости класса: string deviceId;
При загрузке считаем в нее значение id порта к которому подключена плата Arduino: private async void Page_Loaded(object sender, RoutedEventArgs e) { string filt = SerialDevice.GetDeviceSelector(“COM3”); DeviceInformationCollection devices = await DeviceInformation.
FindAllAsync(filt); if (devices.Any()) { deviceId = devices.First().Id; } }
Следующий Task считает 64 байта с порта и отобразит текст в поле с именем txtPortDataprivate async Task Listen() { using (SerialDevice serialPort = await SerialDevice.FromIdAsync(deviceId)) { if (serialPort != null) { serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000); serialPort.
BaudRate = 9600; serialPort.Parity = SerialParity.None; serialPort.StopBits = SerialStopBitCount.One; serialPort.DataBits = 8; serialPort.Handshake = SerialHandshake.None; try { using (DataReader dataReaderObject = new DataReader(serialPort.InputStream)) { Task loadAsyncTask; uint ReadBufferLength = 64; dataReaderObject.InputStreamOptions = InputStreamOptions.
Partial; loadAsyncTask = dataReaderObject.LoadAsync(ReadBufferLength).AsTask(); UInt32 bytesRead = await loadAsyncTask; if (bytesRead > 0) { txtPortData.Text = dataReaderObject.ReadString(bytesRead); txtStatus.Text = “Read operation completed”; } } } catch (Exception ex) { txtStatus.Text = ex.Message; } } } }
В UWP приложениях на C# отсутствует метод SerialPort.DiscardInBuffer.
Поэтому один из вариантов, это считывать данные открывая каждый раз порт заново, что и было продемонстрировано в данном случае. Если вы попробуете, то сможете заметить, что отсчет каждый раз идет с единицы. Примерно то же самое происходит и в Arduino IDE при открытии Serial Monitor. Вариант, конечно, так себе.
Открывать каждый раз порт это не дело, но если данные необходимо считывать редко, то этот способ сойдет. Кроме того, таким образом записанный пример выглядит короче и понятнее.
Рекомендуемый вариант это не объявлять каждый раз порт заново, а объявить его один раз, например, при загрузке.
Но в таком случае необходимо будет регулярно считывать данные с порта, чтобы он не заполнялся старьем и данные оказывались актуальными. Смотрите как это сделано в моем примере UWP приложения. Я так полагаю, что концепт отсутствия возможности очистить буфер состоит в том, что постоянно асинхронно снимаемые данные, не особо нагружают систему.
Как только необходимое количество байт считывается в буфер, выполняется следом написанный код. Есть плюс, в том, что при таком постоянном мониторинге ничего не пропустишь, но некоторым (и мне в том числе) не хватает привычной возможности один раз «считнуть» данные.
Для записи данных в порт можно использовать схожий код: private async Task sendToPort(string sometext) { using (SerialDevice serialPort = await SerialDevice.FromIdAsync(deviceId)) { Task.Delay(1000).Wait(); if ((serialPort != null) && (sometext.Length != 0)) { serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000); serialPort.ReadTimeout = TimeSpan.
FromMilliseconds(1000); serialPort.BaudRate = 9600; serialPort.Parity = SerialParity.None; serialPort.StopBits = SerialStopBitCount.One; serialPort.DataBits = 8; serialPort.Handshake = SerialHandshake.None; Task.Delay(1000).Wait(); try { using (DataWriter dataWriteObject = new DataWriter(serialPort.OutputStream)) { Task storeAsyncTask; dataWriteObject.
WriteString(sometext); storeAsyncTask = dataWriteObject.StoreAsync().AsTask(); UInt32 bytesWritten = await storeAsyncTask; if (bytesWritten > 0) { txtStatus.Text = bytesWritten + ” bytes written”; } } } catch (Exception ex) { txtStatus.Text = ex.
Message; } } } }
Вы можете заметить, что после инициализации порта и установки параметров добавлены паузы по 1 секунде. Без этих пауз заставить Arduino среагировать не получилось. Похоже, что serial port действительно не терпит суеты. Опять же, напоминаю, что лучше открыть порт один раз, а не открывать/закрывать его постоянно.
В таком случае никакие паузы не нужны.
Упрощенный вариант UWP приложения, который аналогичен рассмотренному выше WPF .Net приложению доступен на GitHub
В результате я пришел к выводу, что работа в UWP с Arduino напрямую через виртуальный COM порт хоть и непривычна, но вполне возможна и без подключения сторонних библиотек.
Источник: https://habr.com/post/275439/
Структурное программирование
Хотя C# создавался строго в парадигме ООП, рассмотренные выше операторы языка позволяют реализовать и структурное программирование.
Напомним, что его становление и развитие связано с именем Эдсгера Дейкстры, который опубликовал своё знаменитое письмо «Оператор Go To считается вредным» (1968 год). Это поистине исторический документ, оказавший заметное влияние на дальнейшее развитие программирования.
Вам необходимо освоить технологию структурного программирования для написания «правильных» подпрограмм (структурных единиц ваших программ).
Принципы структурного программирования:
Принцип 1. Следует отказаться от использования оператора безусловного перехода goto.
Принцип 2. Любая программа строится из трёх базовых управляющих конструкций: последовательность, ветвление, цикл.
Последовательность — однократное выполнение операций в том порядке, в котором они записаны в тексте программы.
Ветвление — однократное выполнение одной из двух или более операций, в зависимости от выполнения заданного условия.
Цикл — многократное исполнение одной и той же операции до тех пор, пока выполняется заданное условие (условие продолжения цикла).
Принцип 3. В программе базовые управляющие конструкции могут быть вложены друг в друга произвольным образом. Никаких других средств управления последовательностью выполнения операций не предусматривается.
Принцип 4. Повторяющиеся фрагменты программы можно оформить в виде подпрограмм (процедур и функций). Таким же образом (в виде подпрограмм) можно оформить логически целостные фрагменты программы, даже если они не повторяются.
В этом случае в тексте основной программы, вместо помещённого в подпрограмму фрагмента, вставляется инструкция «Вызов подпрограммы». При выполнении такой инструкции работает вызванная подпрограмма.
После этого продолжается исполнение основной программы, начиная с инструкции, следующей за командой «Вызов подпрограммы».
Принцип 5. Каждую логически законченную группу инструкций следует оформить как блок. Блоки являются основой структурного программирования. Блок — это логически сгруппированная часть исходного кода, например, набор инструкций, записанных подряд в исходном коде программы.
Понятие блок означает, что к блоку инструкций следует обращаться как к единой инструкции. Блоки служат для ограничения области видимости переменных и функций. Блоки могут быть пустыми или вложенными один в другой. Границы блока строго определены. Например, в операторе if блок ограничен кодом BEGIN..
END (в языке Паскаль) или фигурными скобками {…} (в языках C, С++, C#).
Принцип 6. Все перечисленные конструкции должны иметь один вход и один выход.
Произвольные управляющие конструкции (такие, как в блюде спагетти) могут иметь произвольное число входов и выходов.
Ограничив себя управляющими конструкциями с одним входом и одним выходом, мы получаем возможность построения произвольных алгоритмов любой сложности с помощью простых и надежных механизмов.
Принцип 7. Разработка программы ведётся пошагово, методом «сверху вниз».
Конец цитаты.
Примечание (терминологическое) к Принципу 4. «Подпрограммам» в разных языках соответствуют разные названия:
В Паскале это procedure и function, в Бейсике – subroutine и function, в С и С++ — только функции. В C# используется термин «функция-член». Напомним, что основной единицей инкапсуляции в C# является класс, который определяет форму объекта.
Он описывает данные, а также код, который будет ими оперировать. В C# описание класса служит для построения объектов, которые являются экземплярами класса. Код и данные, составляющие вместе класс, называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра.
А код, оперирующий данными, содержится в функциях-членах, самым типичным представителем которых является метод. В C# метод служит в качестве аналога подпрограммы (к числу других функций-членов относятся свойства, события и конструкторы).
Таким образом, методы класса содержат код, воздействующий на поля, определяемые этим классом.
Следует отметить, что в C# метод, как функция-член обязательно относится к какому-либо классу. При попытке объявить метод вне класса, в пространстве имен, диагностируется ошибка:
«Пространство имен не может непосредственно содержать такие члены, как поля или методы».
Даже в стандартном консольном приложении объявляется один класс Program и один метод static void Main(string[] args) этого класса, имеется одна точка входа и одна точка выхода. Другие методы, объявленные в этом классе, могут вызываться как подпрограммы как прямо, так и опосредованно из Main().
Можно считать, что консольное приложение, в котором учитываются 7 указанных выше принципов (не использовать goto, применять только три управляющие структуры и т.д.), вполне соответствует идеологии структурного программирования.
В Windows-приложении в целом, как уже отмечалось, принцип «один вход — один выход» не применим (какие-либо действия являются реакцией на некоторые события), однако реализация каждого метода должна соответствовать принципам структурного программирования.
ЗАКЛЮЧЕНИЕ
Итак, мы рассмотрели синтаксис операторов языка C# с небольшими примерами. Каждый из них вы должны проверить в консольном приложении и, изменяя что-либо, поэкспериментировать.
Теперь нам надо закрепить изученный материал раздела «Основы языка С#».
Для этого вы можете изучить примеры решения задач и написать программы, реализующие задания для самостоятельной работы в следующем части курса «Основы языка C#. Задачи«.
Источник: http://C-sharp.pro/?p=644
Управление светодиодами при помощи программы на C# и Arduino
Вам никогда не хотелось управлять СИД, подключенными к Arduino, с помощью программы, которую вы же и написали? Так вот, я здесь, чтобы помочь вам с этим. Это моя первая статья, так что, прошу подсказать, если я что-то напутал. Ну и можете спокойно изменять мой код под свои нужды.
Нам потребуется:
- Плата Arduino
- Макетная плата
- Провода папа-папа
Шаг 1
Откройте Microsoft Visual Studio 2010 или Microsoft Visual Studio С# 2010 и создайте новый C# проект. Назовите его произвольным именем/названием. После этого нажмите ОК
Шаг 2
Для этого примера я сделаю две простеньких кнопки, чтобы управлять включением и выключением СИД, подключенного на 13 пин. Для начала откройте «Панель элементов» и перетащите элемент «кнопка» на рабочую область. Повторите. Добавьте две панели и измените их размеры, должно получиться приблизительно как на рисунке.
Так же добавьте последовательный порт из той же «Панели элементов»
Шаг 3. Переименуем кнопки
Вы можете переименовать свои кнопки или оставить как есть. Я оставил как есть, но изменил текст на них. Чтобы сделать это, нажимаете на кнопку, затем в правой части окна, в окне «Свойства», в строке «Текст» изменяете текст. На скриншоте можно увидеть это поле. В локализованных версиях название может отличаться. Убедитесь, что изменяете именно ту кнопку.
Шаг 4. Добавляем код
Дважды нажмите на кнопку «On». У вас должно будет появиться окно похожее на то, что на скриншоте. Теперь, в блоке для кода вставьте следующее:
serialPort1.Open();
if (serialPort1.IsOpen)
{
serialPort1.WriteLine(“A”);
}
serialPort1.Close();
panel1.BackColor = Color.Lime;
panel2.BackColor = Color.Transparent;
Поднимитесь выше по коду до:
public Form1()
{
}
Ивставьтеследующее
InitializeComponent();
serialPort1.PortName = ” “;
serialPort1.BaudRate = 9600;
междускобками.
Параметры для PortName мы добавим позже.
Теперь вернемся в «Конструктор», выделим кнопку «Off» и добавим следующий код:
serialPort1.Open();
if (serialPort1.IsOpen)
{
serialPort1.WriteLine(“a”);
}
serialPort1.Close();
panel2.BackColor = Color.Red;
panel1.BackColor = Color.Transparent;
Шаг 5. Код для Arduino
Так, хорошо, для того, чтобы написать код под Arduino, нам необходимо получать сообщения через последовательный порт. И есть только один путь осуществления этого, который я знаю. Извините, если есть и другие варианты – я только начинаю работать с Arduino.
int message = 0; // Резерв одного байта для сообщений через последовательный порт
int LEDPin = 13; // Пин, к которому подключен СИД
int LED = 0; // Параметр значения яркости СИД, может принимать значения 0-255
void setup() {
Serial.begin(9600); //открытие последовательного порта со скоростью передачи данных 9600 бит/с
}
void loop(){
if (Serial.available() > 0) { // Проверка, нет ли новых сообщений
message = Serial.read(); // Послатьсообщениенапоследовательныйпорт Put the serial input into the message
if (message == 'A'){ // Если буква «А» получена в верхнем регистре
LED = 255; // Установить яркость СИД 255 (включить его)
Serial.println(“LED on”); // Отправить «LED on»
}
if (message == 'a'){ // Если буква «А» получена в нижнем регистре
LED = 0; // Установить яркость СИД 0 (выключить его)
Serial.println(“LED off”); // Отправить «LED off»
}
}
}
Шаг 6. Установка
Для начала вам нужно взять СИД и подключить его к Arduino, как показано на фото. Убедитесь, что анод (+) подключен к 13 пину, а катод (-) к земле.
Затем откройте Arduino IDE и вставьте код из вложения ниже. Затем в меню выберите «Инструменты». В разделе «Плата» убедитесь, что выбрана та, которую вы используете. У меня это – Dueminelove. В разделе «Порт» убедитесь, что выбран верный порт. У меня это – COM4.
Простите, за плохое качество фотографий, но делал я их на телефон. Фотоаппарат сломался этим утром.
Шаг 7. Добавляем последовательный порт в программу C#
Вернитесь к C# проекту и найдите там строку
serialPort1.PortName = ” “;
и в пустое место между кавычками вставьте номер последовательного порта.
Затем вам нужно вернуться в конструктор и нажать на изображение последовательного порта в левом нижнем углу. В окне свойств измените PortName на то, что вы вписали в код. В моем случае это – СОМ4.
Шаг 8. Тестирование
Загрузите скетч на плату Arduino и проверьте его с помощью монитора последовательного порта. Напечатайте букву «А» в верхнем регистре, чтобы включить СИД, и в нижнем, чтобы выключить.
Вернитесь в C# программу и запустите отладку. Это можно сделать, нажав значок проигрывания на панели меню, или нажав F5. Затем нажмите на кнопку «On». Должен загореться СИД. Нажмите на «Off» – и он потухнет.
Вуаля! Вы создали программу, которая может общаться с Arduino!
Можете добавить еще несколько СИД и даже функционала! Развлекайтесь!
Ниже я прикрепил фото моего контроллера. Было весело!
Я прикрепил код и то, что не было освещено в статье.
Материалы для данной статьи и скриншоты в высоком качестве можно найти тут: https://yadi.sk/d/6LxChdD1kvjpK
Перевод статьи: http://www.instructables.com/id/Controll-Leds-With-an-Arduino-From-a-C-Program/?ALLSTEPS
Лицензия: CC BY-SA-2.5
Источник: https://tpai.ru/blog/perevody-statej/upravlenie-svetodiodami-pri-pomosshi-programmy-na-c-i-arduino
Теоретические основы программирования на C#
Существует огромное количество людей, которые интересуются компьютерными технологиями, их еще можно назвать гиками.
Рано или поздно такому энтузиасту приходит в голову мысль о создании своих собственных прикладных программ, конечно в этом случае речь не идет о новой операционной системе, скорее о простеньком приложении а-ля математический калькулятор.
Многие школьники, которые только начали изучать Visual Basic на уроках информатики, мечтают создать собственную игру и т.п.
Конечно можно начать с логарифмической линейки и пройти весь путь матерого программиста, но можно и почти мгновенно окунуться в мир программирования, естественно, не для практического опыта а для ознакомления с целью вовлечения! Существуют языки программирования традиционно наиболее подходящие для обучения, но в процессе освоения обучающихся отпугивает большой, непонятный исходный код примеров программ, сложности с настройкой инструментария, непривычные среды исполнения программы, такие как запуск в интерпретаторе команд. Исходя из этих соображений многие педагоги рекомендуют делать первые шаги с современным и активно развивающимся языком C# или C Sharp, который базируется на программной платформе .NET Framework.
В этой статье я коротко изложу теорию предназначения и работы с языком C Sharp, а так же суть работы с программой для создания проектов на различных языках программирования — Visual Studio. Вы спросите, почему именно Visual Studio, потому что это наиболее оптимальная программа для создания подобных проектов.
Надо сказать, что программировать на всех представленных в VS языках можно и в других средах или редакторах, но в качестве IDE для C# программирования явных конкурентов у VS пока не существует или они находятся на «незрелой» стадии развития.
Благодаря Visual Studio мы без всяких затруднений можем создать любой интерфейс программы (GUI или UI), любые параметры обработки информации. В этой статье также будет приведен пример работы в этой IDE.
А в моих следующих статьях я помогу вам создать свои первые программы — такие как калькулятор, простые игры и многое другое. Но для начала давайте рассмотрим возможности Visual Studio.
Возможности Visual Studio
Приступив к изучению C# мы получаем целую связку готовых для работы решений, многие из них предоставляются бесплатно, например, одна из современных версий Visual Studio. Благодаря простому интерфейсу программы, с ней не тяжело разобраться.
С помощью VS мы можем создавать программы на таких известных языках программирования как: C, C++, C#, Visual Basic и т.д.
На всех этих языках в VS мы можем создать любое приложение, любого формата — консольное приложение, обычную Windows форму, приложение для Windows Phone смартфона, библиотеку классов и тому подобные приложения.
Студия очень удобна тем, что там не нужно прописывать абсолютно все коды элементов в ручном режиме (как в простом текстовом редакторе), в среде уже готовы все коды элементов управления (кнопки, чек-боксы, текстовые окна и тому подобные элементы). Что же из себя представляет C# (произносится как си шарп) непосредственно как язык?
- C# — является наследственным сыном двух мощных языков — C++ и Java,
- C# — очень удобен в использовании (написании программ), у него достаточно простой синтаксис и мощные сигнатуры, благодаря которым мы можем создать базы данных не хуже чем SQL или LINQ,
- C# — сейчас очень распространен и является одним из самых оптимальных языков программирования.
История появления C#
История си шарп — является недавней. Язык появился на свет в июне 2000 г. в результате кропотливой работы большой группы разработчиков компании Microsoft, возглавляемой Андерсом Хейлсбергом (Anders Hejlsberg). Этот человек известен как автор одного из первых компилируемых языков программирования для персональных компьютеров IBM — Turbo Pascal.
Наверное, на территории бывшего Советского Союза многие разработчики со стажем, да и просто люди, обучавшиеся в той или иной форме программированию в вузах, испытали на себе очарование и удобство использования этого продукта.
Кроме того, во время работы в корпорации Borland Андерс Хейлсберг прославился созданием интегрированной среды Delphi (он руководил этим проектом вплоть до выхода версии 4.0).
Появление языка си шарп и инициативы .NET отнюдь не случайно пришлось на начало лета 2000 г. Именно к этому моменту компания Microsoft подготовила промышленные версии новых компонентных технологий и решений в области обмена сообщениями и данными, а также создания Интернет-приложений (COM+, ASP+, ADO+, SOAP, Biztalk Framework).
Несомненно, лучшим способом продвижения этих новинок является создание инструментария для разработчиков с их полноценной поддержкой. В этом и заключается одна из главных задач нового языка.
Кроме того Microsoft не могла больше расширять одни и те же инструменты и языки разработки, делая их все более и более сложными для удовлетворения конфликтующих между собой требований поддержки современного оборудования и обеспечения обратной совместимости с теми продуктами, которые были созданы в начале 1990-х гг. во время первого появления Windows.
Наступает момент, когда необходимо начать с чистого листа для того, чтобы создать простой, но имеющий сложную структуру набор языков, сред и средств разработки, которые позволят разработчику легко создавать современные программные продукты.
С# и .NET являются той самой отправной точкой. Если говорить упрощенно, то .NET представляет собой новую платформу, новый API для программирования в Windows, а С# ее новый язык, созданный с нуля, для работы с этой платформой, а также для извлечения всех выгод из прогресса сред разработки и нашего понимания принципов объектно-ориентированного программирования в течение последних 20 лет.
Необходимо отметить, что обратная совместимость не потеряна. Существующие программы будут выполняться, а платформа .NET была спроектирована таким образом, чтобы она могла работать с имеющимся программным обеспечением.
Связь между компонентами в Windows сейчас почти целиком осуществляется при помощи СОМ. С учетом этого .NET обладает способностью создавать оболочки (wrappers) вокруг существующих компонентов СОМ, так что компоненты .
NET могут общаться с ними, и создавать оболочки вокруг компонентов .NET, что позволяет им выглядеть как обычные СОМ-компоненты.
Авторы C# стремились создать язык, сочетающий простоту и выразительность современных объектно-ориентированных языков (вроде Java) c богатством возможностей и мощью C++. По словам Андерса Хейлсберга, C# позаимствовал большинство своих синтаксических конструкций из C++.
В частности, в нем присутствуют такие удобные типы данных, как структуры и перечисления (другой потомок C++ — Java лишен этих элементов, что создает определенные неудобства при программировании). Синтаксические конструкции С# унаследованы не только от C++, но и от Visual Basic.
Например, в С#, как и в Visual Basic, используются свойства классов. Как и C++ позволяет производить перегрузку операторов для созданных вами типов, Java не поддерживает ни ту, ни другую возможность.
С# — это фактически гибрид разных языков, при этом синтаксически не менее (если не более) чист чем Java, так же прост как Visual Basic, и обладает практически той же мощью и гибкостью, что и C++.
Особенности С#
Одной из областей, для которых не предназначен этот язык, являются критичные по времени и высокопроизводительные программы, когда имеет значение, занимать исполнение цикла 1000 или 1050 машинных циклов, и освобождать ресурсы требуется немедленно.
C++ остается в этой области наилучшим из языков низкого уровня.
В С# отсутствуют некоторые ключевые моменты, необходимые для создания высокопроизводительных приложений, в частности подставляемые функции и деструкторы, выполнение которых гарантируется в определенных точках кода.
- Полный и хорошо определенный набор основных типов.
- Встроенная поддержка автоматической генерации XML-документации.
- Автоматическое освобождение динамически распределенной памяти.
- Возможность отметки классов и методов атрибутами, определяемыми пользователем. Это может быть полезно при документировании и способно воздействовать на процесс компиляции (например, можно пометить методы, которые должны компилироваться только в отладочном режиме).
- Полный доступ к библиотеке базовых классов .NET, а также легкий доступ к Windows API (если это действительно необходимо).
- Указатели и прямой доступ к памяти, если они необходимы. Однако язык разработан таким образом, что практически во всех случаях можно обойтись и без этого.
- Поддержка свойств и событий в стиле VB.
- Простое изменение ключей компиляции.
- Позволяет получать исполняемые файлы или библиотеки компонентов .NET, которые могут быть вызваны другим кодом так же, как элементы управления ActiveX (компоненты СОМ).
- Возможность использования С# для написания динамических web-страниц ASP.NET
Теоретические основы программирования на C# was last modified: Март 3rd, 2016 by Admin
Источник: http://compuzilla.ru/visual-c-sharp/
Самоучитель по C# для начинающих. 01. Основы языка, переменные, логика, циклы
1.1 Начальные понятия
Данный самоучитель рассчитан на людей, совершенно не знакомых с программированием, но способных скачать, установить и запустить программу – в данном случае Visual Studio 2010 (2008,2012). В первой части я кратко расскажу о основах языка C#.
Формат самоучителя подразумевает краткое и упрощенное изложение – за подробностями касательно отдельных функций и классов обращайтесь в гугл и msdn, за продвинутыми методиками программирования в продвинутые книги.
В принципе почти всю информацию можно найти в интернете, надо лишь знать что искать, так что в отличие от классических книг на несколько сотен страниц я буду давать ту основу, зная которую вы уже сможете сформулировать поисковый запрос – ни в одном разделе я сознательно не даю полной и исчерпывающей информации, ее место в документации.
Крайне желательно знать английский язык хотя бы на уровне чтения со словарем – в англоязычном интернете информации на порядок больше, невероятно полезные сайты вроде StackOverflow не имеют русских аналогов, а русскоязычные форумы и обсуждения чаще всего напоминают знаменитый анекдот (под американским форумом можно смело понимать англоязычный с немцами, индусами и бразильцами):
Современные языки программирования вообще и C# в частности скрывают многие низкоуровневые особенности работы компьютеров, так что детально разбираться в особенностях работы регистров процессора и тому подобной зауми новичку не надо (99% программистов тоже). Но некоторые вещи стоит держать в уме.
Что такое язык программирования? Это язык, который понимает компьютер. (ваш Капитан Очевидность) Но на самом деле компьютер понимает только нули и единицы.
Так что любой современный язык программирования на самом деле промежуточен – после того как вы напишете программу, он переводится на настоящий язык компьютера – компилируется.
Таким образом сначала мы пишем программу на языке программирования в обычном текстовом файле, потом компиллируем в двоичный язык компьютера.
С# в этом плане еще сложней – сначала ваша программа на C# переводится в специальный промежуточный язык – байт-код, после чего уже этот промежуточный язык переводится в двоичный код. Промежуточный язык рассчитан на специальный набор промежуточных программ, которые надо установить на компьютер перед запуском программы на C# – .Net Framework.
Схема работы .Net и C#
Таким образом мы:
1. Пишем код на языке C# в обычный текстовый файл
2. Компилируем программу в байт-код с помощью компилятора C# (1 и 2 можно делать без Visual Studio, например набрать исходный текст в Блокноте и скомпилировать через командную строку)
3. Запускаем полученную программу на компьютере, где уже установлен .Net Framework соответствующей версии), который переводит программу в двоичный код и собственно запускает, давая доступ к компьютеру. (соответственно на компьютере без Net Framework программа не запустится вообще).
1.2 Привет мир
Перейдем к практике, для создания самой простой программы мы запустим Visual Studio и выполним следующее:
1. Пойдем в меню File-New Project (Файл – Новый проект) или сразу кликнем на Create New Project
2. Выберем шаблон Console Application (Консольное приложение)
3. Выберем каталог на диске, где будет расположен наш проект
4. Добавим две строчки в текст программы, чтобы он выглядел вот так
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TestConsoleApplication { class Program { static void Main(string[] args) { System.Console.WriteLine(“Привет мир!”); System.Console.ReadLine(); } } }
4. Нажмем F5 (можно выбрать в меню Debug – Start Debugging ) и увидим черное окошко с нашим Привет мир, которое закроется после нажатия Enter.
Что это и зачем оно надо? В теории это программа без кнопок и меню, которой можно управлять через командную строку.
В наше время такие программы используются редко, в основном очень продвинутыми сисадминами или в мире Linux (что в принципе одно и то же), но знать об их существовании полезно – программисту может довестись с такой работать или даже писать.
Нам она нужна по одной-единственной причине – такая программа меньше всего будет отвлекать от изучения универсальных особенностей языка C#.
В самом простом случае (это про нас) компьютер последовательно выполняет команды программиста – одну за другой:
System.Console.WriteLine(“Привет мир!”); – выводит в консоль (то самое черное окно) строку “Привет мир””
System.Console.ReadLine(); – читает строку, которую мы вводим (ввод завершается нажатием Enter) и переходит к следующей команде.
Так как следующей команды нет, программа завершает работу и закрывает окно.
1.3 Простые переменные
Обычно программы используются для хранения и обработки какой-то информации. Например списока покупателей магазина, сотрудников фирмы или героев и монстров в компьютерной игре. При работе программы все ее данные хранятся в переменных. Переменные и сама программа хранятся в оперативной памяти.
Переменную можно рассматривать как ящик или сумку для данных. Однажды сделав такой ящик мы можем класть в него разные вещи. Само собой на нижнем уровне абсолютно все данные хранятся в виде нулей и единиц, но языки высокого уровня скрывают от нас ненужные сложности.
Под каждый тип данных – строку, число, картинку – нужен ящик соответствующего типа, вы ведь не будете складывать деньги, спички, бензин и котят в одну и ту же коробку. Так что у каждой переменной есть тип, который надо указать при ее создании.
Тип одновременно описывает и размер переменной – сколько данных в нее можно сложить.
Есть языки программирования, в которых переменные не делятся на типы. Что происходит с котятами в таком случае вы узнаете чуть позже, в разделе про обработку ошибок.
Некоторые из простых типов данных в C#
– int, целое число от -2,147,483,648 до 2,147,483,647
– string, строка
– double, число с дробной частью и переменным количеством знаков после запятой, например 1.38 принимает значения от -1,79769313486232 в 308 степени до 1,79769313486232 в 308 степени. Проще говоря очень большие.
– decimal, число с дробной частью и повышенной точностью рассчетов, специально для финансовых операций – в миллионных и более мелких долях float могут накапливаться мелкие ошибки, банки это не любят
– bool – специальный тип для передачи данных об истинности или ложности, принимает только два значения – true или false.
В старых языках вместо него использовали int с значениями 1 и 0, но это было менее наглядно и приводило к ошибкам.
И многие другие типы.
Как уже говорилось выше очень часто программы обрабатывают данные о людях. Попробуем это сделать и мы.
static void Main(string[] args) { string stringToShow1, stringToShow2; string surname = “Шульженко”; string name = “Олег”; string otchestvo = “Васильевич”; int age = 40; double weight = 88.73; stringToShow1 = surname + ” ” + name + ” ” + otchestvo + “, возраст ” + age + “, вес ” + weight; surname = “Чугунов”; name = “Александр”; otchestvo = “Игоревич”; age = 23; weight = 66; stringToShow2 = surname + ” ” + name + ” ” + otchestvo + “, возраст ” + age + “, вес ” + weight; System.Console.WriteLine(stringToShow1); System.Console.WriteLine(stringToShow2); System.Console.ReadLine(); }
Не забудьте запустить по F5 и посмотреть результаты.
Здесь мы объявляем две переменные-строки, оставляем их пока пустыми, объявляем набор переменных с данными о людях, склеиваем из них одну большую строку и заносим в первую переменную-строку, заносим в тот же самый набор переменных другие данные, склеиваем все вместе и заносим в другую строку и только после этого выводим две финальные строки на экран.
Стоит обратить внимание на склеивание нескольких строк в одну с помощью +. Больше информации можно найти здесь, подробное описание всевозможных издевательств над строками – здесь.
1.4 Арифметические операции
Компьютеры почти всегда что-то считают. Собственно само слово computer означает вычислитель. В этой области даже самый слабенький процессор намного превосходит человеческий мозг.
static void Main(string[] args) { int a = 5; int b = 2; System.Console.WriteLine(“a = ” + a + “, b = ” + b); int result = a + b; System.Console.WriteLine(“Сложение, a + b = ” + result); result = a * b; System.Console.WriteLine(“Умножение, a * b = ” + result); result = a / b; System.Console.WriteLine(“Деление, a / b = ” + result + ” a и b – целые числа, деление только нацело”); double resultDouble = a / b; System.Console.WriteLine(“Деление, a / b = ” + resultDouble + ” все равно что-то не так…”); double aDouble = 5; resultDouble = aDouble / b; System.Console.WriteLine(“Деление, a / b = ” + resultDouble); System.Console.ReadLine(); }
Почему произошло столь странное недоразумение с дробным числом во второй раз? Все дело в том, что внутри одной строки мы выполнили сразу несколько операций. А в каком порядке они выполняются? В порядке приоритета. И у оператора присваивания =, который записывает данные в переменную, этот приоритет один из самых низких
Сначала выполнилось деление двух целочисленных переменных a и b и только после этого целый результат деления записался в дробную переменную doubleResult.
Вот здесь можно найти официальный список всех операторов (не только арифметических) языка C#, сгруппированных в порядке убывания приоритета – верхняя группа выполняется первой. Более простую и наглядную табличку легко находит гугл.
Небольшое отступление:
В дальнейших примерах кода подразумевается, что вы самостоятельно вставите их внутрь
static void Main(string[] args) { }
1.5 Управление и логика
На данный момент наша программа не отличается умом – Скайнет из нее не получится, уничтожение человечеству не грозит.
Мы просто выполняем команды по очереди, одну за другой, а хотелось бы принимать решения в зависимости от внешних условий – например “если есть возможность, уничтожить всех людей, иначе работать над созданием такой возможности”.
Делается это с с помощью специальной конструкции если-иначе, или, на родном для C# английском if-else и специальных операторов сравнения:
Компьютерная логика проста – высказывание или результат сравнения может быть либо истиной либо ложью, либо true либо flase, либо уничтожать человечество либо нет. Третьего компьютеру не дано.
Для хранения таких данных существует специальный тип данных – логический – bool – который может принимать только два значения (догадываетесь какие?).
Если вы хотите чего-то посложней и похардкорней – то все вместе это булева алгебра, изучайте и просвещайтесь.
Нам важно понять, что любая операция сравнения, на пример 2 < 4 на самом деле вычисляет логическое значение типа bool, которое может принимать только два значения. И уже им будет руководствоваться компьютер, выполняя нашу программ. bool boolVariable = true; if (boolVariable) { System.Console.WriteLine("boolVariable = true; --- Истина!"); } else { System.Console.
WriteLine(“boolVariable = false; Ложь!”); } System.Console.WriteLine(); boolVariable = false; if (boolVariable) { System.Console.WriteLine(“boolVariable = false; Истина!”); } else { System.Console.WriteLine(“boolVariable = false; Ложь!”); } boolVariable = 2 < 4; if (boolVariable) { System.Console.WriteLine("boolVariable = 2 < 4; Истина!"); } else { System.Console.
WriteLine(“boolVariable = 2 < 4; Ложь!"); } if (10 != 100) { System.Console.WriteLine("10 != 100! Ваш капитан очевидность!"); } System.Console.WriteLine(); System.Console.
ReadLine();<\p>
Сделать поведение программы еще более сложным нам помогут специальные логические операторы, которые сравнивают две логические величины (каждая из которых может быть либо истиной либо ложью)
– логическое И – оператор && – вовращает истину только в том случае, если и справа и слева от него будет истина, во всех остальных случаях будет ложь
– логическое ИЛИ – оператор || – возвращает истину если хоть одна из двух величин истинна. Ложь он вернет только если обе логические величины ложны
Ну например – если есть армия И есть энергия – напасть на человечество. При использовании оператора && нападения не произойдет если нет энергии или нет армии. А вот при использовании || глупая железяка попытается напасть даже если у нее нету армии, или эта армия лежит мертвой грудой без топлива и электричества.
Источник: http://nullpro.info/2013/samouchitel-po-c-dlya-nachinayushhix-01-osnovy-yazyka-peremennye-logika-cikly/
Введение в язык программирования Arduino
Основа языка программирования модуля Arduino — это язык Си (скорее Си++). Ещё точнее, этот диалект языка называется Processing/Wiring. Хорошее обозрение языка вы найдёте в приложении. А мне хочется больше рассказать не о языке, а о программировании.
Программа — это некий набор команд, которые понимает процессор, процессор вашего компьютера или процессор микроконтроллера модуля Arduino, не суть важно. Процессор читает команды и выполняет их. Любые команды, которые понимает процессор — это двоичные числа.
Это только двоичные числа и ничто иное. Выполняя арифметические операции, для которых процессор некогда и предназначался, процессор оперирует с числами. Двоичными числами. И получается, что и команды, и то, к чему они относятся, это только двоичные числа. Вот так.
Но как же процессор разбирается в этой «куче» двоичных чисел?
Во-первых, все эти двоичные числа записываются в последовательные ячейки оперативной памяти, имеющие адреса. Когда вы загружаете программу, и она начинает работать, процессор получает первый адрес программы, где обязательно должна быть записана команда.
Те команды, которые требуют от процессора операций с числами, имеют «опознавательные знаки», например, что в следующих двух ячейках памяти два числа, которые нужно сложить. А счётчик, назовём его счётчиком команд, где записан адрес следующей команды, в данном случае увеличивает адрес так, что в программе по этому адресу будет следующая команда.
При неправильной работе программы или сбоях процессор может ошибиться, и тогда, прочитав вместо команды число, процессор делает совсем не то, что должен делать, а программа «зависает».
Таким образом, любая программа — это последовательность двоичных чисел. А программирование — это умение правильно записывать правильные последовательности двоичных чисел. Достаточно давно для записи программ стали использовать специальные средства, которые называются языками программирования.
Однако любая программа в первую очередь требует от вас ясного понимания того, что должна делать программа, и для чего она нужна. Чем яснее вы это понимаете, тем легче создать программу.
Небольшие программы, хотя трудно сказать, какие программы небольшие, а какие нет, можно рассматривать целиком. Более сложные программы лучше разбить на части, которые можно рассматривать как самостоятельные программы.
Так их лучше создать, легче отладить и проверить.
Я не готов спорить, но считаю, что программу удобнее начинать с описания на обычном языке. И в этом смысле я считаю, что программирование не следует путать с написанием кода программы. Когда программа описана обычными словами, вам легче определить, например, какой язык программирования выбрать для создания кода программы.
Ближе всего к записи программы с помощью двоичных чисел, язык ассемблер. Для него характерно соответствие команд языка двоичным командам, понятным процессору.
Но кодирование программ на ассемблере требует больших усилий и ближе к искусству, чем к формальным операциям. Более универсальны и легче в применении языки высокого уровня, как Бэйсик или Си.
И давно для записи программ в общем виде используют графический язык, а в последнее время появились и «переводчики» с этого языка на язык процессоров.
Кроме языков программирования общего применения, всегда существовала некоторая специализация языков программирования, и существовали специализированные языки. К последним я бы отнёс и язык программирования модуля Arduino.
Всё, что нужно сказать модулю, чтобы он сделал что-то нужное нам, организовано в удобный набор команд. Но вначале о том, что нам нужно от Arduino?
Модуль можно использовать в разных качествах — это и сердце (или голова) робота, это и основа прибора, это и удобный конструктор для освоения работы с микроконтроллерами и т.д.
Выше мы уже использовали простые программы для проверки подключения модуля к компьютеру. Кому-то они могут показаться слишком простыми, а поэтому не интересными, но любые сложные программы состоят из более простых фрагментов, похожих на те, с которыми мы уже знакомились.
Давайте посмотрим, о чём нам может рассказать самая простая программа «Помигать светодиодом».
int ledPin = 13;
void setup()
{
pinMode (ledPin, OUTPUT);
}
void loop()
{
digitalWrite (ledPin, HIGH);
delay (1000);
digitalWrite (ledPin, LOW);
delay (1000);
}
Вначале вспомним, что такое светодиод. В сущности это обычный диод, у которого, благодаря его конструкции, при протекании тока в прямом направлении начинает светиться переход. То есть, чтобы светодиод светился, нужно чтобы через него протекал ток, а, значит, к светодиоду следует приложить напряжение.
А чтобы ток не превысил допустимого значения, последовательно со светодиодом следует включить резистор, который называют токоограничительным (см. Приложение А, цифровой выход). Напряжение к светодиоду прикладывает микроконтроллер, составляющий основу модуля Arduino.
У микроконтроллера, кроме процессора, выполняющего наши команды, есть один или несколько портов ввода-вывода.
Не вдаваясь в рассмотрение конкретного устройства порта, скажем так — когда вывод порта работает на выход, его можно представить как выход цифровой микросхемы с двумя состояниями, включено и выключено (есть напряжение на выходе, нет напряжения на выходе).
Но этот же вывод порта может работать и как вход. В этом случае его можно представить, например, как вход цифровой микросхемы – на вход подаётся логический уровень, высокий или низкий (см. Приложение А, цифровой ввод).
Как мы мигаем светодиодом:
Включить выходной вывод порта. Выключить вывод порта.
Но процессор работает очень быстро. Мы не успеем заметить мигания. Чтобы заметить это мигание, нам нужно добавить паузы. То есть:
Включить выходной вывод порта. Пауза 1 секунда.
Выключить вывод порта.
Пауза 1 секунда.
Это наша программа. Процессор прочитает первую команду и включит вывод, светодиод загорится. Затем процессор сделает паузу в работе и выключить вывод, светодиод погаснет. Но он только один раз мигнул.
Повторение какого-либо процесса или набора команд называется в программировании циклом. Используются разные виды циклов. Есть цикл, который выполняется заданное число раз. Это цикл for.
Есть циклы, которые выполняются до тех пор, пока не будет выполнено некоторое условие, которое является частью языковой конструкции цикла.
А если условие не будет выполнено никогда, то цикл выполняется бесконечное число раз. Это бесконечный цикл.
Я не думаю, что микроконтроллеры используются с программами того вида, который приведён выше. То есть, один раз выполнено несколько команд и больше контроллер не работает. Как правило, он работает постоянно, как только на него подаётся питающее напряжение. А, значит, микроконтроллер должен работать в бесконечном цикле.
Именно об этом говорит функция void loop(), loop — это петля, замкнутый цикл. Условия прекращения работы цикла нет, а, следовательно, нет условия его завершения.
Кроме того, мы должны сообщить модулю Arduino, какой вывод порта и как мы хотим использовать, для выхода (OUTPUT) или для входа (INPUT). Этой цели служит функция void setup(), которая для языка Arduino является обязательной, даже если она не используется, и команда pinMode(), для задания режима работы вывода.
void setup()
{
pinMode (ledPin, OUTPUT);
}
И ещё, языковая конструкция использует переменные для определения номера вывода:
int ledPin = 13;
Использование переменных удобно. Решив, что вы будете использовать не вывод 13, а 12, вы внесёте изменение только в одной строке. Особенно сильно это сказывается в больших программах.
Имя переменной можно выбирать по своему усмотрению, но, как правило, оно должно быть только символьным, и часто количество символов ограничивается.
Если вы неверно зададите имя переменной, думаю, компилятор вас поправит.
Функция digitalWrite (ledPin, HIGH) устанавливает заданный вывод в состояние с высоким уровнем, то есть включает вывод.
А delay (1000), как вы уже поняли, означает паузу в 1000 миллисекунд или 1 секунду.
Осталось понять, что означают такие приставки, как int, void. Любые значения, любые переменные размещаются в памяти, как и команды программы. В ячейки памяти записываются числа зачастую из 8 битов. Это байт. Но байт — это числа от 0 до 255.
Для записи больших чисел нужно два байта или больше, то есть, две или больше ячеек памяти. Чтобы процессору было ясно, как отыскать число, разные типы чисел имеют разные названия. Так число по имени byte, займёт одну ячейку, int (integer, целое) больше.
Кроме того, функции, используемые в языках программирования, тоже возвращают числа. Чтобы определить, какой тип числа должна вернуть функция, перед функцией записывают этот тип возвращаемого числа.
Но некоторые функции могут не возвращать числа, такие функции предваряют записью void (см. Приложение А, переменные).
Вот, сколько интересного может рассказать даже самая простая программа.
Обо всём этом вы, надеюсь, прочитаете в приложении. А сейчас проделаем простые эксперименты, используя только то, что мы уже знаем из возможностей языка. Первое, заменим переменную типа int, которая занимает много места в памяти, на byte — одно место, одна ячейка памяти. Посмотрим, что у нас получится.
byte ledPin = 13;
void setup()
{
pinMode (ledPin, OUTPUT);
}
void loop()
{
digitalWrite (ledPin, HIGH);
delay (1000);
digitalWrite (ledPin, LOW);
delay (1000);
}
После компиляции и загрузки программы в модуль мы не заметим изменений в работе программы. Хорошо. Тогда изменим программу так, чтобы заметить изменения в её работе.
Для этого мы заменим число в функции delay (1000) переменной, назвав её my_del. Эта переменная должна быть целым числом, то есть, int.
int my_del = 5000;
delay(my_del);
Не забывайте заканчивать каждую команду точкой с запятой. Внесите изменения в программу, скомпилируйте её и загрузите в модуль. Затем поменяйте переменную и повторите компиляцию и загрузку:
byte my_del = 5000;
Разница, уверен, получится ощутимая.
Проделаем ещё один эксперимент с изменением длительности пауз. Уменьшение длительности пауз выполним, скажем, пять раз. Сделаем паузу в 2 секунды, а затем будем увеличивать тоже пять раз. И вновь сделаем паузу в 2 секунды. Цикл, выполняемый заданное количество раз, называется циклом for и записывается он так:
for (int i = 0; i
Источник: http://nauchebe.net/2012/01/vvedenie-v-yazyk-programmirovaniya-arduino/
Загрузка...
