Arduino.ru

Хамить не надо, это лишний раз показывает Ваш богатый внутренний мир.

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

Ну попытка была, сделать целочисленную переменную  и присвоить ей значение с числом обозначающим нужный бит порта, все равно не пошло.

 

Так нарисуйте класс ПИН ОУТ,воткните  и все.

Ну как бы класс создал, даже чункцию всунул, не знаю надо ли она там вообще...

class PinMode{
	public:
		byte pB0,pB1,pB2,pD2,pD3,pD4,pD5,pD6;
	void init(){
		pB0=0x1;
		pB1=0x2;
		pB2=0x4;
		pD2=0x4;
		pD3=0x8;
		pD4=0x10;
		pD5=0x20;
		pD6=0x40;
	}};

Как теперь к нему обратится чтобы оно друг друга понимало и как вместо  "2" вписать pB2?

 

Дурдом! Квон попал!

Точно.

/**/
class Cl_pin {
  protected:
    volatile uint8_t *reg;
    volatile uint8_t *out;
    volatile uint8_t *in;
    byte bit;/*поз бита*/
  public:
    /*конструктор*/
    Cl_pin() {}
    /*регистр на ввод*/
    void input() {}
    /*регистр на вsвод*/
    void output() {}
    /*прочитать*/
    bool read() {
      return 0;
    }
    /*записать*/
    void write(bool data) {}
};
//-----Компоновка----------------------------
Cl_pin PIN2;/*пин 2*/
//----main----------------------------
void setup() {

}

void loop() {

}

 

Никто никуда не попал. Мне тяжко дается эта тема с классами и бъектами, я уже кучу видео и статей пересмотрел. Не могу понять толком, как это работает. Тугодумов и умалишенных здесь нету. У товарища подход не как для новичков, я в эти классы туплю и нихера не понимаю))) Буду разбиратся.

Это, я полагаю, мне. Тогда отвечу - да, с внутренним миром у меня всё в порядке, спс. Ну а ты - выглядишь вполне себе долбаном, взявшим код qwone (т.е. просто скопипастивший его, читать, что такое копипаст), и дополнивший его всякой чушью, пытаясь сделать поставленную задачу на "авось, заработает", при этом не сделав ни малейших усилий по прочтению информации по работе с портами МК AVR - и при этом всём ещё гонорящийся, вместо того, чтобы УЧИТЬСЯ, чего от тебя, долбана, и добивается мудрый препод.

Не нравится слово долбан, долбан? Ну так это моё оценочное суждение текущего "поколения Пепси" - вы там на 90% долбаны по определению.

Твой диагноз ясен - воинствующий неуч. Дитё, ты хоть в гугле по ключевым словам, которые я дал, был? Видел там ПЕРВУЮ СТАТЬЮ В ВЫДАЧЕ? Читал? Что непонятного там? Ты пытался отвлечься от твоей конкретной задачи и просто поработать с каким-либо портом, переводя его на запись, записывая в нужный его бит состояние, переводя на чтение, читая из нужного бита состояние? Ну там ведь строчек - ну пяток, не бином Ньютона, млять. Нет - ты не пытался сделать ни-хе-ра. Ты пишешь дичь, не понимаешь, почему ты пишешь дичь, ноешь, что ты написал дичь и эта дичь не работает, тебе дают ответ, что ты не знаешь основ и предлагают почитать статьи про эти самые основы, а виноват при этом оказываюсь я. Охренеть у тебя логика, я же говорю - долбан.

И классы тут не при чём - всё можно сделать и без классов. Тебе привести код из статей в интернете? Херушки, оторви свою жопу от танчиков и займись делом, а не клянчи тут.

Да, жёстко. Зато по делу.

Зачем так напрягатся? Я должен как то реагировать на эту простыню? Хотя бы возрастом по интересовались, перед тем как позорится. По поводу "дитё", угомоните свое любопытство ибо своих уже двое. Какое пепси, я такую гадость не употребляю, разве что в авто, систему ОЖ помыть. Что значит ваше:  "переводя его на запись, записывая в нужный его бит состояние, переводя на чтение, читая из нужного бита состояние"?  Что то со знаками препинания не так, каша, но никак не адекватное выражение мыслей. От Вас мне ничего не надо, успокойте свою не востребованность.

У каждого МК есть регистры бита порта. У AVR регистр направления работы порта(DDRx), регистр установки состояния его(PORTx) и чтения(PINx), независимо от установленного режима(вход или выход). На сколько я понимаю состояние прочитанное из PINx можно сохранить в переменную и с ней потом работать. Если я не понимаю до конца как работают классы и объекты это не значит что я неук и как вы там выразились еще, уже забыл. Ни у кого ничего не клянчил и не просил, товарищ по доброте душевной пояснить хотел и на сколько я смог понять я усвоил на данный момент. Дальше если осилю, пойму и это будет только плюс.

 

Долбан, это называется сложносоставное предложение, и со знаками препинания там всё норм.

какое то пустозвонство. Покажи как без классов решить задачу, работая на прямую с регистрами портов или слабо?

Ты меня на слабо что ли решил взять? Не, вьюноша, не прокатит, звиняй. Можешь записать меня хоть под каким артикулом, но я тебе реально говорю: там кода - несколько строк, если тебя ломает поискать в гугле и почитать статьи - ты тупая ленивая жопа. За тебя я эту работу делать не намерен, ибо я всё-таки верю в то, что и зайца можно научить курить. Вот если ты признаешься, что ты тупая ленивая жопа, которая вместо того, чтобы прочитать ОДНУ статью, клянчит кусочек готового кода на несколько строк - так и быть, я тебе напишу. Но не раньше.

