Sztuczna Inteligencja o Supli

FilipXYZ · Post Sat Apr 08, 2023 3:00 pm

Kod który zmieścił Klew niestety się nie kompiluje w arduino. Jest jakiś problem z klasami. Chciałem dodać dodać przycisk do obsługi serva niestety z suplą ma problem ale samą obsługę serwa napisał prawidłowo.

#include <ESP8266WiFi.h>
#include <Servo.h>

Servo myservo;
int buttonPin = D1; // przycisk podłączony do pinu D1
int buttonState = 0;
int lastButtonState = 0;
int position = 0; // początkowa pozycja serwa
unsigned long lastButtonTime = 0; // czas ostatniego naciśnięcia przycisku
unsigned long returnTime = 10000; // czas powrotu serwa do pozycji 0 (w milisekundach)

void setup() {
myservo.attach(D5); // podłączenie serwomechanizmu do pinu D5
pinMode(buttonPin, INPUT_PULLUP); // ustawienie pinu przycisku jako wejście i włączenie wewnętrznego pull-up resistora
myservo.write(position); // ustawienie początkowej pozycji serwa na 0 stopni
}

void loop() {
unsigned long currentTime = millis(); // aktualny czas w milisekundach
buttonState = digitalRead(buttonPin); // odczytanie stanu przycisku
if (buttonState != lastButtonState) {
if (buttonState == LOW) { // jeśli przycisk został naciśnięty
if (position == 0) { // jeśli serwo jest w pozycji 0 stopni
position = 90; // ustawienie pozycji serwa na 90 stopni
lastButtonTime = currentTime; // zapisanie czasu ostatniego naciśnięcia przycisku
}
else { // jeśli serwo jest w pozycji 90 stopni
position = 0; // ustawienie pozycji serwa na 0 stopni
}
myservo.write(position); // ustawienie kąta obrotu serwomechanizmu na wartość pozycji
}
lastButtonState = buttonState; // zapisanie aktualnego stanu przycisku
}
if (position != 0 && (currentTime - lastButtonTime) >= returnTime) { // jeśli serwo nie jest w pozycji 0 i upłynął czas powrotu do pozycji 0
position = 0; // ustawienie pozycji serwa na 0 stopni
myservo.write(position); // ustawienie kąta obrotu serwomechanizmu na wartość pozycji
}
}

Może ktoś pomoże z tym kodem?

FilipXYZ · Post Sat Apr 08, 2023 3:12 pm

W ramach testu sprawdziłem jak zachowa się Chat GPT gdy się go poprosi o taki sam kod który jednak nie opiera się o biblioteki
supli.#define BUTTON1_PIN 12
#define BUTTON2_PIN 13
#define RELAY1_PIN 14
#define RELAY2_PIN 15

void setup() {
pinMode(BUTTON1_PIN, INPUT_PULLUP);
pinMode(BUTTON2_PIN, INPUT_PULLUP);
pinMode(RELAY1_PIN, OUTPUT);
pinMode(RELAY2_PIN, OUTPUT);

digitalWrite(RELAY1_PIN, HIGH);
digitalWrite(RELAY2_PIN, HIGH);
}

void loop() {
if (digitalRead(BUTTON1_PIN) == LOW) {
digitalWrite(RELAY1_PIN, LOW);
} else {
digitalWrite(RELAY1_PIN, HIGH);
}

if (digitalRead(BUTTON2_PIN) == LOW) {
digitalWrite(RELAY2_PIN, LOW);
} else {
digitalWrite(RELAY2_PIN, HIGH);
}
}
Kod bez bibliotek supli kompiluje się prawidłowo. Więc mniemam że supla dla sztucznej inteligencji stanowi ogromne wyzwanie. Albo te bibliotek są az tak bardzo nie zrozumiałe. Gdzie indziej wyczytałem, że nawet programiści mają z nimi problem.

Patryk · Post Sat Apr 08, 2023 4:29 pm

FilipXYZ wrote: Sat Apr 08, 2023 3:12 pm Więc mniemam że supla dla sztucznej inteligencji stanowi ogromne wyzwanie.

I to jest fenomen SUPLI.
Choc kod źródłowy jest otwarty, to nawet super maszyna nie potrafi go rozgryźć.

dobo · Post Mon Apr 10, 2023 5:15 pm

No jednak nie radzi sobie z prostym zadaniem dla attiny13. Jest blisko, a zarazem tak daleko.
Dałem zadanie napisania impulsatora z trzema wejściami i jednym wyjściem i prawie działa ale nie działa tak jak mu piszę.
Ma za zadanie zebrać informację (chwilowy stan niski) z wejść 3, 4 i 5 gdy w takiej kolejności zbierze informacje o wykryciu chwilowego stanu niskiego na wejściach to ma zresetować wejścia i na wyjściu 0 ma pojawić się na 200ms stan niski.

Code: Select all

const int input_pins[] = {3, 4, 5};
const int output_pin = 0;
bool input_pins_low[] = {false, false, false};

void setup() {
  pinMode(output_pin, OUTPUT);
  digitalWrite(output_pin, HIGH);
  
  for (int i = 0; i < 3; i++) {
    pinMode(input_pins[i], INPUT_PULLUP);
  }
}

void loop() {
  bool all_inputs_low = true;

  for (int i = 0; i < 3; i++) {
    if (digitalRead(input_pins[i]) == LOW) {
      input_pins_low[i] = true;
    }
    
    if (input_pins_low[i] == false) {
      all_inputs_low = false;
      break;
    }
  }

  if (all_inputs_low) {
    digitalWrite(output_pin, LOW);
    delay(200);
    digitalWrite(output_pin, HIGH);

    for (int i = 0; i < 3; i++) {
      input_pins_low[i] = false;
    }
  }
}

Code: Select all

const byte PIN_3 = PB3;
const byte PIN_4 = PB4;
const byte PIN_5 = PB5;
const byte PIN_0 = PB0;
unsigned long input_pins_low[3];
bool input_pins_state[3] = {HIGH, HIGH, HIGH};

void setup() {
  pinMode(PIN_3, INPUT_PULLUP);
  pinMode(PIN_4, INPUT_PULLUP);
  pinMode(PIN_5, INPUT_PULLUP);
  pinMode(PIN_0, OUTPUT);
}

void loop() {
  if (digitalRead(PIN_3) == LOW && input_pins_state[0] == HIGH) {
    input_pins_low[0] = millis();
    input_pins_state[0] = LOW;
  }
  if (digitalRead(PIN_4) == LOW && input_pins_state[1] == HIGH) {
    input_pins_low[1] = millis();
    input_pins_state[1] = LOW;
  }
  if (digitalRead(PIN_5) == LOW && input_pins_state[2] == HIGH) {
    input_pins_low[2] = millis();
    input_pins_state[2] = LOW;
  }
  if (input_pins_state[0] == LOW && input_pins_state[1] == LOW && input_pins_state[2] == LOW) {
    if (millis() - input_pins_low[2] > 200) {
      digitalWrite(PIN_0, LOW);
      delay(200);
      digitalWrite(PIN_0, HIGH);
      input_pins_state[0] = HIGH;
      input_pins_state[1] = HIGH;
      input_pins_state[2] = HIGH;
    }
  }
}

FilipXYZ · Post Mon Apr 10, 2023 6:15 pm

Ja mu kazałem pisać krok po kroku i ładnie modyfikował. Może nie rozumie opisu i co autor miał na myśli.

dobo · Post Mon Apr 10, 2023 6:38 pm

pisałem w różny sposób i go oprawiałem ale ni h...
trochę z nim walczyłem i mnie pokonał

poniżej nasza konwersacja

Code: Select all

Napisz kod w Arduino na układ attiny13a, który ma 3 wejścia na pinach pb3, pb4 i pb5, które są podciągnięte do VCC oraz 1 wyjście na pinie pb0, które również jest podciągnięte do VCC. Działanie tego układu ma polegać na tym, że na pinie wyjściowym pb0 ma pojawić się stan niski przez 100 ma gdy kolejno po sobie na pinach wejściowych pojawi się stan niski w kolejności pb3, pb4, pb5.
Oto kod w Arduino dla attiny13a, który spełnia wymagania opisane w pytaniu:

scss
Copy code
int pb3_state = HIGH;
int pb4_state = HIGH;
int pb5_state = HIGH;
int pb0_state = HIGH;

void setup() {
  pinMode(0, OUTPUT); // ustawienie pinu pb0 jako wyjście
}

void loop() {
  pb3_state = digitalRead(3); // odczyt stanu pinu pb3
  pb4_state = digitalRead(4); // odczyt stanu pinu pb4
  pb5_state = digitalRead(5); // odczyt stanu pinu pb5

  if (pb3_state == LOW && pb4_state == LOW && pb5_state == LOW) { // sprawdzenie, czy wszystkie trzy piny wejściowe są w stanie niskim
    digitalWrite(0, LOW); // ustawienie stanu niskiego na pinie pb0
    delay(100); // opóźnienie 100ms
    digitalWrite(0, HIGH); // ustawienie stanu wysokiego na pinie pb0
  }
}
Kod ten odczytuje stan trzech pinów wejściowych (pb3, pb4 i pb5), a następnie sprawdza, czy wszystkie trzy są w stanie niskim. Jeśli tak, ustawia stan niski na pinie wyjściowym pb0 przez 100 ms, a następnie przywraca stan wysoki na tym samym pinie. Kod ten będzie działał ciągle w pętli, sprawdzając i reagując na zmiany stanów pinów wejściowych.




dobo1980
Popraw kod w ten sposób, że stan niski na pinach pb3, pb4 i pb5 nie musi być cały czas, a jedynie musi on nastąpić w podanej kolejności by na pinie pb0 pojawił się na 100ms stan niski
Oto zmodyfikowany kod, który spełnia nowe wymagania:

arduino
Copy code
int pb0_state = HIGH;
bool pb3_detected = false;
bool pb4_detected = false;
bool pb5_detected = false;

