Таблица подключения

На 15 пин дисплея подаем +5В для подсветки и на 16 вывод GND. Порты контроллера можно с легкостью менять в программе. Ниже представлен макет присоединения:

Скетч для Arduino

/*
 LiquidCrystal Library

Демонстрация работы с 16x2 LCD дисплеем. Библиотека LiquidCrystal
 работает со всеми LCD совместимыми с Hitachi HD44780.

Данный скетч отображает на LCD надпись «ARDUINO.NET.UA»
 Скетч основан на оригинальном скетче Arduino

http://www.arduino.cc/en/Tutorial/LiquidCrystal

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

Схема подключения:
 * LCD RS пин к цифр. выходу 12
 * LCD Enable пин к цифр. выходу 11
 * LCD R/W к Общему
 * LCD VO пин (пин 3) к ШИМ-выходу 9
 * LCD D4 пин к цифр. выходу 5
 * LCD D5 пин к цифр. выходу 4
 * LCD D6 пин к цифр. выходу 3
 * LCD D7 пин к цифр. выходу 2

*/

// подключаем библиотеку:
 #include 

// инициализация библиотеки с перечнем задействованных выводов
 LiquidCrystal lcd (12, 11, 5, 4, 3, 2);

void setup () {
 // устанавливаем ШИМ выход:
 pinMode (9, OUTPUT);
 analogWrite (9, 50);
 // устанавливаем кол-во столбцов и строк:
 lcd.begin (16, 2);
 // печать сообщения на LCD.
 lcd.print ( «ARDUINO.NET.UA»);
 }

void loop () {
 // устанавливаем курсор в 0-ом столбце, 1 строка (начинается с 0):
 lcd.setCursor (0, 1);
 // печать числа секунд после сброса:
 lcd.print (millis ()/1000);
 }

ArduinoIDEимеет библиотеку LiquidCrystal, но в ней нет поддержки русского языка, модифицированную библиотеку можно скачать ниже и перенести ее в папку libraries.[szapisi]

Скачать скетч LCD HD44780 + Arduino Uno. sketch_apr02a

Подключаем аноды ( длинные контакты светодиодов ) к выводам 2-13 через резисторы 220 Ом. Катоды ( короткие «ножки» светодиода ) подключаем на землю.

Программа:

В функции setup() программы, for () loop используется для настройки цифровых выходов 2-13 Mega на вывод.

Используем три вложенных цикла for () loops.

Первый:

for (int thisPin =lowestPin; thisPin ≤ highestPin; thisPin++)

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

for (int brightness = 0; brightness 

При каждом проходе через цикл, переменная увеличит яркость на одну единицу, что записывается на выходе выбранного контакта в главном цикле. При достижении максимального значения ШИМ ( 255 ), цикл гасит:

for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite (thisPin, brightness);
delay (2);
}

Данный цикл вычитает из данных переменной яркости,тем самым затемняя светодиод. По достижении минимального значения, главным for () loop, после чего программа идет к другому светодиоду ( следующему ), повторяя снова предыдущие шаги.

/ *
 Мега analogWrite () пример

Схема:
 * Светодиоды: контакты от 2 до 13 и к земле.

*/
 // Эти константы не изменяются. Они используются для обозначения выводов
 const int lowestPin = 2;
 const int highestPin = 13;

void setup () {
 //настраивает контакты на вывод:
 for (int thisPin =lowestPin; thisPin ≤ highestPin; thisPin++) {
 pinMode (thisPin, OUTPUT);
 }
 }

void loop () {
 // итерация по выводам:
 for (int thisPin =lowestPin; thisPin ≤ highestPin; thisPin++) {
 // зажигание светодиода:
 for (int brightness = 0; brightness = 0; brightness--) {
 analogWrite (thisPin, brightness);
 delay (2);
 }
 // пауза между индикаторами:
 delay (100);
 }
 }

Не будем говорить, что для этого понадобился ряд подготовительных работ - оригинальные схемы версий Arduino, даташиты на FT 232... В общем получилась такая схема:

Схема для самостоятельной сборки Ардуино

Используемые в схеме детали:

Резисторы SMD типоразмер 0805:
- R1, R2, R4, R7 – от 300 Ом до 1 кОм ( какие есть );
- R3 – 10 кОм;
- R5, R6 – 1 кОм.

Конденсаторы:
- С2, С3, С5, С13, С8, С10, С11 – SMD (0805) номиналом 0,1 мкф;
- электролиты С1, С4, С9, С12 –мкф*50 В. Номинал не особо важен, не ниже 10 мкф на напряжение не ниже 10 В, кроме С9, его напряжение должно быть больше не 20 % напряжения питания внешнего источника;
- С6, С7 – керамика по 22 пф.

