Программа кружка Робототехника

СОГЛАСОВАНО

Заместитель директора по ВР

_______________________ /

«____» ______________ 20___ г.

УТВЕРЖДЕНО

Приказом по МАОУ СШ №8

от «____» сентября 20____ г. №____

Директор _______________________ /

№ п\п

Тема занятия

Количество часов

Дата проведения

План

Факт

Раздел 1. Электричество

Электричество. Основные элементы схемы. Техника безопасности при работе .

1

Схемы. Сборка схем.

1

Управление электричеством. Резистор. Делитель напряжения.

1

Диод. Светодиод. Кнопка.

1

Транзисторы. Конденсатор. Пьезодинамик. Мотор.

1

Светопривод. Микросхема.

Раздел 2. Начало работы с Arduino

Начало работы с Arduino

1

Маячок

1

Маячок с нарастающей яркостью

1

Светильник с управляемой яркостью

1

Терменвокс

2

Ночной светильник

2

Пульсар

1

Бегущий огонек

1

Пианино

2

Миксер

2

Кнопочный переключатель

1

Светильник с кнопочным управлением

1

Кнопочные ковбои

2

Секундомер

1

Счетчик нажатий

1

Комнатный термометр

2

Метеостанция

2

Тестер батареек

2

Светильник, управляемый по USB

1

Итоговое занятие

2

Итого

34 часа

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиод

1 резистор номиналом 220 Ом

2 провода «папа-папа»

Схема на макетке

Скетч

p010_blink.ino

void setup()

{

// настраиваем пин №13 в режим выхода,

// т.е. в режим источника напряжения

pinMode(13, OUTPUT);

}

 void loop()