void setup() {
  pinMode(0, OUTPUT); // ustawienie pinu pb0 jako wyjście
  pinMode(3, INPUT_PULLUP); // ustawienie pinu pb3 jako wejście z podciągnięciem do VCC
  pinMode(4, INPUT_PULLUP); // ustawienie pinu pb4 jako wejście z podciągnięciem do VCC
  pinMode(5, INPUT_PULLUP); // ustawienie pinu pb5 jako wejście z podciągnięciem do VCC
}

void loop() {
  int pb3_state = digitalRead(3); // odczyt stanu pinu pb3
  int pb4_state = digitalRead(4); // odczyt stanu pinu pb4
  int pb5_state = digitalRead(5); // odczyt stanu pinu pb5
  
  if (pb3_state == LOW && !pb3_detected) { // jeśli stan pinu pb3 jest niski i nie został jeszcze wykryty
    pb3_detected = true; // oznaczenie wykrycia stanu niskiego na pinie pb3
  } else if (pb4_state == LOW && pb3_detected && !pb4_detected) { // jeśli stan pinu pb4 jest niski i stan niski na pinie pb3 został już wykryty, ale nie został jeszcze wykryty na pinie pb4
    pb4_detected = true; // oznaczenie wykrycia stanu niskiego na pinie pb4
  } else if (pb5_state == LOW && pb4_detected && pb3_detected && !pb5_detected) { // jeśli stan pinu pb5 jest niski i stany niskie na pinach pb3 i pb4 zostały już wykryte, ale nie został jeszcze wykryty na pinie pb5
    pb5_detected = true; // oznaczenie wykrycia stanu niskiego na pinie pb5
  }

  if (pb3_detected && pb4_detected && pb5_detected) { // jeśli stany niskie na pinach pb3, pb4 i pb5 zostały wykryte w kolejności
    digitalWrite(0, LOW); // ustawienie stanu niskiego na pinie pb0
    delay(100); // opóźnienie 100ms
    digitalWrite(0, HIGH); // ustawienie stanu wysokiego na pinie pb0
    // resetowanie zmiennych
    pb3_detected = false;
    pb4_detected = false;
    pb5_detected = false;
  }
}
Kod ten korzysta z zmiennych boolowskich pb3_detected, pb4_detected i pb5_detected, aby śledzić, czy stany niskie zostały już wykryte na poszczególnych pinach. Jeśli stany niskie zostaną wykryte w kolejności na pinach pb3, pb4 i pb5, ustawiony zostanie stan niski na pinie wyjściowym pb0 przez 100 ms, a następnie zmienne boolowskie




dobo1980
przepisz powyższy kod na język bascom
Oto przepisany kod na język Bascom:

vbnet
Copy code
$regfile = "attiny13a.dat"  ' wybór pliku .dat dla ATTiny13A
$crystal = 1200000         ' częstotliwość zegara

Config Pin0 = Output       ' ustawienie pinu pb0 jako wyjście
Config Pin3 = Input_pullup ' ustawienie pinu pb3 jako wejście z podciągnięciem do VCC
Config Pin4 = Input_pullup ' ustawienie pinu pb4 jako wejście z podciągnięciem do VCC
Config Pin5 = Input_pullup ' ustawienie pinu pb5 jako wejście z podciągnięciem do VCC

Dim pb0_state As Byte      ' zmienna przechowująca stan pinu pb0
Dim pb3_detected As Bit    ' zmienna typu Bit przechowująca informację o wykryciu stanu niskiego na pinie pb3
Dim pb4_detected As Bit    ' zmienna typu Bit przechowująca informację o wykryciu stanu niskiego na pinie pb4
Dim pb5_detected As Bit    ' zmienna typu Bit przechowująca informację o wykryciu stanu niskiego na pinie pb5

Do
  Local pb3_state As Byte  ' zmienna przechowująca stan pinu pb3
  Local pb4_state As Byte  ' zmienna przechowująca stan pinu pb4
  Local pb5_state As Byte  ' zmienna przechowująca stan pinu pb5
  
  pb3_state = Pin3        ' odczyt stanu pinu pb3
  pb4_state = Pin4        ' odczyt stanu pinu pb4
  pb5_state = Pin5        ' odczyt stanu pinu pb5
  
  If pb3_state = 0 And Not pb3_detected Then    ' jeśli stan pinu pb3 jest niski i nie został jeszcze wykryty
    pb3_detected = 1      ' oznaczenie wykrycia stanu niskiego na pinie pb3
  ElseIf pb4_state = 0 And pb3_detected And Not pb4_detected Then   ' jeśli stan pinu pb4 jest niski i stan niski na pinie pb3 został już wykryty, ale nie został jeszcze wykryty na pinie pb4
    pb4_detected = 1      ' oznaczenie wykrycia stanu niskiego na pinie pb4
  ElseIf pb5_state = 0 And pb4_detected And pb3_detected And Not pb5_detected Then   ' jeśli stan pinu pb5 jest niski i stany niskie na pinach pb3 i pb4 zostały już wykryte, ale nie został jeszcze wykryty na pinie pb5
    pb5_detected = 1      ' oznaczenie wykrycia stanu niskiego na pinie pb5
  End If

  If pb3_detected And pb4_detected And pb5_detected Then   ' jeśli stany niskie na pinach pb3, pb4 i pb5 zostały wykryte w kolejności
    Pb0_state = 0         ' ustawienie stanu niskiego



dobo1980
Napisz kod w Arduino na układ attiny13a, który ma 3 wejścia na pinach pb3, pb4 i pb5, które są podciągnięte do VCC oraz 1 wyjście na pinie pb0, które również jest podciągnięte do VCC. Działanie tego układu ma polegać na tym, że na pinie wyjściowym pb0 ma pojawić się stan niski przez 100 ms gdy kolejno po sobie na pb3, pb4, pb5 pojawi się na chwilę stan niski.

2 / 2

Oto kod w Arduino dla ATTiny13A spełniający powyższe wymagania:

c++
Copy code
const int PB0_PIN = 0;
const int PB3_PIN = 3;
const int PB4_PIN = 4;
const int PB5_PIN = 5;

bool pb3_state, pb4_state, pb5_state;   // zmienne przechowujące stan pinów PB3, PB4 i PB5
bool pb3_detected, pb4_detected, pb5_detected; // zmienne przechowujące informację o wykryciu stanów niskich na pinach PB3, PB4 i PB5

void setup() {
  pinMode(PB0_PIN, OUTPUT);       // ustawienie pinu PB0 jako wyjście
  pinMode(PB3_PIN, INPUT_PULLUP); // ustawienie pinu PB3 jako wejście z podciągnięciem do VCC
  pinMode(PB4_PIN, INPUT_PULLUP); // ustawienie pinu PB4 jako wejście z podciągnięciem do VCC
  pinMode(PB5_PIN, INPUT_PULLUP); // ustawienie pinu PB5 jako wejście z podciągnięciem do VCC
}

void loop() {
  pb3_state = digitalRead(PB3_PIN);   // odczyt stanu pinu PB3
  pb4_state = digitalRead(PB4_PIN);   // odczyt stanu pinu PB4
  pb5_state = digitalRead(PB5_PIN);   // odczyt stanu pinu PB5
  
  if (!pb3_state && !pb3_detected) {  // jeśli stan pinu PB3 jest niski i nie został jeszcze wykryty
    pb3_detected = true;              // oznaczenie wykrycia stanu niskiego na pinie PB3
  }
  else if (!pb4_state && pb3_detected && !pb4_detected) { // jeśli stan pinu PB4 jest niski i stan niski na pinie PB3 został już wykryty, ale nie został jeszcze wykryty na pinie PB4
    pb4_detected = true;              // oznaczenie wykrycia stanu niskiego na pinie PB4
  }
  else if (!pb5_state && pb3_detected && pb4_detected && !pb5_detected) { // jeśli stan pinu PB5 jest niski i stany niskie na pinach PB3 i PB4 zostały już wykryte, ale nie został jeszcze wykryty na pinie PB5
    pb5_detected = true;              // oznaczenie wykrycia stanu niskiego na pinie PB5
  }
  
  if (pb3_detected && pb4_detected && pb5_detected) {   // jeśli stany niskie na pinach PB3, PB4 i PB5 zostały wykryte w kolejności
    digitalWrite(PB0_PIN, LOW);     // ustawienie stanu niskiego na pinie PB0
    delay(100);                     // opóźnienie 100 ms
    digitalWrite(PB0_PIN, HIGH);    // powrót do stanu wysokiego na pinie PB0
    pb3_detected = pb4_detected = pb5_detected = false; // resetowanie zmiennych wykrycia stanów niskich
  }
}



dobo1980
kod nie działa tak jak bym chciał popraw go według poniższego założenia
1) aby na pinie PB0 pojawił się na chwilę stan niski np. przez 200ms to musi być spełniony warunek pojawienia się przez chwilę na pinie PB3, PB4 i PB5 stan niski
Oto poprawiony kod, który spełnia Twoje założenia:

arduino
Copy code
int pb3State = HIGH;
int pb4State = HIGH;
int pb5State = HIGH;
int pb0State = HIGH;
unsigned long startTime = 0;

void setup() {
  pinMode(0, OUTPUT); // PB0 as output
  pinMode(3, INPUT_PULLUP); // PB3 as input with pull-up resistor
  pinMode(4, INPUT_PULLUP); // PB4 as input with pull-up resistor
  pinMode(5, INPUT_PULLUP); // PB5 as input with pull-up resistor
  digitalWrite(0, HIGH); // set PB0 to HIGH
}

void loop() {
  int pb3Reading = digitalRead(3);
  int pb4Reading = digitalRead(4);
  int pb5Reading = digitalRead(5);
  
  if (pb3Reading == LOW && pb3State == HIGH) {
    pb3State = LOW;
  }
  if (pb4Reading == LOW && pb3State == LOW && pb4State == HIGH) {
    pb4State = LOW;
  }
  if (pb5Reading == LOW && pb3State == LOW && pb4State == LOW && pb5State == HIGH) {
    pb5State = LOW;
    startTime = millis();
  }
  if (pb3Reading == HIGH && pb3State == LOW) {
    pb3State = HIGH;
    pb4State = HIGH;
    pb5State = HIGH;
  }
  if (millis() - startTime < 200 && pb5State == LOW) {
    pb0State = LOW;
  }
  else {
    pb0State = HIGH;
  }
  
  digitalWrite(0, pb0State);
  delay(10); // small delay for stability
}
W tym kodzie wprowadziliśmy dodatkowe zmienne pb3State, pb4State i pb5State, aby śledzić stan pinów PB3, PB4 i PB5. Następnie, w warunkach sprawdzamy, czy na danym pinie pojawił się stan niski, ale jednocześnie sprawdzamy, czy poprzednie piny również są w stanie niskim. Jeśli wszystkie warunki są spełnione, ustawiamy odpowiednią zmienną stanu na niski i zapisujemy czas rozpoczęcia na zmiennej startTime.