Цени, какой я добрый - я даже за тебя в гугле вбил поисковую фразу и дарю тебе чудесную статью: http://easyelectronics.ru/avr-uchebnyj-kurs-ustrojstvo-i-rabota-portov-vvoda-vyvoda.html

И вторую - тоже дарю, т.е. бэзвозмэздно, т.е. даром: http://easyelectronics.ru/rabota-s-portami-vvoda-vyvoda-mikrokontrollerov-na-si.html

И третью - дарю, в честь наступающего: https://myrobot.ru/stepbystep/pr_mcports.php

В последних двух статьях есть код, можешь проверить моё высказывание относительно "несколько строчек".

 

Старый пердун спалился вконец. Так откопай пулемет и с окна даффай по прохожим, очисть мир от пепси ради кваса ;) 

pdjboy, не обращайте внимания, на форуме есть несколько учителей из числа  "неумееш сам-учи других". Им творческая импотенция так в голову давит, что крышу сносит.  Учить ООП Вам пока безсмысленая трата времени, не партесь этим, учитесь писать просто код на просто Си.  И начинать с дописывания своего в готовый код - не самое пустое дело. Весьма эффективно.

 

Женская логика - иди нахер, только тебя не хватало, ещё один неадекват в комплект к ТС - это уже перебор. Ты уже везде, где только можно, обдристался - что, ещё и здесь своё ЧСВ решил почесать? Не чеши - отвалится, а оно и так у тебя, сам понимаешь, девчачье. 

Вот смотрите.

/**/
class Cl_pin {
  protected:
    volatile uint8_t *reg;
    volatile uint8_t *out;
    volatile uint8_t *in;
    byte bit_;/*поз бита*/
  public:
    /*конструктор*/
    Cl_pin(uint8_t *r, uint8_t *o, uint8_t *i, byte b)
      : reg(r), out(o), in(i), bit_(b) {}
    /*регистр на ввод*/
    void input() {
      *reg &= ~(0x01 << bit_);
      *in  != ~(0x01 << bit_);
    }
    /*регистр на ввод c подтяжкой*/
    void inputPullup() {
      *reg &= ~(0x01 << bit_);
      *in  |= (0x01 << bit_);
    }
    /*регистр на вывод*/
    void output() {
      *reg |= 0x01 << bit_;
    }
    /*прочитать*/
    bool read() {
      return !!(*in & (0x01 << bit_));
    }
    /*записать*/
    void write(bool data) {
      if (!!data) *out |= 1 << bit_;
      else *out &= ~( 1 << bit_);
    }
};
//-----Компоновка----------------------------
//Cl_pin pin0(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/0);/*пин 0*/
//Cl_pin pin1(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/1);/*пин 1*/
Cl_pin pin2(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/2);/*пин 2*/
//Cl_pin pin3(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/3);/*пин 3*/
//Cl_pin pin4(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/4);/*пин 4*/
//Cl_pin pin5(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/5);/*пин 5*/
//Cl_pin pin6(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/6);/*пин 6*/
//Cl_pin pin7(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/7);/*пин 7*/
//
//Cl_pin pin8(/* устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/0);/*пин 8*/
//Cl_pin pin9(/* устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/1);/*пин 9*/
//Cl_pin pin10(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/2);/*пин 10*/
//Cl_pin pin11(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/3);/*пин 11*/
//Cl_pin pin12(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/4);/*пин 12*/
Cl_pin pin13(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/5);/*пин 13*/

//Cl_pin pinA0(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/0);/*пин A0*/
//Cl_pin pinA1(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/1);/*пин A1*/
//Cl_pin pinA2(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/2);/*пин A2*/
//Cl_pin pinA3(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/3);/*пин A3*/
//Cl_pin pinA4(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/4);/*пин A4*/
//Cl_pin pinA5(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/5);/*пин A5*/
//Cl_pin pinA6(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/6);/*пин A6*/
//Cl_pin pinA7(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/7);/*пин A7*/
//----main----------------------------
void setup() {
  pin2.inputPullup();
  pin13.output();
}

void loop() {
  delay (100);
  pin13.write(pin2.read());
}

И 2 .

/**/
class Cl_pin {
  protected:
    volatile uint8_t *reg;
    volatile uint8_t *out;
    volatile uint8_t *in;
    byte bit_;/*поз бита*/
  public:
    /*конструктор*/
    Cl_pin(uint8_t *r, uint8_t *o, uint8_t *i, byte b)
      : reg(r), out(o), in(i), bit_(b) {}
    /*регистр на ввод*/
    void input() {
      *reg &= ~(0x01 << bit_);
      *in  != ~(0x01 << bit_);
    }
    /*регистр на ввод c подтяжкой*/
    void inputPullup() {
      *reg &= ~(0x01 << bit_);
      *in  |= (0x01 << bit_);
    }
    /*регистр на вывод*/
    void output() {
      *reg |= 0x01 << bit_;
    }
    /*прочитать*/
    bool read() {
      return !!(*in & (0x01 << bit_));
    }
    /*записать*/
    void write(bool data) {
      if (!!data) *out |= 1 << bit_;
      else *out &= ~( 1 << bit_);
    }
};
//-----Компоновка----------------------------
//Cl_pin pin0(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/0);/*пин 0*/
//Cl_pin pin1(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/1);/*пин 1*/
//Cl_pin pin2(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/2);/*пин 2*/
//Cl_pin pin3(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/3);/*пин 3*/
//Cl_pin pin4(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/4);/*пин 4*/
//Cl_pin pin5(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/5);/*пин 5*/
//Cl_pin pin6(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/6);/*пин 6*/
//Cl_pin pin7(/*устанв*/&DDRD,/*вивод*/&PORTD,/*ввод*/&PIND,/*бит*/7);/*пин 7*/
//
//Cl_pin pin8(/* устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/0);/*пин 8*/
//Cl_pin pin9(/* устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/1);/*пин 9*/
//Cl_pin pin10(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/2);/*пин 10*/
//Cl_pin pin11(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/3);/*пин 11*/
//Cl_pin pin12(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/4);/*пин 12*/
Cl_pin pin13(/*устанв*/&DDRB,/*вивод*/&PORTB,/*ввод*/&PINB,/*бит*/5);/*пин 13*/