{

// подаём на пин 13 «высокий сигнал» (англ. «high»), т.е.

// выдаём 5 вольт. Через светодиод побежит ток.

// Это заставит его светиться

digitalWrite(13, HIGH);

// задерживаем (англ. «delay») микроконтроллер в этом

// состоянии на 100 миллисекунд

delay(100);

// подаём на пин 13 «низкий сигнал» (англ. «low»), т.е.

// выдаём 0 вольт или, точнее, приравниваем пин 13 к земле.

// В результате светодиод погаснет

digitalWrite(13, LOW);

// замираем в этом состоянии на 900 миллисекунд

delay(900);

// после «размораживания» loop сразу же начнёт исполняться

// вновь, и со стороны это будет выглядеть так, будто

// светодиод мигает раз в 100 мс + 900 мс = 1000 мс = 1 сек

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиод

1 резистор номиналом 220 Ом

2 провода «папа-папа»

Схема на макетке

p020_pulse_light.ino

// даём разумное имя для пина №9 со светодиодом

// (англ. Light Emitting Diode илипросто «LED»)

// Так нам не нужно постоянно вспоминать куда он подключён

#define LED_PIN 9

 void setup()

{

// настраиваем пин со светодиодом в режим выхода,

// какираньше

pinMode(LED_PIN, OUTPUT);

}

void loop()

{

// выдаём неполное напряжение на светодиод

// (он же ШИМ-сигнал, он же PWM-сигнал).

// Микроконтроллер переводит число от 0 до 255 к напряжению

// от 0 до 5 В. Например, 85 — это 1/3 от 255,

// т.е. 1/3 от 5 В,т.е. 1,66 В.

analogWrite(LED_PIN, 85);

// держим такую яркость 250 миллисекунд

delay(250);

// выдаём 170, т.е. 2/3 от 255, или иными словами — 3,33 В.

// Больше напряжение — выше яркость!

analogWrite(LED_PIN, 170);

delay(250);

  // все 5 В — полный накал!

analogWrite(LED_PIN, 255);

// ждём ещё немного перед тем, как начать всё заново

delay(250);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиод

1 резистор номиналом 220 Ом

6 проводов «папа-папа»

1 потенциометр

Схема на макетке

// даём разумные имена для пинов со светодиодом

// и потенциометром (англ potentiometer или просто «pot»)

#define LED_PIN 9

#define POT_PIN A0

void setup()

{

// пин со светодиодом — выход, как и раньше...

pinMode(LED_PIN, OUTPUT);

// ...а вот пин с потенциометром должен быть входом

// (англ. «input»): мы хотим считывать напряжение,

//выдаваемоеим

pinMode(POT_PIN, INPUT);

}

void loop()

{

// заявляем, что далее мы будем использовать 2 переменные с

// именами rotation и brightness, и что хранить в них будем

// целые числа (англ. «integer», сокращённо просто «int»)

int rotation, brightness;

// считываем в rotation напряжение с потенциометра:

// микроконтроллер выдаст число от 0 до 1023

// пропорциональное углу поворота ручки

rotation = analogRead(POT_PIN);

// в brightness записываем полученное ранее значение rotation

// делённое на 4. Поскольку в переменных мы пожелали хранить

// целые значения, дробная часть от деления будет отброшена.

// В итоге мы получим целое число от 0 до 255

brightness = rotation / 4;

// выдаём результат на светодиод

analogWrite(LED_PIN, brightness);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 пьезопищалка

6 проводов «папа-папа»

1 резистор номиналом 10 кОм

1 фоторезистор

Схема на макетке

Скетч

// даём имена для пинов с пьезопищалкой (англ. buzzer) и фото-

//резистором (англ. Light Dependent Resistor илипросто LDR)

#define BUZZER_PIN 3

#define LDR_PIN A0

void setup()

{

// пин с пьезопищалкой — выход...

pinMode(BUZZER_PIN, OUTPUT);

// ...а все остальные пины являются входами изначально,

// всякий раз при подаче питания или сбросе микроконтроллера.

// Поэтому, на самом деле, нам совершенно необязательно

// настраивать LDR_PIN в режим входа: он и так им является

}

void loop()

{

int val, frequency;

// считываем уровень освещённости так же, как для

// потенциометра: в виде значения от 0 до 1023.

val = analogRead(LDR_PIN);

// рассчитываем частоту звучания пищалки в герцах (ноту),

// используя функцию проекции (англ. map). Она отображает

// значение из одного диапазона на другой, строя пропорцию.

// В нашем случае [0; 1023] -> [3500; 4500]. Так мы получим

// частоту от 3,5 до 4,5 кГц.

frequency = map(val, 0, 1023, 3500, 4500);

// заставляем пин с пищалкой «вибрировать», т.е. звучать

// (англ. tone) на заданной частоте 20 миллисекунд. При

// cледующих проходах loop, tone будет вызван снова и снова,

// и на деле мы услышим непрерывный звук тональностью, которая

// зависит от количества света, попадающего на фоторезистор

tone(BUZZER_PIN, frequency, 20);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиод

1 фоторезистор

1 резистор номиналом 220 Ом

1 резистор номиналом 10 кОм

1 переменный резистор (потенциометр)

10 проводов «папа-папа»

Схема на макетке

Скетч

#define LED_PIN 13

#define LDR_PIN A0

#define POT_PIN A1

void setup()

{

pinMode(LED_PIN, OUTPUT);

}

void loop()

{

// считываем уровень освещённости. Кстати, объявлять

// переменную и присваивать ей значение можно разом

int lightness = analogRead(LDR_PIN);

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

// пороговое значение между условными темнотой и светом

int threshold = analogRead(POT_PIN);

// объявляем логическую переменную и назначаем ей значение

// «темно ли сейчас». Логические переменные, в отличие от

// целочисленных, могут содержать лишь одно из двух значений:

// истину (англ. true) или ложь (англ. false). Такие значения

// ещё называют булевыми (англ. boolean).

boolean tooDark = (lightness < threshold);

// используем ветвление программы: процессор исполнит один из

// двух блоков кода в зависимости от исполнения условия.

// Если (англ. «if») слишком темно...

if(tooDark){

// ...включаемосвещение

digitalWrite(LED_PIN, HIGH);

} else {

// ...иначе свет не нужен — выключаем его

digitalWrite(LED_PIN, LOW);

}

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 биполярный транзистор

1 светодиодная шкала

1 резистор номиналом 1 кОм

10 резисторов номиналом 220 Ом

13 проводов «папа-папа»

Схема на макетке

Скетч

p060_pulse_bar.ino

#define CONTROL_PIN 9

// переменные верхнего уровня, т.е. объявленные вне функций,

// называют глобальными. Их значения сохраняются всё время,

// пока работает микроконтроллер

int brightness = 0;

void setup()

{

pinMode(CONTROL_PIN, OUTPUT);

}

void loop()

{

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

// яркость. Однако яркость не должна быть более 255, поэтому

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

// достижении значения 255, следующим значением снова стал 0

// Y % X — это остаток от деления Y на X;

// плюс, минус, делить, умножить, скобки — как в алгебре.

brightness = (brightness + 1) % 256;

// подаём вычисленный ШИМ-сигнал яркости на пин с базой

//управляющеготранзистора

analogWrite(CONTROL_PIN, brightness);

// ждём 10 мс перед следующим наращиванием яркости. Таким

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

// 256×10 = 2560 мс

delay(10);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 пьезопищалка

3 тактовых кнопки

3 резистора номиналом 10 кОм

10 проводов 

Схема на макетке

Скетч

#define BUZZER_PIN 13 // пин с пищалкой (англ.«buzzer»)

#define FIRST_KEY_PIN 7 // первыйпинсклавишей (англ. «key»)

#defineKEY_COUNT 3 // общее количество клавиш

void setup()

{

pinMode(BUZZER_PIN, OUTPUT);

}

voidloop()

{

// в цикле бежим по всем номерам кнопок от 0-го по 2-й

for (int i = 0; i < KEY_COUNT; ++i) {

// на основе номера кнопки вычисляем номер её пина

int keyPin = i + FIRST_KEY_PIN;

// считываем значение с кнопки. Возможны всего 2 варианта:

// * высокий сигнал, 5 вольт, истина — кнопка отпущена

// * низкий сигнал, земля, ложь — кнопка зажата

boolean keyUp = digitalRead(keyPin);

// проверяем условие «если не кнопка отпущена». Знак «!»

// перед булевой переменной означает отрицание, т.е. «не».

if (!keyUp) {

// рассчитываем высоту ноты в герцах в зависимости от

// клавиши, которую рассматриваем на данном этапе цикла.

// Мы получим значение 3500, 4000 или 4500

int frequency = 3500 + i * 500;

// Заставляем пищалку пищать с нужной частотой в течение

// 20 миллисекунд. Если клавиша останется зажатой, пищалка

// вновь зазвучит при следующем проходе loop, а мы услышим

//непрерывныйзвук

tone(BUZZER_PIN, frequency, 20);

Список деталей для эксперимента

1 плата Arduino Uno

беспаечная макетная плата

3 тактовых кнопки

1 коллекторный двигатель

1 выпрямительный диод

1 полевой MOSFET-транзистор

15 проводов 

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

Схема на макетке

Скетч

#define MOTOR_PIN 9

#define FIRST_BUTTON_PIN 5

#define BUTTON_COUNT 3

// имена можно давать не только числам, но и целым выражениям.

// Мы определяем с каким шагом (англ. step) нужно менять

// скорость (англ. speed) мотора при нажатии очередной кнопки

#define SPEED_STEP (255 / (BUTTON_COUNT - 1))

void setup()

{

pinMode(MOTOR_PIN, OUTPUT);

// на самом деле, в каждом пине уже есть подтягивающий

// резистор. Для его включения необходимо явно настроить пин

// как вход с подтяжкой (англ. input with pull up)

for (int i = 0; i < BUTTON_COUNT; ++i)

pinMode(i + FIRST_BUTTON_PIN, INPUT_PULLUP);

}

 void loop()

{

for (int i = 0; i < BUTTON_COUNT; ++i) {

// если кнопка отпущена, нам она не интересна. Пропускаем

// оставшуюся часть цикла for, продолжая (англ. continue)

// его дальше, для следующего значения i

if (digitalRead(i + FIRST_BUTTON_PIN))

continue;

// кнопка нажата — выставляем соответствующую ей скорость

// мотора. Нулевая кнопка остановит вращение, первая

// заставит крутиться в полсилы, вторая — на полную

int speed = i * SPEED_STEP;

// подача ШИМ-сигнала на мотор заставит его крутиться с

// указанной скоростью: 0 — стоп машина, 127 — полсилы,

// 255 — полныйвперёд!

analogWrite(MOTOR_PIN, speed);

}

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 тактовая кнопка

1 резистор номиналом 220 Ом

1 светодиод

5 проводов 

Схема на макетке

Скетч

#define BUTTON_PIN 3

#define LED_PIN 13

boolean buttonWasUp = true; // былаликнопкаотпущена?

boolean ledEnabled = false; // включенлисвет?

void setup()

{

pinMode(LED_PIN, OUTPUT);

pinMode(BUTTON_PIN, INPUT_PULLUP);

}

void loop()

{

// определить момент «клика» несколько сложнее, чем факт того,

// что кнопка сейчас просто нажата. Для определения клика мы

// сначала понимаем, отпущена ли кнопка прямо сейчас...

boolean buttonIsUp = digitalRead(BUTTON_PIN);

// ...если «кнопка была отпущена и (&&) не отпущена сейчас»...

if (buttonWasUp && !buttonIsUp) {

// ...может это «клик», а может и ложный сигнал (дребезг),

// возникающий в момент замыкания/размыкания пластин кнопки,

// поэтому даём кнопке полностью «успокоиться»...

delay(10);

// ...исчитываемсигналснова

buttonIsUp = digitalRead(BUTTON_PIN);

if (!buttonIsUp) { // еслионавсёещёнажата...

// ...это клик! Переворачиваем сигнал светодиода

ledEnabled = !ledEnabled;

digitalWrite(LED_PIN, ledEnabled);

}

}

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

buttonWasUp = buttonIsUp;

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

2 тактовых кнопки

1 резистор номиналом 220 Ом

1 светодиод

7 проводов 

Схема на макетке

Скетч

#define PLUS_BUTTON_PIN 2

#define MINUS_BUTTON_PIN 3

#define LED_PIN 9

int brightness = 100;

boolean plusUp = true;

boolean minusUp = true;

void setup()

{

pinMode(LED_PIN, OUTPUT);

pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP);

pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP);

}

 void loop()

{

analogWrite(LED_PIN, brightness);

// реагируем на нажатия с помощью функции, написанной нами

plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35);

minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35);

}

// Собственная функция с 3 параметрами: номером пина с кнопкой

// (buttonPin), состоянием до проверки (wasUp) и градацией

// яркости при клике на кнопку (delta). Функция возвращает

// (англ. return) обратно новое, текущее состояние кнопки

boolean handleClick(int buttonPin, boolean wasUp, int delta)

{

boolean isUp = digitalRead(buttonPin);

if (wasUp && !isUp) {

delay(10);

isUp = digitalRead(buttonPin);

// если был клик, меняем яркость в пределах от 0 до 255

if (!isUp)

brightness = constrain(brightness + delta, 0, 255);

}

return isUp; // возвращаем значение обратно, в вызывающий код

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

2 тактовых кнопки

2 резистора номиналом 220 Ом

2 светодиода

1 пьезопищалка

10 проводов 

Схема на макетке

Скетч

#define BUZZER_PIN 12 // пин с пищалкой

#define PLAYER_COUNT 2 // количество игроков-ковбоев

// вместо перечисления всех пинов по-одному, мы объявляем пару

// списков: один с номерами пинов с кнопками, другой — со

// светодиодами. Списки также называют массивами (англ. array)

int buttonPins[PLAYER_COUNT] = {3, 13};

int ledPins[PLAYER_COUNT] = {9, 11};

void setup()

{

pinMode(BUZZER_PIN, OUTPUT);

for (int player = 0; player < PLAYER_COUNT; ++player) {

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

// под указанным в них номером. Нумерация начинается с нуля

pinMode(ledPins[player], OUTPUT);

pinMode(buttonPins[player], INPUT_PULLUP);

}

}

void loop()

{

// даём сигнал «пли!», выждав случайное время от 2 до 7 сек

delay(random(2000, 7000));

tone(BUZZER_PIN, 3000, 250); // 3 килогерца, 250 миллисекунд

for (int player = 0; ; player = (player+1) % PLAYER_COUNT) {

// если игрок номер «player» нажал кнопку...

if (!digitalRead(buttonPins[player])) {

// ...включаем его светодиод и сигнал победы на 1 сек

digitalWrite(ledPins[player], HIGH);

tone(BUZZER_PIN, 4000, 1000);

delay(1000);

digitalWrite(ledPins[player], LOW);

break; // Есть победитель! Выходим (англ. break) из цикла

}

}

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 семисегментный индикатор

7 резисторов номиналом 220 Ом

9 проводов 

Схема на макетке

Скетч

#define FIRST_SEGMENT_PIN 2

#define SEGMENT_COUNT 7

// префикс «0b» означает, что целое число за ним записано в

// в двоичном коде. Единицами мы обозначим номера сегментов

// индикатора, которые должны быть включены для отображения

// арабской цифры. Всего цифр 10, поэтому в массиве 10 чисел.

// Нам достаточно всего байта (англ. byte, 8 бит) для хранения

// комбинации сегментов для каждой из цифр.

byte numberSegments[10] = {

0b00111111, 0b00001010, 0b01011101, 0b01011110, 0b01101010,

0b01110110, 0b01110111, 0b00011010, 0b01111111, 0b01111110,

};

void setup()

{

for (int i = 0; i < SEGMENT_COUNT; ++i)

pinMode(i + FIRST_SEGMENT_PIN, OUTPUT);

}

void loop()

{

// определяем число, которое собираемся отображать. Пусть им

// будет номер текущей секунды, зацикленный на десятке

int number = (millis() / 1000) % 10;

// получаем код, в котором зашифрована арабская цифра

int mask = numberSegments[number];

// для каждого из 7 сегментов индикатора...

for (int i = 0; i < SEGMENT_COUNT; ++i) {

// ...определяем: должен ли он быть включён. Для этого

// считываем бит (англ. read bit), соответствующий текущему

// сегменту «i». Истина — он установлен (1), ложь — нет (0)

boolean enableSegment = bitRead(mask, i);

// включаем/выключаем сегмент на основе полученного значения

digitalWrite(i + FIRST_SEGMENT_PIN, enableSegment);

}

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 тактовая кнопка

1 выходной сдвиговый регистр 74HC595

1 семисегментный индикатор

7 резисторов номиналом 220 Ом

24 провода 

Схема на макетке

Скетч

#define DATA_PIN 13 // пинданных (англ. data)

#define LATCH_PIN 12 // пинстроба (англ. latch)

#define CLOCK_PIN 11 // пинтакта (англ. clock)

#define BUTTON_PIN 10

int clicks = 0;

boolean buttonWasUp = true;

byte segments[10] = {

0b01111101, 0b00100100, 0b01111010, 0b01110110, 0b00100111,

0b01010111, 0b01011111, 0b01100100, 0b01111111, 0b01110111

};

void setup()

{

pinMode(DATA_PIN, OUTPUT);

pinMode(CLOCK_PIN, OUTPUT);

pinMode(LATCH_PIN, OUTPUT);

pinMode(BUTTON_PIN, INPUT_PULLUP);

}

 void loop()

{

// считаем клики кнопки, как уже делали это раньше

if (buttonWasUp && !digitalRead(BUTTON_PIN)) {

delay(10);

if (!digitalRead(BUTTON_PIN))

clicks = (clicks + 1) % 10;

}

buttonWasUp = digitalRead(BUTTON_PIN);

// для записи в 74HC595 нужно притянуть пин строба к земле

digitalWrite(LATCH_PIN, LOW);

// задвигаем (англ. shift out) байт-маску бит за битом,

//начинаясмладшего (англ. Least Significant Bit first)

shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, segments[clicks]);

// чтобы переданный байт отразился на выходах Qx, нужно

// подать на пин строба высокий сигнал

digitalWrite(LATCH_PIN, HIGH);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиодная шкала

1 резистор номиналом 10 кОм

1 термистор

10 резисторов номиналом 220 Ом

14 проводов 

Схема на макетке

Скетч

// Огромное количество готового кода уже написано другими людьми

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

// библиотеками. Для использования кода из библиотеки, её нужно

// подключить (англ. include). Библиотека «math» даёт разные

// математические функции, в том числе функцию логарифма

// (англ. log), которая нам понадобится далее

#include <math.h>

#define FIRST_LED_PIN 2

#define LED_COUNT 10

// Параметр конкретного типа термистора (из datasheet):

#define TERMIST_B 4300

#define VIN 5.0

 void setup()

{

for (int i = 0; i < LED_COUNT; ++i)

pinMode(i + FIRST_LED_PIN, OUTPUT);

}

 void loop()

{

// вычисляем температуру в °С с помощью магической формулы.

// Используем при этом не целые числа, а вещественные. Их ещё

// называют числами с плавающей (англ. float) точкой. В

// выражениях с вещественными числами обязательно нужно явно

// указывать дробную часть у всех констант. Иначе дробная

// часть результата будет отброшена

float voltage = analogRead(A0) * VIN / 1023.0;

float r1 = voltage / (VIN - voltage);

float temperature = 1./( 1./(TERMIST_B)*log(r1)+1./(25. + 273.) ) - 273;

for (int i = 0; i < LED_COUNT; ++i) {

// при 21°С должен гореть один сегмент, при 22°С — два и

// т.д. Определяем должен ли гореть i-й нехитрым способом

boolean enableSegment = (temperature >= 21+i);

digitalWrite(i + FIRST_LED_PIN, enableSegment);

}

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 резистор номиналом 10 кОм

1 термистор

3 провода

Схема на макетке

Скетч

#include <math.h>

int minute = 1;

// Параметр конкретного типа термистора (из datasheet):

#define TERMIST_B 4300

#define VIN 5.0

void setup()

{

Serial.begin(9600);

Serial.println("Minute\tTemperature");

}

void loop()

{

float voltage = analogRead(A0) * VIN / 1024.0;

float r1 = voltage / (VIN - voltage);

float temperature = 1./( 1./(TERMIST_B)*log(r1)+1./(25. + 273.) ) - 273;

// печатаем текущую минуту и температуру, разделяя их табом.

// println переводит курсор на новую строку, а print — нет

Serial.print(minute);

Serial.print("\t");

Serial.println(temperature);

delay(60000); // засыпаемнаминуту

++minute; // увеличиваем значение минуты на 1

// откройте окно Serial Monitor в среде Arduino, оставьте на

// сутки, скопируйте данные в Excel, чтобы построить графики

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 сервопривод

1 конденсатор емкостью 220 мкФ

1 потенциометр

11 проводов

Схема на макетке

Скетч

#include <Servo.h>

#define POT_MAX_ANGLE 270.0 // макс. угол поворота потенциометра

// объявляем объект типа Servo с именем myServo. Ранее мы

// использовали int, boolean, float, а теперь точно также

// используем тип Servo, предоставляемый библиотекой. В случае

// Serial мы использовали объект сразу же: он уже был создан

// для нас, но в случае с Servo, мы должны сделать это явно.

// Ведь в нашем проекте могут быть одновременно несколько

// приводов, и нам понадобится различать их по именам

Servo myServo;

void setup()

{

// прикрепляем (англ. attach) нашу серву к 9-му пину. Явный

// вызов pinMode не нужен: функция attach сделает всё за нас

myServo.attach(9);

}

void loop()

{

int val = analogRead(A0);

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

// Используем вещественные числа в расчётах, но полученный

// результат округляем обратно до целого числа

int angle = int(val / 1024.0 * POT_MAX_ANGLE);

// обычная серва не сможет повторить угол потенциометра на

// всём диапазоне углов. Она умеет вставать в углы от 0° до

// 180°. Ограничиваем угол соответствующе

angle = constrain(angle, 0, 180);

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

myServo.write(angle);

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

2 резистора номиналом 10 кОм

1 выпрямительный диод

1 текстовый экран

16 проводов 1 клеммник

Схема на макетке

Скетч

// экраном (англ. Liquid Crystal Display или просто LCD)

#include <LiquidCrystal.h>

// на диоде, защищающем от неверной полярности, падает доля

// напряжения (англ. voltage drop). Необходимо это учитывать

#define DIODE_DROP 0.7

// Объявляем объект, для управления дисплеем. Для его создания

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

// порядке: RS E DB4 DB5 DB6 DB7

LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

void setup()

{

// начинаем работу с экраном. Сообщаем объекту количество

// строк и столбцов. Опять же, вызывать pinMode не требуется:

// функция begin сделает всё за нас

lcd.begin(16, 2);

// печатаем сообщение на первой строке

lcd.print("Battery voltage:");

}

 void loop()

{

// высчитываем напряжение подключенной батарейки

float voltage = analogRead(A0) / 1024.0 * 10.0;

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

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

if (voltage > 0.1)

voltage += DIODE_DROP;

// устанавливаем курсор, колонку 0, строку 1. На деле — это

// левый квадрат 2-й строки, т.к. нумерация начинается с нуля

lcd.setCursor(0, 1);

// печатаем напряжение в батарейке с точностью до сотых долей

lcd.print(voltage, 2);

// следом печатаем единицы измерения

lcd.print(" Volts");

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиод

1 резистор номиналом 220 Ом

2 провода 

Схема на макетке

Скетч

#define LED_PIN 9

// для работы с текстом существуют объекты-строки (англ. string)

String message;

void setup()

{

pinMode(LED_PIN, OUTPUT);

Serial.begin(9600);

}

void loop()

{

while (Serial.available()) {

// считываем (англ. read) пришедший символ в переменную

char incomingChar = Serial.read();

// не стоит путать целые числа и символы. Они соотносятся

// друг с другом по таблице, называемой кодировкой. Например

// '0' — это 48, '9' — 57, 'A' — 65, 'B' — 66 и т.п. Символы

// в программе записываются в одинарных кавычках

if (incomingChar >= '0' && incomingChar <= '9') {

// если пришёл символ-цифра, добавляем его к сообщению

message += incomingChar;

} else if (incomingChar == '\n') {

// если пришёл символ новой строки, т.е. enter, переводим

// накопленное сообщение в целое число (англ. to integer).

// Так последовательность символов '1', '2', '3' станет

// числом 123. Результат выводим на светодиод

analogWrite(LED_PIN, message.toInt());

// обнуляем накопленное сообщение, чтобы начать всё заново

message = "";

}

}

// посылайте сообщения-числа с компьютера через Serial Monitor

}

Список деталей для эксперимента

1 плата Arduino Uno

1 беспаечная макетная плата

1 светодиодная шкала

10 резисторов номиналом 220 Ом

4 резисторов номиналом 100 кОм

2 тактовых кнопки

2 керамических конденсатора номиналом 100 нФ

1 пьезопищалка

1 инвертирующий триггер Шмитта

24 провода 

Схема на макетке

Скетч

#define BUZZER_PIN 0

#define FIRST_BAR_PIN 4

#define BAR_COUNT 10

#define MAX_SCORE 20

// глобальные переменные, используемые в прерываниях (см. далее)

// должны быть отмечены как нестабильные (англ. volatile)

volatile int score = 0;

void setup()

{

for (int i = 0; i < BAR_COUNT; ++i)

pinMode(i + FIRST_BAR_PIN, OUTPUT);

pinMode(BUZZER_PIN, OUTPUT);

attachInterrupt(INT1, pushP1, FALLING); // INT1 — это 3-йпин

attachInterrupt(INT0, pushP2, FALLING); // INT0 — это 2-йпин

}

void pushP1() { ++score; } // функция-прерывание 1-го игрока

void pushP2() { --score; } // функция-прерывание 2-го игрока

void loop()

{

tone(BUZZER_PIN, 2000, 1000); // даём сигнал к старту.

// пока никто из игроков не выиграл, обновляем «канат»

while (abs(score) < MAX_SCORE) {

int bound = map(score, -MAX_SCORE, MAX_SCORE, 0, BAR_COUNT);

int left = min(bound, BAR_COUNT / 2 - 1);

int right = max(bound, BAR_COUNT / 2);

for (int i = 0; i < BAR_COUNT; ++i)

digitalWrite(i + FIRST_BAR_PIN, i >= left && i <= right);

}

tone(BUZZER_PIN, 4000, 1000); // даёмсигналпобеды

while (true) {} // «подвешиваем» плату до перезагрузки

}