Następnie, jeśli minęło mniej niż 200 ms od momentu, gdy startTime zostało ustawione i pin PB5 znajduje się w stanie niskim, ustawiamy zmienną pb0State na niski, co spowoduje pojawienie się stanu niskiego na pinie PB0.

Używamy opóźnienia 10 ms w każdym przebiegu pętli, aby zapewnić stabilność.




dobo1980
usuń z kodu zmienną startTime nie jest ona potrzebna
Jeśli usuniemy zmienną startTime, to trzeba będzie zastosować inny sposób na śledzenie czasu, więc należy dodać dodatkową zmienną, która będzie przechowywała czas ostatniego zmiany stanu na pinach PB3, PB4 i PB5. W ten sposób będziemy mogli sprawdzić, czy upłynęło wystarczająco dużo czasu między kolejnymi zmianami stanu, aby uznać, że spełniony jest warunek do wygenerowania stanu niskiego na pinie PB0. Oto zmodyfikowany kod:

arduino
Copy code
int pb3State = HIGH;
int pb4State = HIGH;
int pb5State = HIGH;
int pb0State = HIGH;
unsigned long lastChangeTime = 0;

void setup() {
  pinMode(0, OUTPUT); // PB0 as output
  pinMode(3, INPUT_PULLUP); // PB3 as input with pull-up resistor
  pinMode(4, INPUT_PULLUP); // PB4 as input with pull-up resistor
  pinMode(5, INPUT_PULLUP); // PB5 as input with pull-up resistor
  digitalWrite(0, HIGH); // set PB0 to HIGH
}

void loop() {
  int pb3Reading = digitalRead(3);
  int pb4Reading = digitalRead(4);
  int pb5Reading = digitalRead(5);
  unsigned long currentTime = millis();
  
  if (pb3Reading == LOW && pb3State == HIGH) {
    pb3State = LOW;
    lastChangeTime = currentTime;
  }
  if (pb4Reading == LOW && pb3State == LOW && pb4State == HIGH) {
    pb4State = LOW;
    lastChangeTime = currentTime;
  }
  if (pb5Reading == LOW && pb3State == LOW && pb4State == LOW && pb5State == HIGH) {
    pb5State = LOW;
    lastChangeTime = currentTime;
  }
  if (pb3Reading == HIGH && pb3State == LOW) {
    pb3State = HIGH;
    pb4State = HIGH;
    pb5State = HIGH;
  }
  if (currentTime - lastChangeTime < 200 && pb5State == LOW) {
    pb0State = LOW;
  }
  else {
    pb0State = HIGH;
  }
  
  digitalWrite(0, pb0State);
  delay(10); // small delay for stability
}
W tym kodzie użyliśmy zmiennej lastChangeTime, aby śledzić czas ostatniej zmiany stanu na pinach PB3, PB4 i PB5. Następnie, jeśli upłynęło mniej niż 200 ms od ostatniej zmiany stanu i pin PB5 znajduje się w stanie niskim, ustawiamy zmienną pb0State na niski, co spowoduje pojawienie się stanu niskiego na pinie PB0.

Używamy opóźnienia 10 ms w każdym przebiegu pętli, aby zapewnić stabilność.




dobo1980
nie ma potrzeby śledzenia czasu na pinach PB3, PB4 i PB5 musi być tylko zachowana odpowiednia kolejność pojawienia się stanu niskiego na tych pinach gdy ona nastąpi na PB0 ma być stan niski przez 200ms. Ma to działać jak impulsator po zebraniu impulsów z PB3, PB4 i PB5 ma pojawić się impuls 200ms na PB0.
Oto poprawiony kod, który powinien spełniać opisane wymagania:

arduino
Copy code
const int PB3 = 3;
const int PB4 = 4;
const int PB5 = 5;
const int PB0 = 0;

bool pb3Low = false;
bool pb4Low = false;
bool pb5Low = false;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
  digitalWrite(PB0, HIGH);
}

void loop() {
  if (digitalRead(PB3) == LOW) {
    pb3Low = true;
  }
  if (digitalRead(PB4) == LOW && pb3Low) {
    pb4Low = true;
  }
  if (digitalRead(PB5) == LOW && pb3Low && pb4Low) {
    pb5Low = true;
  }
  
  if (pb3Low && pb4Low && pb5Low) {
    digitalWrite(PB0, LOW);
    delay(200);
    digitalWrite(PB0, HIGH);
    pb3Low = false;
    pb4Low = false;
    pb5Low = false;
  }
}
W tym kodzie używamy trzech zmiennych boolowskich do śledzenia, czy pojawił się stan niski na każdym z trzech pinów PB3, PB4 i PB5 w odpowiedniej kolejności. Gdy te trzy zmienne są ustawione na true, oznacza to, że pojawił się stan niski na każdym z tych pinów w odpowiedniej kolejności i możemy wygenerować impuls na PB0 przez 200 ms. Następnie zerujemy te zmienne, aby zacząć śledzenie kolejnego zestawu impulsów na PB3, PB4 i PB5.




dobo1980
kod w arduino nie chce się skompilować
Przepraszam za poprzedni kod, prawdopodobnie zawierał błędy. Oto nowy kod, który powinien działać poprawnie:

arduino
Copy code
const int PB3 = 3;
const int PB4 = 4;
const int PB5 = 5;
const int PB0 = 0;

bool pb3Low = false;
bool pb4Low = false;
bool pb5Low = false;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
  digitalWrite(PB0, HIGH);
}

void loop() {
  if (digitalRead(PB3) == LOW) {
    pb3Low = true;
  }
  if (digitalRead(PB4) == LOW && pb3Low) {
    pb4Low = true;
  }
  if (digitalRead(PB5) == LOW && pb3Low && pb4Low) {
    pb5Low = true;
  }
  
  if (pb3Low && pb4Low && pb5Low) {
    digitalWrite(PB0, LOW);
    delay(200);
    digitalWrite(PB0, HIGH);
    pb3Low = false;
    pb4Low = false;
    pb5Low = false;
  }
}
W tym kodzie używamy trzech zmiennych boolowskich do śledzenia, czy pojawił się stan niski na każdym z trzech pinów PB3, PB4 i PB5 w odpowiedniej kolejności. Gdy te trzy zmienne są ustawione na true, oznacza to, że pojawił się stan niski na każdym z tych pinów w odpowiedniej kolejności i możemy wygenerować impuls na PB0 przez 200 ms. Następnie zerujemy te zmienne, aby zacząć śledzenie kolejnego zestawu impulsów na PB3, PB4 i PB5.




dobo1980
arduino wykrywa błąd w tym kodzie 
const int PB3 = 3;
const int PB4 = 4;
const int PB5 = 5;
const int PB0 = 0;
W kodzie, który napisałem wcześniej, nazwy zmiennych PB3, PB4, PB5 i PB0 zostały zdefiniowane jako stałe (const), ale ta definicja nie jest obsługiwana przez język Bascom. W Arduino musimy zdefiniować te nazwy jako zmienne (int). Poprawiony kod wyglądałby w ten sposób:

arduino
Copy code
int PB3 = 3;
int PB4 = 4;
int PB5 = 5;
int PB0 = 0;

bool pb3Low = false;
bool pb4Low = false;
bool pb5Low = false;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
  digitalWrite(PB0, HIGH);
}

void loop() {
  if (digitalRead(PB3) == LOW) {
    pb3Low = true;
  }
  if (digitalRead(PB4) == LOW && pb3Low) {
    pb4Low = true;
  }
  if (digitalRead(PB5) == LOW && pb3Low && pb4Low) {
    pb5Low = true;
  }
  
  if (pb3Low && pb4Low && pb5Low) {
    digitalWrite(PB0, LOW);
    delay(200);
    digitalWrite(PB0, HIGH);
    pb3Low = false;
    pb4Low = false;
    pb5Low = false;
  }
}
Mam nadzieję, że teraz będzie działać poprawnie.




dobo1980
nadal się nie kompiluje i wywala poniższy błąd 
In file included from c:\users\artur\appdata\local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\io.h:420:0,
                 from C:\Users\Artur\AppData\Local\Arduino15\packages\MicroCore\hardware\avr\2.2.1\cores\microcore/Arduino.h:17,
                 from C:\Users\Artur\AppData\Local\Temp\arduino\sketches\A7DD3B181AD05F7C5DA8F6DFEF779E2D\sketch\attiny13a.ino.cpp:1:
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:1:5: error: expected unqualified-id before numeric constant
 int PB3 = 3;
     ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:2:5: error: expected unqualified-id before numeric constant
 int PB4 = 4;
     ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:3:5: error: expected unqualified-id before numeric constant
 int PB5 = 5;
     ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:4:5: error: expected unqualified-id before numeric constant
 int PB0 = 0;
     ^

exit status 1

Compilation error: expected unqualified-id before numeric constant
Wygląda na to, że nazwy zmiennych, które używasz, kolidują z istniejącymi definicjami w pliku io.h, do którego odwołuje się biblioteka avr. Aby uniknąć tego typu konfliktów, możesz użyć innych nazw zmiennych. Oto zmodyfikowany kod:

arduino
Copy code
const int pinPB3 = 3;
const int pinPB4 = 4;
const int pinPB5 = 5;
const int pinPB0 = 0;

int previousValues = 0;

void setup() {
  pinMode(pinPB3, INPUT_PULLUP);
  pinMode(pinPB4, INPUT_PULLUP);
  pinMode(pinPB5, INPUT_PULLUP);
  pinMode(pinPB0, OUTPUT);
}