//Cl_pin pinA0(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/0);/*пин A0*/
//Cl_pin pinA1(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/1);/*пин A1*/
//Cl_pin pinA2(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/2);/*пин A2*/
//Cl_pin pinA3(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/3);/*пин A3*/
//Cl_pin pinA4(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/4);/*пин A4*/
//Cl_pin pinA5(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/5);/*пин A5*/
//Cl_pin pinA6(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/6);/*пин A6*/
//Cl_pin pinA7(/*устанв*/&DDRC,/*вивод*/&PORTC,/*ввод*/&PINC,/*бит*/7);/*пин A7*/
//----main----------------------------
void setup() {
  pin13.output();
}

void loop() {
  pin13.write(0);
  delay (1000);
  pin13.write(1);
  delay (1000);

}

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

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

Пацан сказал - пацан сделал. Надеюсь, что от твоего гнилого ЧСВ сюда не поступит ни одного высера. Читай, тебе полезно.

Правка: ах да, забыл, ты ж не сдержишь слово. Пацан бы сдержал, а твоё девчачье - не сможет, вы же, бабы, не умеете в обещания и секреты :)

это дерьмо я еще месяц назад читал, что тыт тут так щедро даришь.

подобного в сети валом, нового ты ничего не показал.

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

Я, тупая ленивая жопа, которая вместо того, чтобы прочитать ОДНУ статью, клянчит кусочек готового кода на несколько строк. О, великий DIYMan, помоги! Не дай помереть смертью страшной от не знания примудростей написания кода. 

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

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

Написал раз класс , проверил в работе и пользуйся. Библиотеки они тоже как классы , как правило написаны. Просто на глазах нет , то нет и проблем. Не нравится с классом вот файл из среды Ардуино. 

/*
  wiring_digital.c - digital input and output functions
  Part of Arduino - http://www.arduino.cc/

  Copyright (c) 2005-2006 David A. Mellis

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA

  Modified 28 September 2010 by Mark Sproul
*/

#define ARDUINO_MAIN
#include "wiring_private.h"
#include "pins_arduino.h"

void pinMode(uint8_t pin, uint8_t mode)
{
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
	volatile uint8_t *reg, *out;

	if (port == NOT_A_PIN) return;

	// JWS: can I let the optimizer do this?
	reg = portModeRegister(port);
	out = portOutputRegister(port);

	if (mode == INPUT) { 
		uint8_t oldSREG = SREG;
                cli();
		*reg &= ~bit;
		*out &= ~bit;
		SREG = oldSREG;
	} else if (mode == INPUT_PULLUP) {
		uint8_t oldSREG = SREG;
                cli();
		*reg &= ~bit;
		*out |= bit;
		SREG = oldSREG;
	} else {
		uint8_t oldSREG = SREG;
                cli();
		*reg |= bit;
		SREG = oldSREG;
	}
}

// Forcing this inline keeps the callers from having to push their own stuff
// on the stack. It is a good performance win and only takes 1 more byte per
// user than calling. (It will take more bytes on the 168.)
//
// But shouldn't this be moved into pinMode? Seems silly to check and do on
// each digitalread or write.
//
// Mark Sproul:
// - Removed inline. Save 170 bytes on atmega1280
// - changed to a switch statment; added 32 bytes but much easier to read and maintain.
// - Added more #ifdefs, now compiles for atmega645
//
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
//static inline void turnOffPWM(uint8_t timer)
static void turnOffPWM(uint8_t timer)
{
	switch (timer)
	{
		#if defined(TCCR1A) && defined(COM1A1)
		case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
		#endif
		#if defined(TCCR1A) && defined(COM1B1)
		case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
		#endif
		#if defined(TCCR1A) && defined(COM1C1)
		case TIMER1C:   cbi(TCCR1A, COM1C1);    break;
		#endif
		
		#if defined(TCCR2) && defined(COM21)
		case  TIMER2:   cbi(TCCR2, COM21);      break;
		#endif
		
		#if defined(TCCR0A) && defined(COM0A1)
		case  TIMER0A:  cbi(TCCR0A, COM0A1);    break;
		#endif
		
		#if defined(TCCR0A) && defined(COM0B1)
		case  TIMER0B:  cbi(TCCR0A, COM0B1);    break;
		#endif
		#if defined(TCCR2A) && defined(COM2A1)
		case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
		#endif
		#if defined(TCCR2A) && defined(COM2B1)
		case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
		#endif
		
		#if defined(TCCR3A) && defined(COM3A1)
		case  TIMER3A:  cbi(TCCR3A, COM3A1);    break;
		#endif
		#if defined(TCCR3A) && defined(COM3B1)
		case  TIMER3B:  cbi(TCCR3A, COM3B1);    break;
		#endif
		#if defined(TCCR3A) && defined(COM3C1)
		case  TIMER3C:  cbi(TCCR3A, COM3C1);    break;
		#endif

		#if defined(TCCR4A) && defined(COM4A1)
		case  TIMER4A:  cbi(TCCR4A, COM4A1);    break;
		#endif					
		#if defined(TCCR4A) && defined(COM4B1)
		case  TIMER4B:  cbi(TCCR4A, COM4B1);    break;
		#endif
		#if defined(TCCR4A) && defined(COM4C1)
		case  TIMER4C:  cbi(TCCR4A, COM4C1);    break;
		#endif			
		#if defined(TCCR4C) && defined(COM4D1)
		case TIMER4D:	cbi(TCCR4C, COM4D1);	break;
		#endif			
			
		#if defined(TCCR5A)
		case  TIMER5A:  cbi(TCCR5A, COM5A1);    break;
		case  TIMER5B:  cbi(TCCR5A, COM5B1);    break;
		case  TIMER5C:  cbi(TCCR5A, COM5C1);    break;
		#endif
	}
}