Светодиоды любые (форма, габариты, цвет) на ток 15-20 мА. Диод D5 – 1N4007 тоже в SMD корпусе. Кварц – 16 МГц.

Микросхемы:
- DA1 – L7805 в корпусе ТО220;
- DD1 – FT232RL ;
- DD2 – микроконтроллер ATmega168, можно ATmega8.

Собираем устройство и подключаем его к компьютеру. В скачанной программе Arduino IDE находим драйвер и устанавливаем его.Использовать эту систему можно в разнообразных ситуациях, вплоть до охранных систем. В интернете и на нашем сайте можно найти много применений данной системы.

Печатные платы и программирование Arduino

Работает контроллер используя программу Arduino IDE. Программы пишутся самостоятельно. После загрузки ее в микроконтроллер он начинает по ней работать. Контроллер питается как от USB так и от внешнего источника. Для этого установлен микросхемный стабилизатор L7805. Разъем ICSP позволяет загружать сторонние программы.

Файлы ПП в Sprint-Layout прилагаются. Прошитый контроллер начинает работать сразу. Но начинает работать через некоторое время светодиод D3 осле загрузки бутлодера. Эта проблема также решается путем прошивки. Для программирования стоит использовать  CodeVisionAVR. Открываем окно прошивки микроконтроллера, нажимаем load flash, находим наш (для ATmega168) файл прошивки в скаченном дистрибутиве «…arduino-1.0.1hardwarearduinobootloadersatmega ATmegaBOOT_168_diecimila.hex. Далее необходимо выставить lock и fuse биты так, как показано на рисунке:

Узнать фьюз- и лок-биты для своего микроконтроллера можно посмотреть в файле: «…arduino-1.0.1hardwarearduinoboards.txt», использовав калькулятор фьюзов для AVR (можно легко найти в интернете).
Если же у Вас нет программатора, но есть программатор у друга, соседа.., то есть другой, более быстрый и полезный способ прошить загрузчик. Для этого нужно собрать программатор по этой схеме. Схема рабочая и проверенная мной. Простота этого метода заключается в том, что не нужно искать прошивку микроконтроллера, выставлять фьюз и лок-биты. При подключении этого программатора к компьютеру с установленными драйверами и подключенным программируемым МК, Вы, выбрав в программе Arduino IDE порт, на котором «сидит» программатор и свою прошиваемую плату и подключенный программатор, просто нажимаете на кнопку во вкладке сервис «прошить загрузчик» и радуетесь.