void loop() {
  // odczytaj wartości wejść i dodaj do poprzednich
  int currentValues = 0;
  currentValues |= !digitalRead(pinPB3);
  currentValues |= !digitalRead(pinPB4) << 1;
  currentValues |= !digitalRead(pinPB5) << 2;
  previousValues = (previousValues << 1) | currentValues;

  // jeśli poprzednie wartości to 0b000111, to pojawił się impuls
  if (previousValues == 0b000111) {
    digitalWrite(pinPB0, LOW);
    delay(200);
    digitalWrite(pinPB0, HIGH);
  }
}
Upewnij się, że ten kod jest zapisany w pliku attiny13a.ino i spróbuj go skompilować ponownie.




dobo1980
Może inaczej opiszę ci jak ma to działać na arduino
attiny13a ma działać jak impulsator, który zbiera 3 impulsy stanu niskiego na wejściach w kolejności najpierw na pinie 3 potem na pinie 4 i na końcu na pinie 5. Zebrany w ten sposób stan niski z pinów 3, 4 i 5 zapisywany jest w zmiennej gdy warunek jest spełniony następuje jego zresetowanie i pojawienie się stanu niskiego na pinie 0 przez 200ms
Rozumiem, spróbuję napisać kod zgodnie z tym opisem. Oto próbka kodu, który powinien działać:

arduino
Copy code
const int pin3 = 3;
const int pin4 = 4;
const int pin5 = 5;
const int outPin = 0;

boolean pin3_low = false;
boolean pin4_low = false;
boolean pin5_low = false;
boolean output_active = false;

void setup() {
  pinMode(pin3, INPUT_PULLUP);
  pinMode(pin4, INPUT_PULLUP);
  pinMode(pin5, INPUT_PULLUP);
  pinMode(outPin, OUTPUT);
  digitalWrite(outPin, HIGH);
}

void loop() {
  boolean pin3_state = digitalRead(pin3) == LOW;
  boolean pin4_state = digitalRead(pin4) == LOW;
  boolean pin5_state = digitalRead(pin5) == LOW;

  if (!pin3_low && pin3_state) {
    pin3_low = true;
  }
  else if (!pin4_low && pin4_state && pin3_low) {
    pin4_low = true;
  }
  else if (!pin5_low && pin5_state && pin3_low && pin4_low) {
    pin5_low = true;
  }

  if (pin3_low && pin4_low && pin5_low && !output_active) {
    output_active = true;
    digitalWrite(outPin, LOW);
    delay(200);
    digitalWrite(outPin, HIGH);
    pin3_low = false;
    pin4_low = false;
    pin5_low = false;
    output_active = false;
  }
}
Proszę zauważyć, że powyższy kod jest jedynie próbką i nie został przetestowany na układzie attiny13a.




dobo1980
prawie działa ale kod nie bierze pod uwagę stanu niskiego na pinie 5 bo gdy na pinie 3 i 4 pojawi się stan niski to na pinie 0 pojawia się stan niski przez 200ms, a stan niski powinien się pojawić dopiero gdy na 
pinie 5 pojawi się również stan niski.

Oto poprawiony kod, który uwzględnia ten warunek:

arduino
Copy code
const int PB3 = 3;
const int PB4 = 4;
const int PB5 = 5;
const int PB0 = 0;

bool pb3_flag = false;
bool pb4_flag = false;
bool pb5_flag = false;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
}

void loop() {
  if (digitalRead(PB3) == LOW && pb3_flag == false) {
    pb3_flag = true;
  } else if (digitalRead(PB4) == LOW && pb3_flag == true && pb4_flag == false) {
    pb4_flag = true;
  } else if (digitalRead(PB5) == LOW && pb3_flag == true && pb4_flag == true && pb5_flag == false) {
    pb5_flag = true;
  } else if (pb3_flag == true && pb4_flag == true && pb5_flag == true) {
    digitalWrite(PB0, LOW);
    delay(200);
    digitalWrite(PB0, HIGH);
    pb3_flag = false;
    pb4_flag = false;
    pb5_flag = false;
  }
}
W tej wersji kodu pojawienie się stanu niskiego na pinie 0 zostanie opóźnione do momentu, gdy na pinie 5 pojawi się również stan niski.




dobo1980
napisz kod impulsatora w oparciu o układ attiny13 z trzema wejściami (piny 3, 4 i 5) oraz jednym wyjściem (pin 0) gdy zostanie spełniony warunek pojawienia się na wszystkich trzech pinach wejściowych stanu niskiego w kolejności pin 3, 4 i 5 to na wyjściu pin 0 ma pojawić się stan niski przez 200ms 
Oto kod impulsatora dla układu Attiny13 z trzema wejściami (piny 3, 4 i 5) oraz jednym wyjściem (pin 0). Kod ten działa na zasadzie zbierania impulsów z trzech pinów wejściowych, a następnie pojawienia się impulsu na wyjściu przez 200ms, gdy zostanie spełniony warunek pojawienia się na wszystkich trzech pinach wejściowych stanu niskiego w kolejności pin 3, 4 i 5.

arduino
Copy code
const int PB3 = 3;
const int PB4 = 4;
const int PB5 = 5;
const int PB0 = 0;

bool pb3_state = false;
bool pb4_state = false;
bool pb5_state = false;
unsigned long start_time = 0;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
  digitalWrite(PB0, HIGH);
}

void loop() {
  if (digitalRead(PB3) == LOW && !pb3_state) {
    pb3_state = true;
  }
  if (digitalRead(PB4) == LOW && pb3_state && !pb4_state) {
    pb4_state = true;
  }
  if (digitalRead(PB5) == LOW && pb4_state && pb3_state && !pb5_state) {
    pb5_state = true;
    start_time = millis();
  }

  if (pb5_state && millis() - start_time < 200) {
    digitalWrite(PB0, LOW);
  } else {
    digitalWrite(PB0, HIGH);
    pb3_state = false;
    pb4_state = false;
    pb5_state = false;
  }
}
W tym kodzie używamy trzech zmiennych logicznych (pb3_state, pb4_state, pb5_state) do śledzenia, czy na każdym z trzech pinów wejściowych (PB3, PB4, PB5) pojawił się stan niski w odpowiedniej kolejności. Jeśli wszystkie trzy zmienne mają wartość "true", to ustawiamy start_time na aktualny czas, co oznacza, że warunek został spełniony. Następnie, w pętli "loop()", sprawdzamy, czy minęło już 200ms od czasu start_time, i jeśli tak, to ustawiamy stan niski na pinie PB0 przez krótki czas. Po tym czasie, zmienne logiczne są resetowane, a pin PB0 wraca do stanu wysokiego.




dobo1980
zamień PB na pin
Oto poprawiony kod z użyciem zmiennych typu pin:

c++
Copy code
const pin PIN3 = 3;
const pin PIN4 = 4;
const pin PIN5 = 5;
const pin PIN0 = 0;
bool state3 = false;
bool state4 = false;
bool state5 = false;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(PIN0, OUTPUT);
}

void loop() {
  if (digitalRead(PIN3) == LOW && !state3) {
    state3 = true;
  } else if (digitalRead(PIN4) == LOW && state3 && !state4) {
    state4 = true;
  } else if (digitalRead(PIN5) == LOW && state4 && !state5) {
    state5 = true;
  }
  if (state5) {
    digitalWrite(PIN0, LOW);
    delay(200);
    digitalWrite(PIN0, HIGH);
    state3 = false;
    state4 = false;
    state5 = false;
  }
}



dobo1980
nadal arduino ma problem z kompilacją
Proszę podać dokładny komunikat błędu, który pojawia się podczas kompilacji, abyśmy mogli pomóc w rozwiązaniu problemu.




dobo1980
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:1:7: error: 'pin' does not name a type; did you mean 'sin'?
 const pin PIN3 = 3;
       ^~~
       sin
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:2:7: error: 'pin' does not name a type; did you mean 'sin'?
 const pin PIN4 = 4;
       ^~~
       sin
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:3:7: error: 'pin' does not name a type; did you mean 'sin'?
 const pin PIN5 = 5;
       ^~~
       sin
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:4:7: error: 'pin' does not name a type; did you mean 'sin'?
 const pin PIN0 = 0;
       ^~~
       sin

exit status 1

Compilation error: 'pin' does not name a type; did you mean 'sin'?
Przepraszam za mój błąd - niepoprawnie przetłumaczyłem ostatnie zalecenie. W Arduino, zamiast "pin" należy używać typu "byte" lub "int" do deklarowania numeru pinu.

Tak więc, zamiast:

arduino
Copy code
const pin PIN3 = 3;
const pin PIN4 = 4;
const pin PIN5 = 5;
const pin PIN0 = 0;
Powinno być:

arduino
Copy code
const byte PIN3 = 3;
const byte PIN4 = 4;
const byte PIN5 = 5;
const byte PIN0 = 0;
Proszę spróbować wprowadzić te zmiany i skompilować kod ponownie.




dobo1980
nadal jest problem
In file included from c:\users\artur\appdata\local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\io.h:715:0,
                 from C:\Users\Artur\AppData\Local\Arduino15\packages\MicroCore\hardware\avr\2.2.1\cores\microcore/Arduino.h:17,
                 from C:\Users\Artur\AppData\Local\Temp\arduino\sketches\A7DD3B181AD05F7C5DA8F6DFEF779E2D\sketch\attiny13a.ino.cpp:1:
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:1:12: error: expected unqualified-id before numeric constant
 const byte PIN3 = 3;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:2:12: error: expected unqualified-id before numeric constant
 const byte PIN4 = 4;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:3:12: error: expected unqualified-id before numeric constant
 const byte PIN5 = 5;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:4:12: error: expected unqualified-id before numeric constant
 const byte PIN0 = 0;
            ^

exit status 1

Compilation error: expected unqualified-id before numeric constant
Przepraszam za pomyłki. Zamiast słowa byte powinno być słowo int. Oto poprawiony kod:

c++
Copy code
const int PIN3 = 3;
const int PIN4 = 4;
const int PIN5 = 5;
const int PIN0 = 0;