void digitalWrite(uint8_t pin, uint8_t val)
{
	uint8_t timer = digitalPinToTimer(pin);
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
	volatile uint8_t *out;

	if (port == NOT_A_PIN) return;

	// If the pin that support PWM output, we need to turn it off
	// before doing a digital write.
	if (timer != NOT_ON_TIMER) turnOffPWM(timer);

	out = portOutputRegister(port);

	uint8_t oldSREG = SREG;
	cli();

	if (val == LOW) {
		*out &= ~bit;
	} else {
		*out |= bit;
	}

	SREG = oldSREG;
}

int digitalRead(uint8_t pin)
{
	uint8_t timer = digitalPinToTimer(pin);
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);

	if (port == NOT_A_PIN) return LOW;

	// If the pin that support PWM output, we need to turn it off
	// before getting a digital reading.
	if (timer != NOT_ON_TIMER) turnOffPWM(timer);

	if (*portInputRegister(port) & bit) return HIGH;
	return LOW;
}

Пользуйтесь, ни в чем себе не отказывайте.

Это Вам так кажется.

 

Ок, падаван, принимается - осознание своего несовершенства есть путь к внутреннему развитию. Мне только странно, что ты называешь хорошие статьи дерьмом, ибо там как раз показано, как общаться с регистрами портов. Ну вот ведь прям как на ладони там всё прям. Но я тебе приведу кусок кода, так и быть. Смотри - весь порт B сконфигурирован на выход:

DDRB = 0xFF;

Смотри - весь порт B сконфигурирован на вход:

DDRB = 0;

Смотри - пин PB0 порта B сконфигурирован на выход:

DDRB = 1;

Смотри - пины PB0 и PB2 сконфигурированы на выход:

DDRB = 1 | (1 << 2);

Теперь читаем из порта B:

byte portBStatus = PINB;

Там состояние всех пинов порта. Надо прочитать отдельный пин? Да пож:

bool isPB2On = PINB & (1 << 2); // прочитали состояние PB2

Записать в порт? Аналогично - формируешь байт - и пишешь. Или просто - побитово манипулируешь:

PORTB |= (1 << 2); // PB2 в единичку
PORTB &= ~(1 << 2); // Сбросить PB2 в нолик

Что из этого требует наличия классов, раз ты так к этому слову прицепился?

Не думал, что Вас можно на слабо взять.

А вот это вопрос философский, его лучше Квону задавать. По мне так, если не используется наследование, то ничего не требует, но у него другое мнение :)

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

 

  DDRB = 0xFF;                      //весь порт "В" выход
  PORTB = 0x00;                     //в весь порт "В" записали "0"
  DDRC = 0x00;                      //весь порт "С" как вход
  PORTC = 0xFF;                     //порт "С" в режиме INPUT_PULLUP
  DDRD = 0x00;                      //весь порт "D" как вход
  PORTD = 0xFF;                     //порт "D" в режиме INPUT_PULLUP

 void stand(byte state_) {
      state = state_;
      past = mill;
      switch (state) {
        case 0:
           PORTB = 0x1;                 //Motor ON
          Serial.println("Motor ON");
          break;
        case 1:
           PORTB = 0x00;                //Motor OFF
          Serial.println("Motor OFF");
          break;
        case 2:
          PORTB = 0x2;                  //Lock ON
          Serial.println("Lock ON");
          break;
        case 3:
          PORTB = 0x6;                  //Pull ON
          Serial.println("Pull ON");
          break;
        case 4:
          PORTB = 0x02;                 //Pull OFF
          Serial.println("Pull OFF");
          break;
        case 5:
          PORTB = 0x00;                 //Lock OFF
          Serial.println("Lock OFF");
          break;
        default:
          PORTB = 0x00;                 //Motor OFF
          Serial.println("Motor OFF");
      }
    }

 

Используй битовые операции, Luke!!!

Это что то типа такого?

DDRD |= 1<<2;   //просто записали логическое "1" в бит "2", порта "D".

bool i;

DDRD |= i<<2;   // записали содержимое переменной "i" в бит "2", порта "D".

 

Класс счетчика поддался и работает без ардуиновского digitalRead(pin);

class Cl_Check {

  protected:
    byte pin;                                //<-- это переменая ноги
    pDo Do;                                  //<-- это ее обработчик
    bool val, oldVal;
    byte num = 0, maxNum = 5;
 
  public:    
    Cl_Check(byte pin_, pDo Do_): pin(pin_), Do(Do_) {}
    
    void init() {

      DDRD = 0x40;                              //PD6 INPUT
      PORTD = 0x40;                             //INPUT_PULLUP

      oldVal = ~PIND&0x40;      
    }
    
    void run() {
      val = ~PIND&0x40;
      if (val && !oldVal) {                      // count^\_
        oldVal = val;
        ++num;
        Serial.println(num);
        if (num >= maxNum) {                     // count max
          num = 0; Do();
        }
      }
      if (!val && oldVal) {                      // count _/^
        oldVal = val;
      }
    }

А вот с кнпопками не получается.

class Cl_Btn {
  protected:
    byte pin; 								// переменая ноги
    pDo Do;							        // ее обработчик
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    
    Cl_Btn(byte pin_, pDo Do_)
      : pin(pin_), Do(Do_) {}
    