Теперь (с устанвленными драйверами на компьютере, открываете программу Arduino IDE, во вкладке «Сервис» наводим курсор на вкладку «плата» и выбираем свое устройство (в моем варианте это – Arduino Diecimila or Duemilanove w/ ATmega168). Далее, там же, выбираем порт к которому подключен контроллер (можно посмотреть в диспетчере устройств компьютера). Реализуем свои мысли в скетче и радуемся работе контроллера!

Схема подключения LCD к Ардуино

Ниже приведена программа под Arduino/ Значение контрастности выставится только после того, когда проинициализируется программа. При самостоятельной доработке скетча можно сделать внешнее управление контрастностью. Один из примеров - кнопки "+" и "-". Для такого решения также надо внести изменения в программу.

/*

 Демонстрация работы с 16x2 LCD дисплеем.  Библиотека LiquidCrystal
 работает со всеми LCD совместимыми с Hitachi HD44780.
 
 Данный скетч отображает на LCD "Hobbytronics".
 Скетч основан на оригинальном скетче Arduino 
 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 с модификациями, позволяющими вручную устанавливать
 контрастность дисплея
 
  Схема подключения:
 * LCD RS пин к цифр. выходу 12
 * LCD Enable пин к цифр. выходу 11
 * LCD R/W к Общему
 * LCD VO пин (пин 3) к ШИМ-выходу 9
 * LCD D4 пин к цифр. выходу 5
 * LCD D5 пин к цифр. выходу 4
 * LCD D6 пин к цифр. выходу 3
 * LCD D7 пин к цифр. выходу 2

 */

#include        // подключаем библиотеку

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // инициализация библиотеки с перечнем задействованных выводов

void setup() {
  pinMode(9, OUTPUT);  
  analogWrite(9, 50);   // устанавливаем ШИМ выход   
  lcd.begin(16, 2);             // устанавливаем кол-во столбцов и строк
  lcd.print("  HobbyTronics");  // печать сообщения на LCD
}

void loop() {
  // устанавливаем курсор в 0-ом столбце, 1 строка (начинается с 0)
  lcd.setCursor(0, 1);
  lcd.print(millis()/1000);     // печать числа секунд после сброса
}

Решается проблема при помощи MOSFET-транзисторов. Рассмотрим MOSFET фирмы ST microelectronics: 95N2LH5 N-Channel Power MOSFET.

Этот транзистор легко выдерживает нагрузку до 80 А продолжительное время. Открывается при напряжении затвора 1в. А следовательно спокойно можем присоединять его к ноге Arduino. При открытом транзисторе сопротивление Исток-Сток всего 0.0049 Ом.

Т.е. если к нему подключить двигатель 12В, 10А - на транзисторе падение напряжения составит всего 0,049В, рассеиваемая мощность будет достигать 0,49 Ватт.

Схема подключения двигателя к Arduino посредством MOSFET

Используя ШИМ-выход контроллера, можно управлять мощностью двигателя.

Ну и еще пример: здесь мы смотрели плавное включение светодиода, но вместо LED можно использовать автомобильную лампочку накаливания на 12 В. Питание лампы надо осуществлять от 12 В батареи или БП.

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

Напряжение с делителя подается на вход АЦП Arduino. Сравнивается значение с определенным порогом и включается или выключается ночник.

Схема делителя

Когда освещенность увеличивается, сопротивление фоторезистора падает и соответственно на выходе делителя (и входе АЦП) напряжение увеличивается. Когда освещенность падает все идет наоборот.

Монтажная схема светодиодного светильника

Напряжение 0 и 5 В берутся непосредственно с Arduino. A0 - используем для входа АЦП.

Более яркий LED-светодиод, вы можете подключить к ноге 13 (через резистор ~220 Ом). Если будете подключать более мощную нагрузку, такую как лампу накаливания, то ее следует подключать через реле или тиристор.

/*
** Ночник на светодиоде
**
*/

int sensorPin = A0;            // устанавливаем входную ногу для АЦП
unsigned int sensorValue = 0;  // цифровое значение фоторезистора

void setup()
{
  pinMode(13, OUTPUT);
  Serial.begin(9600);        // старт последовательного вывода данных (для тестирования)
}

void loop()
{
  sensorValue = analogRead(sensorPin);  // считываем значение с фоторезистора
  if(sensorValue

Понятно, что при переходе сигнала от положительного к нулю, мы считываем значение В. Если В в положительном состоянии, следовательно энкодер вращается вправо. Если В в нуле - то энкодер вращается влево. Считывая оба выхода, мы при помощи МК можем определить направление вращения, и при помощи подсчета импульсов с А выхода - угол поворота.

Как мы уговорились, будем управлять яркостью светодиода  используя ШИМ-выход. Для считывания данных будем использовать этот метод на программных таймерах, который рассматривали ранее. Определимся, как часто будем обращаться к выходам нашего энкодера для считывания значений. Пример: мы можем повернуть ручку энкодера на 180° за 1/10 сек, т.е. это будет 6 импульсов за 1/10 сек или 60 импульсов в секунду. В реальности быстрее вращать не сможете. Т.к. нам необходимо отслеживать все полупериоды, то частота должна быть минимум 120 Герц. Мы примем 200 Гц.

Схема энкодера Arduino

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

Программа приведена ниже, используется функция millis() для задания временных интервалов. Временной интервал : 5 мс (200 Гц).

/*
** Энкодер
** Для управлением яркостью LED используется энкодер Sparkfun
*/

int brightness = 120;           // яркость LED, начинаем с половины
int fadeAmount = 10;            // шаг изменения яркости LED
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 12;           // pin 12
const int pin_B = 11;           // pin 11
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_A_prev=0;

void setup()  {
  // declare pin 9 to be an output:
  pinMode(9, OUTPUT);             // устанавливаем pin 9 как выход
  pinMode(pin_A, INPUT);
  pinMode(pin_B, INPUT);
  currentTime = millis();
  loopTime = currentTime; 
} 

void loop()  {
  currentTime = millis();
  if(currentTime >= (loopTime + 5)){ // проверяем каждые 5мс (200 Гц)
    encoder_A = digitalRead(pin_A);     // считываем состояние выхода А энкодера 
    encoder_B = digitalRead(pin_B);     // считываем состояние выхода А энкодера    
    if((!encoder_A) && (encoder_A_prev)){        // если состояние изменилось с положительного к нулю
      if(encoder_B) {
        // выход В в полож. сост., значит вращение по часовой стрелке
        // увеличиваем яркость, не более чем до 255
        if(brightness + fadeAmount = 0) brightness -= fadeAmount;               
      }   

    }   
    encoder_A_prev = encoder_A;     // сохраняем значение А для следующего цикла 
    
    analogWrite(9, brightness);   // устанавливаем яркость на 9 ножку
   
    loopTime = currentTime;
  }                       
}

Для этого подключим к пину 9 светодиод через резистор 220 Ом.

Для плавного регулирования яркостью используем функцию analogWrite(). Эта функция выводит ШИМ-сигнал на ножку контроллера. Функцию pinMode() предварительно можно не вызывать. Функция analogWrite(pin, value) соответственно содержит два параметра - pin - номер ножки для вывода и value - значение от 0 ( выключенное состояние светодиода ) до 255 ( вкл.)

/*
 Плавное включение светодиодов
 
 Пример, показывающий возможности функции analogWrite()
 для реализации Fade-эффекта светодиода, который
 подключен к ноге 9 контроллера
 
 */
int brightness = 0;     // яркость светодиода
int fadeAmount = 5;     // шаг изменения яркости
unsigned long currentTime;
unsigned long loopTime;

void setup()  { 
  pinMode(9, OUTPUT);   // устанавливаем 9 ногу как выход
  currentTime = millis();
  loopTime = currentTime; 
} 

void loop()  { 
  currentTime = millis();
  if(currentTime >= (loopTime + 20)){  
    analogWrite(9, brightness);    // устанавливаем значение на 9 ножке

    brightness = brightness + fadeAmount;       // прибавляем шаг изменения яркости, которая установится в следующем цикле

    // если достигли мин. или макс. значения, то идем в обратную сторону (реверс): 
    if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ; 
    }     
    loopTime = currentTime;
  }       
}

У Arduino UNO имеется 3 порта:

• B (цифровые входа/выхода с 8 по 13)
• C (аналоговые входа)
• D (цифровые входа/выхода с 0 по 7)

Каждый порт подвергается управлению 3 регистрами. Регистр DDR сам определит, чем будет pin: вход или выход. Используя регистр PORT устанавливаем pin в состояние HIGH или LOW. При помощи регистра PIN можно считать состояние ножек Arduino, когда они работает на вход.

Будем использовать порт В. Установим ножки порта В как цифровые выхода. Порт В имеет только шесть ног. Mbns регистра для нашего порта В (DDRB) устанавливаются в 1 при использовании ноги как OUTPUT и в 0, если INPUT. Биты порта нумеруются с 0-7, но не обязательно они содержат все 8 ног.

Пример:

DDRB = B00111110; // установить ножки порта В с 1 по 5 как выхода, а 0 как вход.

В нашем проекте бегущего огня мы будем использовать 5 выходов:
DDRB = B00011111; // установить ноги порта В с 0 по 4 как выхода

Для записи значений в порт В необходимо использовать регистр PORTB. Зажечь первый светодиод можно командой:
PORTB = B00000001;
первый и четвертый:
PORTB = B00001001;

При помощи этих команд мы теперь можем легко зажигать и выключать LED.

Рассматриваем операторы сдвига.

Существуют два оператора сдвига: влево и вправо - >.

Пример:

varA = 1; // 00000001
varA = 1 varA = 1 varA = 1

Введем  2 переменные: перваяupDown - куда двигаться - вверх или вниз, а вторая cylon какие LED зажигать.

В функции setup() мы определяем какие ножки должны работать как выхода.

В главном цикле программы loop(), светодиоды по очереди загораются вверх путем увеличения переменной cylon, а когда доходит до самого верхнего, то переменной upDown присваивается 0 и светодиоды загораются вниз по очереди.[szapisi]

/*
  Бегущая строка. 5 светодиодов
 */

unsigned char upDown=1;         // начинаем с движения вверх    
unsigned char cylon=0;          // определяет очередность LED

void setup() {                
  DDRB = B00011111;             // устанавливаем порт B с 0 по 4 как выхода   
}

void loop() {
  if(upDown==1){                                // если идем вверх, то
    cylon++;
    if(cylon>=4) upDown=0;      // когда достигнут наибольший номер LED, то в след. цикле идем вниз
  }
  else {
    cylon--;
    if(cylon==0) upDown=1;      // когда достигнут наименьший номер LED, то в след. цикле идем вверх
  }
  PORTB = 1 

Для управления светодиодом мы использовали код:

/* Мигание LED
 * ------------
 *
 * Включает и выключает светодиод (LED) подсоединенный  
 * к выходу 13, с интервалом в 2 секунды
 *
 */

int ledPin = 13;                // LED подсоединен к выводу 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливаем вывод 13 как выход
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // включаем LED
  delay(1000);                  // пауза 1 секунда
  digitalWrite(ledPin, LOW);    // выключаем LED
  delay(1000);                  // пауза 1 секунда
}

В этом коде есть один недостаток: для выдержки между циклами включения LED использовалась команда: delay(). Но...При использовании этой команды, контроллер не в состоянии использовать другие команды в главной функции loop():

Внесем некоторые изменения в исходный код. Заменим две строки исходного кода на один. Вместо установки значения вHIGH, а затем обратно в LOW, мы получим текущее значение ledPin и проинвертируем его. Т.е. если оно было HIGH, то станет LOW и наоборот.

void loop()
{
  digitalWrite(ledPin, !digitalRead(ledPin));   // включаем/выключаем LED
  delay(1000);                  // задержка 1 сек.
}

Теперь модернизируем функцию delay(). Вместо нее стоит вставить millis(). Она возвращает миллисекунды,прошедшие с момента запуска программы. Функция переполнится (вернется в нуль) приблизительно через 50 суток работы программы.

Как за альтернативу можно взять команду micros(), она возвращает количество микросекунд, прошедшее с момента запуска текущей программы. Функция переполнится (вернется в нуль) приблизительно через 70 минут работы программы.

/* Мигание LED Версия 2
 * ------------------------
 * Включает и выключает светодиод (LED) подсоединенный   
 * к выходу 13, с интервалом в 2 секунды используя функцию millis()
 *
 */
int ledPin = 13;                 // LED подсоединен к выводу 13
unsigned long currentTime;
unsigned long loopTime;

void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливаем вывод 13 как выход
  currentTime = millis();               // считываем время, прошедшее с момента запуска программы
  loopTime = currentTime;  
}

void loop()
{
  currentTime = millis();                                       // считываем время, прошедшее с момента запуска программы
  if(currentTime >= (loopTime + 1000)){                              // сравниваем текущий таймер с переменной loopTime + 1 секунда
    digitalWrite(ledPin, !digitalRead(ledPin));         // включаем/выключаем LED
    loopTime = currentTime;                                             // в loopTime записываем новое значение
  }
  // Здесь могут быть другие команды
}

Мы ввели в пример две новые переменные currentTime и loopTime. Обе функции имеют одинаковое значение. В функции loop(), переменная currentTime каждый раз обновляется в цикле. Когда currentTime больше чем loopTime на 1 секунду (loopTime + 1000), то LED меняет свое состояние, а переменной loopTime присваивается текущее значениеcurrentTime. Обратите внимание, что в данном примере мы не использовали функцию delay() и процессор может выполнять другие операции.[szapisi]

Программа очень простая. Для начала стоит подключить программу.  В приведенном ниже файле абсолютно все команды для управления серво. Можно, конечно написать самому, но для чего изобретать велосипед?

Создаем сам объект servo. В нашем случае это будет servoMain. Другая функция - stup(), в ней прописывается место прописки подсоединения контроллера. В этом случае - пин 9.

/*
Arduino Servo
*/
#include 
Servo servoMain; // Обьект Servo

void setup()
{
   servoMain.attach(9); // Servo присоединен к 9 выводу
}

void loop()
{
   servoMain.write(45);  // Повернуть серво влево на 45 градусов
   delay(2000);          // Пауза 2 сек.
   servoMain.write(0);   // Повернуть серво влево на 0 градусов
   delay(1000);          // Пауза 1 сек.
   servoMain.write(90);  // Повернуть серво на 90 градусов. Центральная позиция
   delay(1500);          // Пауза 1.5 сек.
   servoMain.write(135); // Повернуть серво вправо на 135 градусов
   delay(3000);          // Пауза 3 сек.
   servoMain.write(180); // Повернуть серво вправо на 180 градусов
   delay(1000);          // Пауза 1 сек.
   servoMain.write(90);  // Повернуть серво на 90 градусов. Центральная позиция
   delay(5000);          // Пауза 5 сек.
}

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

Контроллер  Arduino UNO уже имеет резистор и светодиод. Светодиод уже подключен к 13 выводу и никаких других компонентов нам не понадобится.

/* Мигание LED
 * ------------
 *
 * Включает и выключает светодиод (LED) подсоединенный  
 * к выходу 13, с интервалом в 2 секунды
 *
 */

int ledPin = 13;                // LED подсоединен к выводу 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливаем вывод 13 как выход
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // включаем LED
  delay(1000);                  // пауза 1 секунда (1000 мс)
  digitalWrite(ledPin, LOW);    // выключаем LED
  delay(1000);                  // пауза 1 секунда (1000 мс)
}

Функция delay(n) приостанавливает обработку программы на n миллисекунд. Все это происходит в вечном цикле loop().[szapisi]