bool pin3Low = false;
bool pin4Low = false;
bool pin5Low = false;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(PIN0, OUTPUT);
}

void loop() {
  if (!digitalRead(PIN3)) {
    pin3Low = true;
  } else if (pin3Low && !digitalRead(PIN4)) {
    pin4Low = true;
  } else if (pin4Low && !digitalRead(PIN5)) {
    pin5Low = true;
  }
  
  if (pin3Low && pin4Low && pin5Low) {
    digitalWrite(PIN0, LOW);
    delay(200);
    digitalWrite(PIN0, HIGH);
    pin3Low = false;
    pin4Low = false;
    pin5Low = false;
  }
}
Upewnij się, że wprowadziłeś poprawki zgodnie z powyższym kodem, a następnie spróbuj ponownie skompilować program.




dobo1980
In file included from c:\users\artur\appdata\local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\io.h:715:0,
                 from C:\Users\Artur\AppData\Local\Arduino15\packages\MicroCore\hardware\avr\2.2.1\cores\microcore/Arduino.h:17,
                 from C:\Users\Artur\AppData\Local\Temp\arduino\sketches\A7DD3B181AD05F7C5DA8F6DFEF779E2D\sketch\attiny13a.ino.cpp:1:
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:1:11: error: expected unqualified-id before numeric constant
 const int PIN3 = 3;
           ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:2:11: error: expected unqualified-id before numeric constant
 const int PIN4 = 4;
           ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:3:11: error: expected unqualified-id before numeric constant
 const int PIN5 = 5;
           ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:4:11: error: expected unqualified-id before numeric constant
 const int PIN0 = 0;
           ^

exit status 1

Compilation error: expected unqualified-id before numeric constant
Wygląda na to, że problemem są słowa kluczowe const int - w przypadku Attiny13 nie są one potrzebne. Spróbuj zmienić deklaracje na:

arduino
Copy code
const byte PIN3 = 3;
const byte PIN4 = 4;
const byte PIN5 = 5;
const byte PIN0 = 0;
Powinno to rozwiązać problem kompilacji.




dobo1980
In file included from c:\users\artur\appdata\local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\io.h:715:0,
                 from C:\Users\Artur\AppData\Local\Arduino15\packages\MicroCore\hardware\avr\2.2.1\cores\microcore/Arduino.h:17,
                 from C:\Users\Artur\AppData\Local\Temp\arduino\sketches\A7DD3B181AD05F7C5DA8F6DFEF779E2D\sketch\attiny13a.ino.cpp:1:
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:1:12: error: expected unqualified-id before numeric constant
 const byte PIN3 = 3;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:2:12: error: expected unqualified-id before numeric constant
 const byte PIN4 = 4;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:3:12: error: expected unqualified-id before numeric constant
 const byte PIN5 = 5;
            ^
C:\Users\Artur\Documents\Arduino\attiny13a\attiny13a.ino:4:12: error: expected unqualified-id before numeric constant
 const byte PIN0 = 0;
            ^

exit status 1

Compilation error: expected unqualified-id before numeric constant
The error message is indicating that there is a syntax error in your code. Specifically, it says "expected unqualified-id before numeric constant". This means that the compiler was expecting to see something other than a numeric constant at the location where you have declared your variables.

Looking at your code, it appears that you are trying to define constants for pin numbers using the names PIN3, PIN4, PIN5, and PIN0. However, you have declared these constants as byte or int variables, which is causing the syntax error.

To fix the error, you should change the variable types to const byte or const int, like this:

cpp
Copy code
const byte PIN3 = 3;
const byte PIN4 = 4;
const byte PIN5 = 5;
const byte PIN0 = 0;
By using the const keyword, you are telling the compiler that these variables will not be changed at runtime, which is what you want for pin definitions.




dobo1980
nie rozumiem
Błąd kompilacji wskazuje na to, że w twoim programie brakuje deklaracji lub definicji, lub są one niewłaściwie zdefiniowane. Konkretnie błąd wskazuje na to, że gdzieś w kodzie użyto słowa kluczowego, które nie jest poprawnym identyfikatorem (np. PIN3, PIN4, itp.) w kontekście, w którym zostało użyte. Słowa kluczowe (ang. keywords) są zarezerwowane przez język programowania i nie mogą być używane jako nazwy zmiennych, stałych lub funkcji.

Aby rozwiązać błąd, możesz spróbować zmienić nazwy zmiennych z PIN3, PIN4 itp. na coś innego, co jest poprawnym identyfikatorem, na przykład myPin3, myPin4 itp. Upewnij się również, że używasz odpowiednich typów zmiennych, w zależności od potrzeb twojego programu.




dobo1980
zamień pin na PB
Proszę spróbować zmienić definicję stałych z "PIN" na "PB", ponieważ "PIN" jest już zdefiniowany przez bibliotekę Arduino. Oto przykładowy kod:

c++
Copy code
const byte PB3 = 3;
const byte PB4 = 4;
const byte PB5 = 5;
const byte PB0 = 0;

void setup() {
  pinMode(PB3, OUTPUT);
  pinMode(PB4, OUTPUT);
  pinMode(PB5, OUTPUT);
  pinMode(PB0, OUTPUT);
}

void loop() {
  digitalWrite(PB3, HIGH);
  digitalWrite(PB4, HIGH);
  digitalWrite(PB5, HIGH);
  digitalWrite(PB0, HIGH);
  delay(1000);
  digitalWrite(PB3, LOW);
  digitalWrite(PB4, LOW);
  digitalWrite(PB5, LOW);
  digitalWrite(PB0, LOW);
  delay(1000);
}
W powyższym kodzie zmieniłem definicję stałych z "PIN" na "PB". Proszę zwrócić uwagę na użycie tych stałych w funkcjach pinMode() i digitalWrite().




dobo1980
wprowadz poprawkę do wcześniejszego kodu
Oto poprawiony kod:

c++
Copy code
const int PIN3 = PB3;
const int PIN4 = PB4;
const int PIN5 = PB5;
const int PIN0 = PB0;

void setup() {
  pinMode(PIN3, OUTPUT);
  pinMode(PIN4, OUTPUT);
  pinMode(PIN5, OUTPUT);
  pinMode(PIN0, OUTPUT);
}

void loop() {
  digitalWrite(PIN3, HIGH);
  digitalWrite(PIN4, HIGH);
  digitalWrite(PIN5, HIGH);
  digitalWrite(PIN0, HIGH);
  delay(1000);
  digitalWrite(PIN3, LOW);
  digitalWrite(PIN4, LOW);
  digitalWrite(PIN5, LOW);
  digitalWrite(PIN0, LOW);
  delay(1000);
}
Zmieniłem tylko definicje stałych PIN3, PIN4, PIN5 i PIN0 tak, aby korzystały z oznaczenia pinu PBx zamiast x. Następnie zaktualizowałem wywołania funkcji pinMode() i digitalWrite() tak, aby używały zdefiniowanych stałych.




dobo1980
napisz kod czujnika impulsów w oparciu o układ attiny13 z trzema wejściami (PB 3, 4 i 5) oraz jednym wyjściem (PB 0) gdy zostanie spełniony warunek stanu niskiego na wszystkich trzech wejściach w kolejności PB 3, 4 i 5 to na wyjściu PB 0 ma pojawia się stan niski na 200ms 
Oto kod czujnika impulsów dla układu attiny13:

scss
Copy code
const byte PIN_3 = 3;
const byte PIN_4 = 4;
const byte PIN_5 = 5;
const byte PIN_OUT = 0;

void setup() {
  pinMode(PIN_3, INPUT);
  pinMode(PIN_4, INPUT);
  pinMode(PIN_5, INPUT);
  pinMode(PIN_OUT, OUTPUT);
}

void loop() {
  if (digitalRead(PIN_3) == LOW && digitalRead(PIN_4) == LOW && digitalRead(PIN_5) == LOW) {
    digitalWrite(PIN_OUT, LOW);
    delay(200);
  } else {
    digitalWrite(PIN_OUT, HIGH);
  }
}
W tym kodzie definiujemy trzy wejścia jako stałe (PIN_3, PIN_4, PIN_5) oraz jedno wyjście (PIN_OUT). W funkcji setup() ustawiamy tryby pinów jako wejście lub wyjście. Następnie w pętli loop() sprawdzamy, czy wszystkie trzy wejścia mają stan niski. Jeśli tak, to ustawiamy stan wyjścia na niski przez 200ms, a następnie na wysoki. Jeśli chociaż jedno z wejść ma stan wysoki, to ustawiamy stan wyjścia na wysoki.




dobo1980
stan niski na wejściu nie musi być cały czas aby został spełniony warunek, natomiast spełniona musi być kolejność stanu niskiego na wejściu PB 3, PB 4 i PB 5 
Dziękuję za doprecyzowanie warunku. Poniżej znajduje się zmodyfikowany kod, który uwzględnia kolejność stanów niskich na wejściach PB 3, PB 4 i PB 5, bez wymagania ciągłego stanu niskiego na wejściach.

scss
Copy code
const byte PIN3 = PB3;
const byte PIN4 = PB4;
const byte PIN5 = PB5;
const byte OUTPUT_PIN = PB0;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(OUTPUT_PIN, OUTPUT);
}

void loop() {
  if (digitalRead(PIN3) == LOW) {
    delay(50);
    if (digitalRead(PIN4) == LOW) {
      delay(50);
      if (digitalRead(PIN5) == LOW) {
        digitalWrite(OUTPUT_PIN, LOW);
        delay(200);
        digitalWrite(OUTPUT_PIN, HIGH);
      }
    }
  }
}
W tym kodzie, jeśli stan niski zostanie wykryty na wejściu PB3, program czeka 50 ms i sprawdza, czy jest spełniony kolejny warunek na wejściu PB4. Jeśli tak, program czeka kolejne 50 ms i sprawdza, czy stan niski jest wykryty na wejściu PB5. Jeśli wszystkie trzy wejścia mają stan niski, to na wyjściu PB0 pojawia się stan niski na 200 ms.