    void init() {
    	DDRD = 0xFC;                                                   //PD2,PD3,PD4,PD5 INPUT
    	PORTD = 0xFC;                                                  //INPUT_PULLUP

    }
    
    void run() {

      bool newBtn;

      newBtn = digitalRead(pin);                                       //от этого избавится бы

      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) Do();
      }
    }
};

 

DDRD |= 1<<2;   //просто записали логическое "1" в бит "2", порта "D".

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

bool i;

DDRD |= i<<2;   // записали содержимое переменной "i" в бит "2", порта "D".

А вот нулики так писать не получится, это операция ИЛИ. 

 

 

Коллеги, ну нафига вы этому инвалиду на голову помогаете?

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

Мое глубокое убеждение - лентяи и тупицы ДОЛЖНЫ ЖИТЬ ТРУДНО И ПЛОХО. Только так можно заставить их учиться.

Товарищ самоидентифицировался, как я и просил - в ответ я выполнил договорённость, "слабо" тут не при чём :)

Это не более чем случайность. Код такой же неверный, как и с кнопками.

Диагноз - "вы основ не знаете" - как правильно обращаться с регистрами.

доктор, может поясните почему не правильно? или просто потому что Вы так это видите? Не было бы правильно не работало бы. Вы тут все друг на друга гоните что не правильно, не так, каряво. Так покажи как надо, это не "слабо", это не пострекание, просто не надо пустословить и сыпать гениальные высказывания перед такими неуками как я. знаешь как, покажи принцип, структуру. Не сможешь даже научить, иди дальше.

да какой смысл обьяснять мне, коли куда как более умные люди давно все описали в сотне учебников? Ты свой "очень простой проект" мучаешь уже третий мкесяц, а так и не нашел пару вечеров, чтоб книжку почитать. Вместо этого днями тут точишь, вытягиваешь код "на слабо", унижаешься. лишь бы получить готовенькое, а не головой поработать.

Или ты настолько непроходимо туп. что книжки не понимаешь? - тогда тем более просвещать тебя не моя работа. это дело специалистов другого профиля.

Адьос, амиго.

 

даже реагировать не буду на эти порванные пуканы.

Похоже никто не догадался как использовать класс Пин.Но скорее всего никому и не надо. Ладно вот мое решение. Правда не к задаче ТС. Хотя там просто разобраться и вставить. Вот к примеру исходный код.

//**/
unsigned long mill;// переменная для millis()
typedef void (*pDo)() ;// тип -функция обработчик
//------Cl_Led----------------------
// класс светодиод
class Cl_Led {
  protected:
    const byte pin;
    bool led;
    unsigned long past, time;
    byte state; //0 выкл/ 1 вкл / 2 мигать
    /*установить в состояние*/
    void stand(byte state_) {
      past = mill;
      state = state_;
      switch (state) {
        case 0: // выкл
          digitalWrite(pin, led = LOW);
          break;
        case 1: // вкл
          digitalWrite(pin, led = HIGH);
          break;
        case 2:// мигать
          digitalWrite(pin, led = !led);
          break;
        case 3:// короткое выключение
          digitalWrite(pin, led = LOW);
          break;
        case 4:// короткое включение
          digitalWrite(pin, led = HIGH);
          break;
      }
    }
  public:
    /*конструктор*/
    Cl_Led(byte pin_): pin(pin_) {}
    /*инициализация-вставить в setup()*/
    void init() {
      pinMode(pin, OUTPUT);
      OFF();
    }
    /*работа-вставить в loop()*/
    void run() {
      if (state == 2 && mill - past >= time)stand(2);
      if (state == 3 && mill - past >= time)stand(1);
      if (state == 4 && mill - past >= time)stand(0);
    }
    /*включить*/
    void ON() {
      stand(1);
    }
    /*коротко включить*/
    void ON(unsigned long time_) {
      time = time_;
      stand(4);
    }
    /*выключить*/
    void OFF() {
      stand(0);
    }
    /*коротко выключить*/
    void OFF(unsigned long time_) {
      time = time_;
      stand(3);
    }
    /*мигать*/
    void blink(unsigned long time_ = 200) {
      time = time_;
      stand(2);
    }
};
//------Cl_Btn----------------------
// класс кнопка
class Cl_Btn {
  protected:
    const byte pin;
    pDo Do;//обработчик
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    /*конструктор*/
    Cl_Btn(byte pin_, pDo Do_): pin(pin_), Do(Do_) {}
    /*инициализация-вставить в setup()*/
    void init() {
      pinMode(pin, INPUT_PULLUP);
    }
    /*работа-вставить в loop()*/
    void run() {
      bool newBtn = digitalRead(pin);
      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) Do();
      }
    }
};
//-----компоновка----------------------
Cl_Led Led(/*пин*/13);
void DoBtn1() {
  Led.ON(200);
  Serial.println("DoBtn1");
}
void DoBtn2() {
  Led.OFF(200);
  Serial.println("DoBtn2");
}
void DoBtn3() {
  Led.blink();
  Serial.println("DoBtn3");
}
Cl_Btn Btn1(/*пин*/2,/*обработчик*/DoBtn1);
Cl_Btn Btn2(/*пин*/3,/*обработчик*/DoBtn2);
Cl_Btn Btn3(/*пин*/4,/*обработчик*/DoBtn3);
//-----main----------------------
void setup() {
  Serial.begin(9600);
  Led.init();
  Btn1.init();
  Btn2.init();
  Btn3.init();
}
void loop() {
  mill = millis();
  Led.run();
  Btn1.run();
  Btn2.run();
  Btn3.run();
}