dobo1980
ma nie czekać
Jeśli chcesz, aby kod był w stanie reagować na zmiany wejść w czasie, to powinieneś użyć przerwań. W takim przypadku, gdy nastąpi zmiana stanu wejść, przerwanie zostanie wywołane i kod obsługi przerwania zostanie wykonany natychmiast. W ten sposób unikniesz blokowania działania programu przez oczekiwanie na zmianę stanu wejść.

Poniżej znajduje się przykładowy kod, który wykorzystuje przerwania do obsługi wejść PB3, PB4 i PB5 i w przypadku spełnienia warunku pojawia się stan niski na wyjściu PB0 przez 200ms.

scss
Copy code
const byte PB0 = 0;
const byte PB3 = 3;
const byte PB4 = 4;
const byte PB5 = 5;

volatile byte PB3_state = HIGH;
volatile byte PB4_state = HIGH;
volatile byte PB5_state = HIGH;

void setup() {
  pinMode(PB0, OUTPUT);
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  
  attachInterrupt(digitalPinToInterrupt(PB3), handle_PB3_change, CHANGE);
  attachInterrupt(digitalPinToInterrupt(PB4), handle_PB4_change, CHANGE);
  attachInterrupt(digitalPinToInterrupt(PB5), handle_PB5_change, CHANGE);
}

void loop() {
  // Empty loop
}

void handle_PB3_change() {
  PB3_state = digitalRead(PB3);
  check_PB_sequence();
}

void handle_PB4_change() {
  PB4_state = digitalRead(PB4);
  check_PB_sequence();
}

void handle_PB5_change() {
  PB5_state = digitalRead(PB5);
  check_PB_sequence();
}

void check_PB_sequence() {
  if (PB3_state == LOW && PB4_state == LOW && PB5_state == LOW) {
    digitalWrite(PB0, LOW);
    delay(200);
    digitalWrite(PB0, HIGH);
  }
}
W tym kodzie zastosowano trzy zmienne PB3_state, PB4_state i PB5_state, które przechowują stan wejść PB3, PB4 i PB5. Zmienne te są deklarowane jako volatile, co oznacza, że są one dostępne i aktualne wewnątrz funkcji obsługi przerwania, nawet jeśli zmieniają się poza tą funkcją.

Funkcja handle_PB3_change() jest wywoływana za każdym razem, gdy zmienia się stan wejścia PB3. Wewnątrz tej funkcji odczytywany jest aktualny stan wejścia i zapisywany do zmiennej PB3_state. Następnie wywoływana jest funkcja check_PB_sequence(), która sprawdza, czy spełniony jest warunek na kolejność stanu niskiego na wejściach PB3, PB4 i PB5.

Podobnie działa funkcja handle_PB4_change() dla wejścia PB4 i funkcja handle_PB5_change() dla wejścia PB5.

Funkcja check_PB_sequence() sprawdza, czy stan niski na wejści




dobo1980
resetuj stan wejść po pojawieniu się stanu niskiego na wyjściu
Możesz dodać do kodu poniższą instrukcję przed końcem pętli while, aby zresetować stan wejść:

scss
Copy code
  if (PORTB & (1 << PB0)) { // jeśli wyjście PB0 jest w stanie wysokim
    PORTB &= ~((1 << PB3) | (1 << PB4) | (1 << PB5)); // resetuj stany wejść
  }
Ta instrukcja wykrywa, czy wyjście PB0 jest w stanie wysokim (czyli równym 1) i jeśli tak, to ustawia bity PB3, PB4 i PB5 portu B na 0, co resetuje stany wejść.




dobo1980
napisz to w arduino
Oto kod w Arduino, który realizuje opisane przez Ciebie wymagania:

arduino
Copy code
const int PIN3 = 3;
const int PIN4 = 4;
const int PIN5 = 5;
const int PIN0 = 0;

unsigned long start_time = 0;
bool triggered = false;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(PIN0, OUTPUT);
}

void loop() {
  if (digitalRead(PIN3) == LOW && digitalRead(PIN4) == LOW && digitalRead(PIN5) == LOW) {
    if (!triggered) {
      start_time = millis();
      triggered = true;
    } else if (millis() - start_time >= 200) {
      digitalWrite(PIN0, LOW);
    }
  } else {
    triggered = false;
    digitalWrite(PIN0, HIGH);
  }
}
W tym kodzie zdefiniowaliśmy trzy wejścia cyfrowe (PB 3, 4 i 5) oraz jedno wyjście cyfrowe (PB 0). W funkcji setup() ustawiliśmy tryby pracy pinów (wejścia są ustawione jako pull-up, a wyjście jako wyjście).

W funkcji loop() sprawdzamy, czy wszystkie trzy wejścia są w stanie niskim. Jeśli tak, to zapisujemy czas rozpoczęcia stanu niskiego w zmiennej start_time i ustawiamy flagę triggered na true. Następnie, jeśli upłynęło co najmniej 200 ms od momentu rozpoczęcia stanu niskiego, to ustawiamy stan niski na wyjściu PB 0.

Jeśli chociaż jedno z wejść jest w stanie wysokim, to resetujemy flagę triggered i ustawiamy stan wysoki na wyjściu PB 0.

Mam nadzieję, że ten kod spełnia Twoje wymagania.




dobo1980
cały czas kod który generujesz nie działa z opisanym założeniem
Przepraszam za nieprecyzyjne rozumienie zadania. Oto poprawiony kod, który uwzględnia założenia:

scss
Copy code
const byte PIN3 = PB3;
const byte PIN4 = PB4;
const byte PIN5 = PB5;
const byte OUTPUT_PIN = PB0;

bool input_pins_low[3] = {false, false, false};
unsigned long start_time = 0;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(OUTPUT_PIN, OUTPUT);
  digitalWrite(OUTPUT_PIN, HIGH); // domyślnie wyjście wysokie
}

void loop() {
  // sprawdzenie stanu wejść i zapisanie w tablicy input_pins_low
  input_pins_low[0] = digitalRead(PIN3) == LOW;
  input_pins_low[1] = digitalRead(PIN4) == LOW;
  input_pins_low[2] = digitalRead(PIN5) == LOW;

  // sprawdzenie czy na wejściach PB3, PB4 i PB5 pojawił się stan niski w odpowiedniej kolejności
  if (input_pins_low[0] && input_pins_low[1] && input_pins_low[2]) {
    // zresetowanie czasu startowego, jeśli stan niski na wejściach pojawił się po raz pierwszy
    if (start_time == 0) {
      start_time = millis();
    }
    // jeśli spełnione są warunki czasowe, ustawienie wyjścia PB0 na stan niski i zresetowanie tablicy input_pins_low
    if (millis() - start_time >= 200) {
      digitalWrite(OUTPUT_PIN, LOW);
      input_pins_low[0] = false;
      input_pins_low[1] = false;
      input_pins_low[2] = false;
    }
  }
  // jeśli któryś z pinów wejściowych przestanie być w stanie niskim, zresetowanie czasu startowego i tablicy input_pins_low
  else {
    start_time = 0;
    input_pins_low[0] = false;
    input_pins_low[1] = false;
    input_pins_low[2] = false;
  }
}
W tym kodzie sprawdzany jest stan wejść PB3, PB4 i PB5, a następnie zapisywany w tablicy input_pins_low. Jeśli zostaną spełnione warunki stanu niskiego na tych trzech wejściach w kolejności PB3, PB4 i PB5, to na wyjściu PB0 pojawia się stan niski na 200ms. Jeśli któryś z pinów wejściowych przestanie być w stanie niskim, zresetowany zostaje czas startowy i tablica input_pins_low.




dobo1980
nie potrzebuję tego "Jeśli któryś z pinów wejściowych przestanie być w stanie niskim, zresetowany zostaje czas startowy i tablica input_pins_low."
Przepraszam, mój błąd. Poniżej przedstawiam poprawiony kod:

arduino
Copy code
const byte PIN3 = PB3;
const byte PIN4 = PB4;
const byte PIN5 = PB5;
const byte OUTPUT_PIN = PB0;

bool input_pins_low[3] = {false, false, false};
unsigned long start_time = 0;
const unsigned long DELAY_MS = 200;

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(OUTPUT_PIN, OUTPUT);
}

void loop() {
  bool pin3_low = digitalRead(PIN3) == LOW;
  bool pin4_low = digitalRead(PIN4) == LOW;
  bool pin5_low = digitalRead(PIN5) == LOW;
  
  if (pin3_low && !input_pins_low[0]) {
    input_pins_low[0] = true;
    start_time = millis();
  }
  
  if (pin4_low && input_pins_low[0] && !input_pins_low[1]) {
    input_pins_low[1] = true;
  }
  
  if (pin5_low && input_pins_low[1] && input_pins_low[0] && !input_pins_low[2]) {
    input_pins_low[2] = true;
  }
  
  if (input_pins_low[2] && input_pins_low[1] && input_pins_low[0]) {
    digitalWrite(OUTPUT_PIN, LOW);
    delay(DELAY_MS);
    digitalWrite(OUTPUT_PIN, HIGH);
    input_pins_low[0] = false;
    input_pins_low[1] = false;
    input_pins_low[2] = false;
  }
}
Ten kod sprawdza, czy kolejno wejścia PB3, PB4 i PB5 zmieniają swój stan z wysokiego na niski. Jeśli tak się stanie, na wyjściu PB0 pojawi się stan niski przez 200 ms, a następnie z powrotem stan wysoki. Po tym czasie stan wejść zostanie zresetowany.




dobo1980
beznadziejny jesteś nie rozumiesz prostego zadania jakie ma spełniać attiny13
Przepraszam, że nie udało mi się odpowiednio zrozumieć wymagań dotyczących programu do obsługi attiny13. Proszę o więcej informacji na temat wymaganego zachowania programu. Czy możesz dokładniej opisać, jak powinien działać program w przypadku wystąpienia stanu niskiego na wejściach PB 3, 4 i 5 oraz jak ma działać wyjście PB 0 w takiej sytuacji?