/*Скетч использует 2858 байт (9%) памяти устройства. Всего доступно 30720 байт.
  Глобальные переменные используют 251 байт (12%) динамической памяти, оставляя 1797 байт для локальных переменных. Максимум: 2048 байт.
*/

А вот результат замены на класс Пин.

//**/
unsigned long mill;// переменная для millis()
typedef void (*pDo)() ;// тип -функция обработчик
//------------------------------------------------
// класс Пин
class Cl_pin {
  protected:
    volatile uint8_t *reg;
    volatile uint8_t *out;
    volatile uint8_t *in;
    byte bit_;/*поз бита*/
  public:
    /*конструктор*/
    Cl_pin(uint8_t *r, uint8_t *o, uint8_t *i, byte b)
      : reg(r), out(o), in(i), bit_(b) {}
    /*регистр на ввод*/
    void input() {
      *reg &= ~(0x01 << bit_);
      *in  != ~(0x01 << bit_);
    }
    /*регистр на ввод c подтяжкой*/
    void inputPullup() {
      *reg &= ~(0x01 << bit_);
      *in  |= (0x01 << bit_);
    }
    /*регистр на вывод*/
    void output() {
      *reg |= 0x01 << bit_;
    }
    /*прочитать*/
    bool read() {
      return !!(*in & (0x01 << bit_));
    }
    /*записать*/
    void write(bool data) {
      if (!!data) *out |= 1 << bit_;
      else *out &= ~( 1 << bit_);
    }
};
//------Cl_Led----------------------
// класс светодиод
class Cl_Led {
  protected:
    Cl_pin &pin;
    bool led;
    unsigned long past, time;
    byte state; //0 выкл/ 1 вкл / 2 мигать
    /*установить в состояние*/
    void stand(byte state_) {
      past = mill;
      state = state_;
      switch (state) {
        case 0: // выкл
          pin.write(led = LOW);
          break;
        case 1: // вкл
          pin.write( led = HIGH);
          break;
        case 2:// мигать
          pin.write(led = !led);
          break;
        case 3:// короткое выключение
          pin.write(led = LOW);
          break;
        case 4:// короткое включение
          pin.write(led = HIGH);
          break;
      }
    }
  public:
    /*конструктор*/
    Cl_Led(Cl_pin &pin_): pin(pin_) {}
    /*инициализация-вставить в setup()*/
    void init() {
      pin.output();
      OFF();
    }
    /*работа-вставить в loop()*/
    void run() {
      if (state == 2 && mill - past >= time)stand(2);
      if (state == 3 && mill - past >= time)stand(1);
      if (state == 4 && mill - past >= time)stand(0);
    }
    /*включить*/
    void ON() {
      stand(1);
    }
    /*коротко включить*/
    void ON(unsigned long time_) {
      time = time_;
      stand(4);
    }
    /*выключить*/
    void OFF() {
      stand(0);
    }
    /*коротко выключить*/
    void OFF(unsigned long time_) {
      time = time_;
      stand(3);
    }
    /*мигать*/
    void blink(unsigned long time_ = 200) {
      time = time_;
      stand(2);
    }
};
//------Cl_Btn----------------------
// класс кнопка
class Cl_Btn {
  protected:
    Cl_pin &pin;
    pDo Do;//обработчик
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    /*конструктор*/
    Cl_Btn(Cl_pin &p, pDo Do_): pin(p), Do(Do_) {}
    /*инициализация-вставить в setup()*/
    void init() {
      pin.inputPullup();
    }
    /*работа-вставить в loop()*/
    void run() {
      bool newBtn = pin.read();
      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) Do();
      }
    }
};
//-----компоновка----------------------
Cl_pin pin2(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/2);/*пин 2*/
Cl_pin pin3(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/3);/*пин 3*/
Cl_pin pin4(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/4);/*пин 4*/
Cl_pin pin13(/*устанв*/&DDRB,/*вывод*/&PORTB,/*ввод*/&PINB,/*бит*/5);/*пин 13*/
Cl_Led Led(/*пин*/pin13);
void DoBtn1() {
  Led.ON(200);
  Serial.println("DoBtn1");
}
void DoBtn2() {
  Led.OFF(200);
  Serial.println("DoBtn2");
}
void DoBtn3() {
  Led.blink();
  Serial.println("DoBtn3");
}
Cl_Btn Btn1(/*пин*/pin2,/*обработчик*/DoBtn1);
Cl_Btn Btn2(/*пин*/pin3,/*обработчик*/DoBtn2);
Cl_Btn Btn3(/*пин*/pin4,/*обработчик*/DoBtn3);
//-----main----------------------
void setup() {
  Serial.begin(9600);
  Led.init();
  Btn1.init();
  Btn2.init();
  Btn3.init();
}
void loop() {
  mill = millis();
  Led.run();
  Btn1.run();
  Btn2.run();
  Btn3.run();
}

/*Скетч использует 2864 байт (9%) памяти устройства. Всего доступно 30720 байт.
  Глобальные переменные используют 283 байт (13%) динамической памяти, оставляя 1765 байт для локальных переменных. Максимум: 2048 байт.
*/

 

Квон, тебе уже пора "собрание сочинений" собрать где-нить в одном месте, а то неудобно по разным темам искать твое творчество. Я в пару своих проектов скопипастил твои классы, кстати :)

А вот здесь и есть самая фишка. Вот чел закончит универ, поступит на работу. и будет косить бабло. Но вспомним у нас капитализм. А это значит что наличие бумажки (диплома) не обеспечивает работу. Опять же наличие бумажки не выполняет работу автоматически. Можете хоть 10 дипломов сложить в стопочку, но работать придется вам ручками. И если провтыкал в универе, то врят ли зацепится на работе по специальности или почти по специальности , или около далеко специальности. И если там будет работа по специальности, то он будет ЖИТЬ ТРУДНО И ПЛОХО. Потому что на работе балласт работает балластом. А если фирма наберет балласт, то надо его ипользовать или избавляться. Иначе вся фирма пойдет на дно. И балласту надо искать новую работу, но уже без диплома. Потому что при отсутсвии наработаных знаний и навыков диплом это бумажка, а учеба в универе это просраное время и деньги.Образование уже далеко не на шару.

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

Так что корреляция между полученными научными знаниями и умением устроиться в этой жизни вовсе не очевидна, как представляется.

Я не очень в курсе американских законов, но с точки зрения обычного здравого смысла ничего неправильного в этом случае не вижу. Зависит, конечно, от содержания договора этого работника с компанией, но что плохого, если он за свои деньги нанимал сторонних исполнителей для выполнения работы? Если он сам лично проверял их код и готов отвечать за его качество - вай нот?

 

Программирование не наука, а чистая практика. А для того что бы из программирования качать деньги надо знать не только программирование(10%) а все остальное(90%). Все строится на бизнесс проектах Некая сумма+некое время=результат. Просрал деньги время и нет результата. До свидание. Можно использовать хоть индийских программистов, но если вам не дадут вовремя и нужный результат, то вы пролетели как фанера над Манхеттеном.

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

Просрал 40% денег, 50% откатил, 10% тыранул, результата нет, но бизнес идет. Знакомо?

Вы этот бред афоризм сами придумали, или подсказал кто?

Жизнь куда как сложнее Ваших примитивных теоретических выкладок. Вы, например, знаете такой Первый закон Скотта? Он начисто опровергет процитированный мною тезис.

Жизнь подсказала. Можно сколько угодно болтать о науке. Но код придется набирать ручками, и думать головой и по конкретной задаче. 

Да, разумеется. Видал я таких набирателей. Как-то на спор тиснул на одном фрилансерском сайте задание: 

Привёл web-страницу, на которой было окошко для ввода скрипта юзером (JScript ), который потом исполнянлся, и сказал, что тупые юзера часто вводят скрипт, который зацикливается, а потом жалуются, что страница подвисла. Задание было - разработать на том же JScript проверяльщик, который проверял бы юзеровский скрипт на зацикливание перед тем, как исполнять.

Поступило более 10 (не помню, 12-16) предложений сделать такой проверяльщик по цене от $100 до $2000. Видать, тоже от "чистых практиков".

------------

Набиратель кода и программист - это разные вещи. Тут многие этого не понимают.

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