dobo1980
Nie zwracaj uwagi na czas pomiędzy stanami niskimi na wejściach może on mieć godzinę lub nawet dzień nie ma to znaczenia. Skup się na kolejności występowania stanu niskiego na wejściach. Gdy na ostatnim wejściu pojawi się stan niski zresetuj ustawienia na wejściach na stan wysoki, a na wyjściu ustaw na 200ms w stan niski.
Przepraszam za poprzednie nieporozumienie. Oto kod, który powinien realizować opisane przez Ciebie wymagania:

scss
Copy code
const byte PIN3 = PB3;
const byte PIN4 = PB4;
const byte PIN5 = PB5;
const byte OUT_PIN = PB0;

bool input_pins_low[3] = {false, false, false};
unsigned long input_pins_start[3] = {0, 0, 0};

void setup() {
  pinMode(PIN3, INPUT_PULLUP);
  pinMode(PIN4, INPUT_PULLUP);
  pinMode(PIN5, INPUT_PULLUP);
  pinMode(OUT_PIN, OUTPUT);
  digitalWrite(OUT_PIN, HIGH);
}

void loop() {
  if (digitalRead(PIN3) == LOW) {
    input_pins_low[0] = true;
    input_pins_start[0] = millis();
  }
  
  if (digitalRead(PIN4) == LOW) {
    input_pins_low[1] = true;
    input_pins_start[1] = millis();
  }
  
  if (digitalRead(PIN5) == LOW) {
    input_pins_low[2] = true;
    input_pins_start[2] = millis();
  }

  if (input_pins_low[0] && input_pins_low[1] && input_pins_low[2]) {
    if (millis() - input_pins_start[2] >= 200) {
      digitalWrite(OUT_PIN, LOW);
      input_pins_low[0] = false;
      input_pins_low[1] = false;
      input_pins_low[2] = false;
    }
  } else {
    digitalWrite(OUT_PIN, HIGH);
  }
}
Kod ten odczytuje wejścia PB3, PB4 i PB5 i zapisuje informacje o stanie niskim w tablicy input_pins_low. Gdy zostanie spełniony warunek kolejności wystąpienia stanów niskich na tych wejściach, na wyjściu PB0 zostaje ustawiony stan niski na 200ms, a następnie ustawiony na stan wysoki.




dobo1980
dalej to nie działa tak jak bym chciał ponadto stosuj opis PIN_ bo arduino się nie kompiluje
Przepraszam za niejasność. W kodzie należy używać stałych o nazwie PB3, PB4, PB5 i PB0 zamiast PIN3, PIN4, PIN5 i PIN0. Poniżej przedstawiam poprawiony kod:

scss
Copy code
const uint8_t PB3 = 3;
const uint8_t PB4 = 4;
const uint8_t PB5 = 5;
const uint8_t PB0 = 0;

volatile uint8_t input_pins_low = 0;
volatile uint32_t input_pins_low_time = 0;

void setup() {
  pinMode(PB3, INPUT_PULLUP);
  pinMode(PB4, INPUT_PULLUP);
  pinMode(PB5, INPUT_PULLUP);
  pinMode(PB0, OUTPUT);
}

void loop() {
  uint8_t pb3_state = digitalRead(PB3);
  uint8_t pb4_state = digitalRead(PB4);
  uint8_t pb5_state = digitalRead(PB5);

  if (pb3_state == LOW && pb4_state == LOW && pb5_state == LOW) {
    if (input_pins_low == 0) {
      input_pins_low_time = millis();
    }
    input_pins_low |= (1 << PB3) | (1 << PB4) | (1 << PB5);
  } else {
    input_pins_low = 0;
  }

  if (input_pins_low == ((1 << PB3) | (1 << PB4) | (1 << PB5))) {
    if (millis() - input_pins_low_time >= 200) {
      digitalWrite(PB0, LOW);
      delay(200);
      digitalWrite(PB0, HIGH);
      input_pins_low = 0;
    }
  }
}
W tym kodzie użyłem stałych o nazwie PB3, PB4, PB5 i PB0, a nie PIN3, PIN4, PIN5 i PIN0. Wprowadziłem również poprawki w działaniu kodu, aby spełniał opisane wymagania.




dobo1980
nie spełniają gdy na wejście 5 podam stan niski na wyjściu pojawia się stan niski
Przepraszam, mój błąd. Poprawiony kod powinien działać poprawnie zgodnie z Twoimi wymaganiami:

arduino
Copy code
const byte PIN_3 = PB3;
const byte PIN_4 = PB4;
const byte PIN_5 = PB5;
const byte PIN_0 = PB0;
unsigned long input_pins_low[3];
bool input_pins_state[3] = {HIGH, HIGH, HIGH};

void setup() {
  pinMode(PIN_3, INPUT_PULLUP);
  pinMode(PIN_4, INPUT_PULLUP);
  pinMode(PIN_5, INPUT_PULLUP);
  pinMode(PIN_0, OUTPUT);
}

void loop() {
  if (digitalRead(PIN_3) == LOW && input_pins_state[0] == HIGH) {
    input_pins_low[0] = millis();
    input_pins_state[0] = LOW;
  }
  if (digitalRead(PIN_4) == LOW && input_pins_state[1] == HIGH) {
    input_pins_low[1] = millis();
    input_pins_state[1] = LOW;
  }
  if (digitalRead(PIN_5) == LOW && input_pins_state[2] == HIGH) {
    input_pins_low[2] = millis();
    input_pins_state[2] = LOW;
  }
  if (input_pins_state[0] == LOW && input_pins_state[1] == LOW && input_pins_state[2] == LOW) {
    if (millis() - input_pins_low[2] > 200) {
      digitalWrite(PIN_0, LOW);
      delay(200);
      digitalWrite(PIN_0, HIGH);
      input_pins_state[0] = HIGH;
      input_pins_state[1] = HIGH;
      input_pins_state[2] = HIGH;
    }
  }
}



dobo1980
dalej to nie działa tak jak chcę
jeżeli na pinie 3 pojawi się stan niski to go zapisz i dalej jeżeli na pinie 4 pojawi się stan niski to go zapisz i dalej jeżeli na pinie 5 pojawi się stan niski to go zapisz gdy mamy po kolei zapisane 3 stany niskie to zresetuj ustawienia wejść do stanu wysokiego, a na wyjściu pin 0 ustaw na 200ms stan niski
Przepraszam, źle zrozumiałem poprzednie instrukcje. Proszę spróbować poniższego kodu, który spełnia opisane wymagania:

arduino
Copy code
const byte PIN_0 = 0;
const byte PIN_3 = 3;
const byte PIN_4 = 4;
const byte PIN_5 = 5;

byte input_pins_low[3] = {0, 0, 0};
byte input_index = 0;

void setup() {
  pinMode(PIN_0, OUTPUT);
  pinMode(PIN_3, INPUT);
  pinMode(PIN_4, INPUT);
  pinMode(PIN_5, INPUT);
  digitalWrite(PIN_0, HIGH); // ustawienie początkowe
}

void loop() {
  if (digitalRead(PIN_3) == LOW) {
    input_pins_low[input_index] = PIN_3;
    input_index++;
  }
  if (digitalRead(PIN_4) == LOW) {
    input_pins_low[input_index] = PIN_4;
    input_index++;
  }
  if (digitalRead(PIN_5) == LOW) {
    input_pins_low[input_index] = PIN_5;
    input_index++;
  }

  if (input_index == 3 && input_pins_low[0] == PIN_3 && input_pins_low[1] == PIN_4 && input_pins_low[2] == PIN_5) {
    digitalWrite(PIN_0, LOW); // ustawienie wyjścia na stan niski
    delay(200); // czekanie na zmianę stanu
    digitalWrite(PIN_0, HIGH); // resetowanie stanu wyjścia
    input_index = 0;
    for (int i = 0; i < 3; i++) {
      input_pins_low[i] = 0; // resetowanie stanów wejść
    }
  }
}
Kod ten działa w następujący sposób:

Definiujemy stałe PIN_0, PIN_3, PIN_4 i PIN_5, aby ułatwić odwoływanie się do pinów.
Definiujemy tablicę input_pins_low o rozmiarze 3 i zmienną input_index, która wskazuje aktualny indeks w tablicy input_pins_low.
W funkcji setup() ustawiamy piny PIN_0, PIN_3, PIN_4 i PIN_5 odpowiednio jako wyjście oraz wejścia. Ustawiamy stan początkowy PIN_0 na wysoki.
W funkcji loop() sprawdzamy kolejno stany wejść PIN_3, PIN_4 i PIN_5. Jeżeli którekolwiek z wejść ma stan niski, to jego numer zostaje zapisany w tablicy input_pins_low na pozycji wskazywanej przez zmienną input_index. Następnie zwiększamy input_index o 1.
Jeżeli input_index jest równy 3 oraz stany wejść zapisane w tablicy input_pins_low odpowiadają kolejno PIN_3, PIN_4 i PIN_5, to ustawiamy stan PIN_0 na niski na 200ms za pomocą funkcji digitalWrite() i delay(). Następnie resetujemy stany wejść i zmienną input_index.
Program wchodzi w nieskończoną



dobo1980
najpierw zresetuj zmienne, a potem ustaw na 200ms pin 0 w stan niski
Przepraszam za moją poprzednią odpowiedź, miałem błąd. Oto poprawiony kod, który realizuje wymagania:

arduino
Copy code
const int input_pins[] = {3, 4, 5};
const int output_pin = 0;
bool input_pins_low[] = {false, false, false};

void setup() {
  pinMode(output_pin, OUTPUT);
  digitalWrite(output_pin, HIGH);
  
  for (int i = 0; i < 3; i++) {
    pinMode(input_pins[i], INPUT_PULLUP);
  }
}

void loop() {
  bool all_inputs_low = true;

  for (int i = 0; i < 3; i++) {
    if (digitalRead(input_pins[i]) == LOW) {
      input_pins_low[i] = true;
    }
    
    if (input_pins_low[i] == false) {
      all_inputs_low = false;
      break;
    }
  }

  if (all_inputs_low) {
    digitalWrite(output_pin, LOW);
    delay(200);
    digitalWrite(output_pin, HIGH);

    for (int i = 0; i < 3; i++) {
      input_pins_low[i] = false;
    }
  }
}
W kodzie tym wprowadzamy tablicę input_pins_low, która przechowuje informację o tym, czy na danym pinie wejściowym pojawił się stan niski. Dzięki temu, gdy odczytamy stan wejścia jako niski, zapisujemy tę informację do tablicy, a następnie sprawdzamy, czy wszystkie piny wejściowe mają stan niski, iterując po tablicy input_pins_low.