Заключительный код. Компилируется. Не проверял.

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)(); // тип - функция обработчик
//------------------------------------------------
// класс Пин
class Cl_pin {
  protected:
    volatile uint8_t *reg;
    volatile uint8_t *out;
    volatile uint8_t *in;
    byte bit_;/*поз бита*/
  public:
    /*конструктор*/
    Cl_pin(uint8_t *r, uint8_t *o, uint8_t *i, byte b)
      : reg(r), out(o), in(i), bit_(b) {}
    /*регистр на ввод*/
    void input() {
      *reg &= ~(0x01 << bit_);
      *in  != ~(0x01 << bit_);
    }
    /*регистр на ввод c подтяжкой*/
    void inputPullup() {
      *reg &= ~(0x01 << bit_);
      *in  |= (0x01 << bit_);
    }
    /*регистр на вывод*/
    void output() {
      *reg |= 0x01 << bit_;
    }
    /*прочитать*/
    bool read() {
      return !!(*in & (0x01 << bit_));
    }
    /*записать*/
    void write(bool data) {
      if (!!data) *out |= 1 << bit_;
      else *out &= ~( 1 << bit_);
    }
};
//---------------------------------------------------------------
// класс мотор,класс заслонка,класс толкатель
#define ON_ HIGH
class Cl_Machine {
  protected:
    Cl_pin &pin;
  public:
    /*конструктор*/
    Cl_Machine(Cl_pin &p): pin(p) {}
    /*инициализация- вставить в setup*/
    void init() {
      pin.output();
      OFF();
    }
    /*работа- вставить в loop*/
    void run() {}
    /*включить*/
    void ON() {
      pin.write(ON_);
    }
    /*выключить*/
    void OFF() {
      pin.write(!ON_);
    }
};
//--------------------------------------------
// класс конвейер
class Cl_Transporter {
  protected:
    Cl_Machine Motor, Lock, Pull;
    unsigned long past;
    byte state;//состояние конвейера
    /*устатановить конвейер в состояние*/
    void stand(byte state_) {
      state = state_;
      past = mill;
      switch (state) {
        case 0:
          Motor.ON();
          Serial.println("Motor ON");
          break;
        case 1:
          Motor.OFF();
          Serial.println("Motor OFF");
          break;
        case 2:
          Lock.ON();
          Serial.println("Lock ON");
          break;
        case 3:
          Pull.ON();
          Serial.println("Pull ON");
          break;
        case 4:
          Pull.OFF();
          Serial.println("Pull OFF");
          break;
        case 5:
          Lock.OFF();
          Serial.println("Lock OFF");
          break;
        default:
          Motor.OFF();
          Serial.println("Motor OFF");
      }
    }
  public:
    /*конструктор*/
    Cl_Transporter(Cl_pin pin1, Cl_pin pin2, Cl_pin pin3)
      : Motor(pin1), Lock(pin2), Pull(pin3) {}
    /*инициализация- вставить в setup*/
    void init() {
      Motor.init();
      Lock.init();
      Pull.init();
      stand(0);// вкл мотор
    }
    /*работа- вставить в loop*/
    void run() {
      if (state == 1 && mill - past >= 500) stand(2);
      if (state == 2 && mill - past >= 500) stand(3);
      if (state == 3 && mill - past >= 500) stand(4);
      if (state == 4 && mill - past >= 1000)stand(5);
      if (state == 5 && mill - past >= 500)stand(0);
    }
    /*запустить конвейep*/
    void start() {
      if (state == 6) stand(0);// вкл мотор
    }
    /*остановить конвейep*/
    void stop() {
      if (state == 0) stand(6);// выкл мотор
    }
    /*разгрузить конвейep*/
    void swap() {
      if (state == 0) stand(1);// вкл разгрузку конвейера
    }
};
//----------------------------
//класс учетчик
class Cl_Check {
  protected:
    Cl_pin &pin; //<-- это переменая ноги
    pDo Do;   //<-- это ее обработчик
    bool val, oldVal;
    byte num = 0, maxNum = 5; // сколько и мах кол-во предметов на конвейере
  public:
    /*конструктор*/
    Cl_Check(Cl_pin &p, pDo Do_): pin(p), Do(Do_) {}
    /*инициализация- вставить в setup*/
    void init() {
      pin.inputPullup();
      oldVal = pin.read();
    }
    /*работа- вставить в loop*/
    void run() {
      val = pin.read();
      if (val && !oldVal) { // если произошел перепад ^\_
        oldVal = val;
        ++num;
        if (num >= maxNum) { // если кол-во предметов достигла максимума
          num = 0; Do();
        }
      }
      if (!val && oldVal) { // если произошел перепад _/^
        oldVal = val;
      }
    }
    /*режим5 предметов*/
    void mode5() {
      if (maxNum != 5) {
        maxNum = 5;
        if (num >= maxNum) {
          num = 0; Do();
        }
      }
    }
    /*режим10 предметов*/
    void mode10() {
      if (maxNum != 10) {
        maxNum = 10;
      }
    }
};
//--------------------------------
// класс кнопка
class Cl_Btn {
  protected:
    Cl_pin &pin; //<- это переменая ноги
    pDo Do;// <-- это ее обработчик
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    /*конструктор*/
    Cl_Btn(Cl_pin &p, pDo Do_)
      : pin(p), Do(Do_) {}
    /*инициализация- вставить в setup*/
    void init() {
      pin.inputPullup();
    }
    /*работа- вставить в loop*/
    void run() {
      bool newBtn = pin.read();
      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) Do();
      }
    }
};
//---Компоновка-----------------------------
Cl_pin pin2(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/2);/*пин 2*/
Cl_pin pin3(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/3);/*пин 3*/
Cl_pin pin4(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/4);/*пин 4*/
Cl_pin pin5(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/5);/*пин 5*/
Cl_pin pin6(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/6);/*пин 6*/
Cl_pin pin7(/*устанв*/&DDRD,/*вывод*/&PORTD,/*ввод*/&PIND,/*бит*/7);/*пин 7*/
Cl_pin pin8(/* устанв*/&DDRB,/*вывод*/&PORTB,/*ввод*/&PINB,/*бит*/0);/*пин 8*/
Cl_pin pin9(/* устанв*/&DDRB,/*вывод*/&PORTB,/*ввод*/&PINB,/*бит*/1);/*пин 9*/
Cl_Transporter Transporter(/*пин Мотора*/pin7,/*пин Шторки*/pin8,/*пин Толкателя*/pin9);
void DoCheck() {
  Transporter.swap();
  Serial.println("Transporter Swap");
}
Cl_Check Check(/*пин счетчика*/pin6,/*обработчик*/&DoCheck);
void DoStart() {
  Serial.println("Transporter Start");
  Transporter.start();
}
Cl_Btn Btn1(/*пин*/pin2,/*обработчик*/&DoStart);
void DoStop() {
  Serial.println("Transporter Stop");
  Transporter.stop();
}
Cl_Btn Btn2(/*пин*/pin3,/*обработчик*/&DoStop);
void DoMode5() {
  Serial.println("DoMode5");
  Check.mode5();
}
Cl_Btn Btn3(/*пин*/pin4,/*обработчик*/&DoMode5);
void DoMode10() {
  Serial.println("DoMode10");
  Check.mode10();
}
Cl_Btn Btn4(/*пин*/pin5,/*обработчик*/&DoMode10);
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Transporter.init();
  Check.init();
  Btn1.init();
  Btn2.init();
  Btn3.init();
  Btn4.init();

}
void loop() {
  mill = millis();
  Transporter.run();
  Check.run();
  Btn1.run();
  Btn2.run();
  Btn3.run();
  Btn4.run();
}
/*Скетч использует 3422 байт (11%) памяти устройства. Всего доступно 30720 байт.
  Глобальные переменные используют 431 байт (21%) динамической памяти, оставляя 1617 байт для локальных переменных. Максимум: 2048 байт.
*/

 

Это точно! Лично я при проверке знаний даю простенькую задачку, написать программку на любом языке считающую объем в бочке  лежащей  на боку на ровной горизонтальной поверхности к примеру через 1 миллиметр, в основном не справляются, хреново Вы их там учите ))) (или учили)

 

что значит "считающую обьем....  через 1 миллиметр" :) Подозреваю,  что подразумевается интеграл по обьему... но надо же выражаться точно, когда ТЗ составляешь:)

Вопрос - откуда экзаменующиеся берут форму боковой поверхности бочки для интегрирования обьема?