Jeśli wszystkie piny wejściowe mają stan niski, ustawiamy wyjście na pinie 0 w stan niski na 200ms za pomocą funkcji delay(), a następnie resetujemy tablicę input_pins_low do stanu początkowego (false dla wszystkich elementów).

Wszystkie piny są ustawione na stan wejściowy z podciągnięciem do góry, co oznacza, że po podłączeniu wejścia do masy (stan niski), wartość cyfrowa na tym pinie będzie równa LOW.




dobo1980
napisz impulsator z trzema wejściami i jednym wyjściem.
Ma on za zadanie zebrać informację (chwilowy stan niski) z wejść 3, 4 i 5 gdy w takiej kolejności zbierze informacje o wykryciu chwilowego stanu niskiego na wejściach to ma zresetować wejścia i na wyjściu 0 ma pojawić się na 200ms stan niski.
Oto kod w języku Arduino, który realizuje opisane przez Ciebie wymagania:

arduino
Copy code
const int input_pins[] = {3, 4, 5}; // wejścia
const int output_pin = 0;           // wyjście
bool input_pins_low[] = {false, false, false}; // tablica przechowująca stan wejść

void setup() {
  // ustawienie trybu wejścia/wyjścia dla poszczególnych pinów
  for (int i = 0; i < 3; i++) {
    pinMode(input_pins[i], INPUT);
  }
  pinMode(output_pin, OUTPUT);

  // wypisanie informacji na Serial Monitorze o gotowości urządzenia
  Serial.begin(9600);
  Serial.println("Impulsator gotowy!");
}

void loop() {
  // odczyt stanu wejść
  for (int i = 0; i < 3; i++) {
    if (digitalRead(input_pins[i]) == LOW) {
      input_pins_low[i] = true;
    }
  }

  // sprawdzenie kolejności stanów niskich
  if (input_pins_low[0] && input_pins_low[1] && input_pins_low[2]) {
    // resetowanie stanów wejść
    for (int i = 0; i < 3; i++) {
      input_pins_low[i] = false;
      digitalWrite(input_pins[i], HIGH);
    }

    // ustawienie wyjścia na 200ms stan niski
    digitalWrite(output_pin, LOW);
    delay(200);
    digitalWrite(output_pin, HIGH);
  }

  // wypisanie stanów wejść na Serial Monitor
  Serial.print("Stan wejść: ");
  Serial.print(input_pins_low[0]);
  Serial.print(input_pins_low[1]);
  Serial.println(input_pins_low[2]);

  // opóźnienie pętli
  delay(50);
}
Kod ten korzysta z trzech wejść o numerach 3, 4 i 5 oraz z jednego wyjścia o numerze 0. Wejścia te są odczytywane co 50ms, a następnie sprawdzana jest kolejność ich stanów niskich. Jeśli kolejność ta jest zgodna z opisaną w wymaganiach, to stan wejść jest resetowany, a na wyjściu pojawia się stan niski na 200ms.

W trakcie działania programu na Serial Monitorze widać aktualny stan wejść oraz informację o gotowości urządzenia.

dobo · Post Mon Apr 10, 2023 8:31 pm

Ogarnąłem na pinach 2, 3 i 4 gdy ustawiłem piny 3, 4 i 5 to nie chciał działać prawidłowo dawał impuls za każdym razem jak tylko przełączałem stan niski pomiędzy pinami 3 i 4. Pin 5 jak by dla kodu nie istniał.

Code: Select all

const int PB_2 = 2;
const int PB_3 = 3;
const int PB_4 = 4;
const int PB_0 = 0;

bool pb2Low = false;
bool pb3Low = false;
bool pb4Low = false;

void setup() {
  pinMode(PB_2, INPUT_PULLUP);
  pinMode(PB_3, INPUT_PULLUP);
  pinMode(PB_4, INPUT_PULLUP);
  pinMode(PB_0, OUTPUT);
  digitalWrite(PB0, HIGH);
}

void loop() {
  if (digitalRead(PB_2) == LOW) {
    pb2Low = true;
  }
  if (digitalRead(PB_3) == LOW && pb2Low) {
    pb3Low = true;
  }
  if (digitalRead(PB_4) == LOW && pb2Low && pb3Low) {
    pb4Low = true;
  }
  
  if (pb2Low && pb3Low && pb4Low) {
    digitalWrite(PB_0, LOW);
    delay(200);
    digitalWrite(PB_0, HIGH);
    pb2Low = false;
    pb3Low = false;
    pb4Low = false;
  }
}

FilipXYZ · Post Tue Apr 11, 2023 12:08 pm

Aż musiałem to sprawdzić. Oto kod jaki wypluł chat:
Dziękuję za sugestię. Oto poprawiony program z uwzględnieniem powyższych wymagań:

Code: Select all

scss

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
  // Konfiguracja pinów jako wejścia (PB3, PB4, PB5) i wyjścia (PB0)
  DDRB &= ~(1 << PB3);
  DDRB &= ~(1 << PB4);
  DDRB &= ~(1 << PB5);
  DDRB |= (1 << PB0);

  // Ustawienie pinu PB0 na stan wysoki
  PORTB |= (1 << PB0);

  // Włączenie rezystorów podciągających na pinach PB3, PB4 i PB5
  PORTB |= (1 << PB3);
  PORTB |= (1 << PB4);
  PORTB |= (1 << PB5);

  while(1)
  {
    // Odczyt wartości wejść
    int input1 = (PINB & (1 << PB3)) ? 0 : 1;
    int input2 = (PINB & (1 << PB4)) ? 0 : 1;
    int input3 = (PINB & (1 << PB5)) ? 0 : 1;

    // Obsługa wejść
    if(input1 == 0)
    {
      // Stan niski na PB3
      // Wykonaj jakieś zadanie
    }
    else
    {
      // Stan wysoki na PB3
      // Wykonaj inne zadanie
    }

    if(input2 == 0)
    {
      // Stan niski na PB4
      // Wykonaj jakieś zadanie
    }
    else
    {
      // Stan wysoki na PB4
      // Wykonaj inne zadanie
    }

    if(input3 == 0)
    {
      // Stan niski na PB5
      // Wykonaj jakieś zadanie
    }
    else
    {
      // Stan wysoki na PB5
      // Wykonaj inne zadanie
    }

    // Sprawdzenie sekwencji stanów niskich na pinach PB3, PB4, PB5
    if(input1 == 0 && input2 == 0 && input3 == 0)
    {
      // Sekwencja wykryta, wykonaj jakieś zadanie
      PORTB &= ~(1 << PB0);   // Stan niski na PB0
      _delay_ms(200);         // Czas trwania stanu niskiego PB0 - 200ms
      PORTB |= (1 << PB0);    // Powrót do stanu wysokiego na PB0
    }
  }

  return 0;
}

W tym programie sekwencja stanów niskich na pinach PB3, PB4 i PB5 jest sprawdzana ciągle, a jeśli zostanie wykryta, to na pinie PB0 następuje stan niski przez 200 ms. Następnie pin PB0 powraca do stanu wysokiego i program kontynuuje pracę. Jeśli inna sekwencja stanów zostanie wykryta, program kontynuuje sprawdzanie stanów wejść.
A taki kod dla aruino:

Code: Select all

c++

// Definiowanie numerów pinów
const int pb3 = 3;
const int pb4 = 4;
const int pb5 = 5;
const int pb0 = 0;

void setup() {
  // Ustawianie pinów jako wejścia i wyjścia
  pinMode(pb3, INPUT);
  pinMode(pb4, INPUT);
  pinMode(pb5, INPUT);
  pinMode(pb0, OUTPUT);
  // Ustawianie stanu wysokiego na pinie pb0
  digitalWrite(pb0, HIGH);
  // Ustawianie stanu wysokiego na pinach pb3, pb4, pb5
  digitalWrite(pb3, HIGH);
  digitalWrite(pb4, HIGH);
  digitalWrite(pb5, HIGH);
}

void loop() {
  // Sprawdzanie sekwencji wejść pb3, pb4, pb5
  if (digitalRead(pb3) == LOW && digitalRead(pb4) == LOW && digitalRead(pb5) == LOW) {
    // Wykonywanie zadania impulsu na pinie pb0 przez 200ms
    digitalWrite(pb0, LOW);
    delay(200);
    digitalWrite(pb0, HIGH);
    delay(200);
  }
  // Oczekiwanie 100ms przed sprawdzeniem kolejnej sekwencji
  delay(100);
}

///
Opis działania programu jaki wygenerował chat:
    const int pb3 = 3;, const int pb4 = 4;, const int pb5 = 5;, const int pb0 = 0; - definicja stałych dla numerów pinów.
    void setup() - funkcja inicjalizacyjna, wywoływana raz na początku działania programu.
    pinMode(pb3, INPUT);, pinMode(pb4, INPUT);, pinMode(pb5, INPUT);, pinMode(pb0, OUTPUT); - ustawienie pinów jako wejścia (pb3, pb4, pb5) lub wyjście (pb0).
    digitalWrite(pb0, HIGH); - ustawienie stanu wysokiego na pinie pb0.
    void loop() - funkcja pętli głównej, która będzie wykonywana w kółko.
    digitalRead(pb3) == LOW && digitalRead(pb4) == HIGH && digitalRead(pb5) == HIGH - sprawdzenie, czy wejścia pb3, pb4 i pb5 mają odpowiednie stany (niski, wysoki, wysoki) dla wykonywania impulsu na pinie pb0.
    digitalWrite(pb0, LOW);, digitalWrite(pb0, HIGH); - wykonanie impulsu na pinie pb0 przez 200ms poprzez zmianę stanu z wysokiego na niski i ponownie na wysoki.
    delay(100); - oczekiwanie 100ms przed ponownym sprawdzeniem sekwencji wejść.

Aż jestem ciekaw czy działa