ATNEL tech-forum

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-09-11T09:02:54+01:00

Przyznam się, że ja też zawsze chciałem zrobić model takiego skrzyżowania ze światłami, ale jak zwykle brak czasu. Więc w ramach ćwiczeń w programowaniu napisałem taki program do sterowania sygnalizatorami. Może komuś się to przyda.
[syntax=c]/* e-gadget.header
* main.c
*
* Created on: 2016-08-27
* Modyfied: 2016-08-27 21:38:29
* Author: Janusz M.
*
* Project name: "Skrzyzowanie_sygnalizacja"
*
* MCU: ATmega328P
* F_CPU: 16 000 000 Hz
*
* Flash: 1 458 bytes [ 4,4 % ]
* RAM: 10 bytes [ 0,5 % ]
* EEPROM: 0 bytes [ 0,0 % ]
*
*/

#include
#include
#include

#include "makra.h"

/* Podłączenie lamp sygnalizatorów do procesora */

#define K1_A_R_PORTD// Kierunek1_Auta_Red
#define K1_A_R_PIN0

#define K1_A_Y_PORTD// Kierunek1_Auta_Yellow
#define K1_A_Y_PIN1

#define K1_A_G_PORTD// Kierunek1_Auta_Green
#define K1_A_G_PIN2

#define K1_P_R_PORTD// Kierunek1_Piesi_Red
#define K1_P_R_PIN3

#define K1_P_G_PORTD// Kierunek1_Piesi_Green
#define K1_P_G_PIN4

#define K2_A_R_PORTD// Kierunek2_Auta_Red
#define K2_A_R_PIN5

#define K2_A_Y_PORTD// Kierunek2_Auta_Yellow
#define K2_A_Y_PIN6

#define K2_A_G_PORTD// Kierunek2_Auta_Green
#define K2_A_G_PIN7

#define K2_P_R_PORTB// Kierunek2_Piesi_Red
#define K2_P_R_PIN0

#define K2_P_G_PORTB// Kierunek2_Piesi_Green
#define K2_P_G_PIN1

/* Podłączenie przycisków */
#define SW_FLASH_PORTC// przycisk włączający tryb pulsującego żółtego światła
#define SW_FLASH_PIN0

#define SW_NORMAL_PORTC// przycisk włączający normalny tryb zmiany świateł
#define SW_NORMAL_PIN1

#define SW_K1P_PORTC// przycisk aktywujący zielone światło dla pieszych, dla kierunku 1
#define SW_K1P_PIN2

#define SW_K2P_PORTC// przycisk aktywujący zielone światło dla pieszych, dla kierunku 2
#define SW_K2P_PIN3

/* Podświetlenie przycisków */
#define LED_SW_K1P_PORTC// podświetlenie przycisku aktywacji świateł dla pieszych, dla kierunku 1
#define LED_SW_K1P_PIN4

#define LED_SW_K2P_PORTC// podświetlenie przycisku aktywacji świateł dla pieszych, dla kierunku 2
#define LED_SW_K2P_PIN5

/* Makra ułatwiające sterowanie światłami - stan niski włącza światło, stan wysoki wyłącza */

#define K1_A_R_ONPORT(K1_A_R_PORT) &= ~(1 << K1_A_R_PIN)// włączenie światła czerwonego dla samochodów, dla kierunku 1
#define K1_A_R_OFFPORT(K1_A_R_PORT) |= (1 << K1_A_R_PIN)// wyłączenie światła czerwonego dla samochodów, dla kierunku 1

#define K1_A_Y_ONPORT(K1_A_Y_PORT) &= ~(1 << K1_A_Y_PIN)// włączenie światła żółtego dla samochodów, dla kierunku 1
#define K1_A_Y_OFFPORT(K1_A_Y_PORT) |= (1 << K1_A_Y_PIN)// wyłączenie światła żółtego dla samochodów, dla kierunku 1

#define K1_A_G_ONPORT(K1_A_G_PORT) &= ~(1 << K1_A_G_PIN)// włączenie światła zielonego dla samochodów, dla kierunku 1
#define K1_A_G_OFFPORT(K1_A_G_PORT) |= (1 << K1_A_G_PIN)// wyłączenie światła zielonego dla samochodów, dla kierunku 1

#define K1_P_R_ONPORT(K1_P_R_PORT) &= ~(1 << K1_P_R_PIN)// włączenie światła czerwonego dla pieszych, dla kierunku 1
#define K1_P_R_OFFPORT(K1_P_R_PORT) |= (1 << K1_P_R_PIN)// wyłączenie światła czerwonego dla pieszych, dla kierunku 1

#define K1_P_G_ONPORT(K1_P_G_PORT) &= ~(1 << K1_P_G_PIN)// włączenie światła zielonego dla pieszych, dla kierunku 1
#define K1_P_G_OFFPORT(K1_P_G_PORT) |= (1 << K1_P_G_PIN)// wyłączenie światła zielonego dla pieszych, dla kierunku 1

#define K2_A_R_ONPORT(K2_A_R_PORT) &= ~(1 << K2_A_R_PIN)// włączenie światła czerwonego dla samochodów, dla kierunku 2
#define K2_A_R_OFFPORT(K2_A_R_PORT) |= (1 << K2_A_R_PIN)// wyłączenie światła czerwonego dla samochodów, dla kierunku 2

#define K2_A_Y_ONPORT(K2_A_Y_PORT) &= ~(1 << K2_A_Y_PIN)// włączenie światła żółtego dla samochodów, dla kierunku 2
#define K2_A_Y_OFFPORT(K2_A_Y_PORT) |= (1 << K2_A_Y_PIN)// wyłączenie światła żółtego dla samochodów, dla kierunku 2

#define K2_A_G_ONPORT(K2_A_G_PORT) &= ~(1 << K2_A_G_PIN)// włączenie światła zielonego dla samochodów, dla kierunku 2
#define K2_A_G_OFFPORT(K2_A_G_PORT) |= (1 << K2_A_G_PIN)// wyłączenie światła zielonego dla samochodów, dla kierunku 2

#define K2_P_R_ONPORT(K2_P_R_PORT) &= ~(1 << K2_P_R_PIN)// włączenie światła czerwonego dla pieszych, dla kierunku 2
#define K2_P_R_OFFPORT(K2_P_R_PORT) |= (1 << K2_P_R_PIN)// wyłączenie światła czerwonego dla pieszych, dla kierunku 2

#define K2_P_G_ONPORT(K2_P_G_PORT) &= ~(1 << K2_P_G_PIN)// włączenie światła zielonego dla pieszych, dla kierunku 2
#define K2_P_G_OFFPORT(K2_P_G_PORT) |= (1 << K2_P_G_PIN)// wyłączenie światła zielonego dla pieszych, dla kierunku 2

#define K12_A_Y_ONPORT(K1_A_Y_PORT) &= ~(1 << K1_A_Y_PIN); PORT(K2_A_Y_PORT) &= ~(1 << K2_A_Y_PIN)// włączenie światła żółtego dla samochodów, dla wszystkich kierunków
#define K12_A_Y_OFFPORT(K1_A_Y_PORT) |= (1 << K1_A_Y_PIN); PORT(K2_A_Y_PORT) |= (1 << K2_A_Y_PIN)// wyłączenie światła żółtego dla samochodów, dla wszystkich kierunków

#define LED_SW_K1P_OFFPORT(LED_SW_K1P_PORT) |= (1 << LED_SW_K1P_PIN)// wyłączenie podświetlania przycisku aktywacji światła zielonego dla pieszych, dla kierunku 1
#define LED_SW_K2P_OFFPORT(LED_SW_K2P_PORT) |= (1 << LED_SW_K2P_PIN)// wyłączenie podświetlania przycisku aktywacji światła zielonego dla pieszych, dla kierunku 2
#define LED_SW_K1P_ONPORT(LED_SW_K1P_PORT) &= ~(1 << LED_SW_K1P_PIN)// włączenie podświetlania przycisku aktywacji światła zielonego dla pieszych, dla kierunku 1
#define LED_SW_K2P_ONPORT(LED_SW_K2P_PORT) &= ~(1 << LED_SW_K2P_PIN)// włączenie podświetlania przycisku aktywacji światła zielonego dla pieszych, dla kierunku 2
#define FLASH_SW_K1PPORT(LED_SW_K1P_PORT) ^= (1 << LED_SW_K1P_PIN)// miganie podświetlaniem przycisku aktywacji światła zielonego dla pieszych, dla kierunku 1
#define FLASH_SW_K2PPORT(LED_SW_K2P_PORT) ^= (1 << LED_SW_K2P_PIN)// miganie podświetlaniem przycisku aktywacji światła zielonego dla pieszych, dla kierunku 2

/* definicje czsów poszczególnych cykli w ms * 10 */
#define T_K1_G800// czas trwania zielonego światła dla kierunku 1
#define T_K2_G800// czas trwania zielonego światła dla kierunku 2
#define T_P30// czas pojedynczego mignięcia światła zielonego dla pieszych (czas świecenia, czas przerwy jest taki sam)
#define T_Y300// czas trwania światła żółtego
#define T_R100// czas trwania światła czerwonego dla wszystkich kierunków
#define N_MIGNIEC4// liczba mignięc światła zielonego dla pieszych

#define T_TEST1000// czas w ms włączenia kolejnych lamp w teście

/* Informacja o źle dobranym czasie trwania światła zielonego dla poszczególnych kierunków,
* jeśli całkowity czas cyklu migania światła zielonego dla pieszych będzie dłuższy lub równy czasowi trwania światła zielonego dla aut */
#if(T_K1_G <= N_MIGNIEC * 2 * T_P)
#error Źle dobrany czas T_K1_G w stosunku do N_MIGNIEC i T_P
#endif

#if(T_K2_G <= N_MIGNIEC * 2 * T_P)
#error Źle dobrany czas T_K2_G w stosunku do N_MIGNIEC i T_P
#endif

/* Funkcja inicjalizująca piny do których podłączone są lampy sygnalizatorów i przyciski */
void lamp_port_init(void);

/* Funkcja testowa podłączenia lamp sygnalizatorów
* Kolejno zapalane bedą na czas T_TEST światła sygnalizatorów i podświetlenia przycisków
*/
void lamp_test(void);

/* Funkcja wyłączająca wszystkie światła */
void lamps_off(void);

/* Zmienne globalne */
uint8_t tryb_pracy = 0;// dla wartości 0, 1, 2 - pulsujące żółte, dla wartości 3, 4 - rormalny cykl zmiany świateł
uint8_t sekwencja = 0;// numer sekwencji układu świateł
uint8_t n_powtorzen = 0;// licznik powtórzeń migającego zielonego dla pieszych
uint8_t k1p = 0;// flaga wciśniętego przycisku dla pieszych dla kierunku 1
uint8_t k2p = 0;// flaga wciśniętego przycisku dla pieszych dla kierunku 2
uint8_t sw_flash = 0;// flaga wciśniętego przycisku SW_FLASH
volatile uint16_t Timer1, Timer2;// Timer1 odmierza czasy przełączania swiateł sygnalizatorów,
// Timer2 miganie podświetlania przycisków aktywujących zielone światło dla pieszych

int main(void) {

// inicjalizacja portów mikrokontrolera
lamp_port_init();

// konfiguracja timera programowego
TCCR1B |= (1 << WGM12);// tryb pracy CTC
TCCR1B |= (1 << CS12);// prescaler = 256
OCR1A = 624;// przerwanie co 10 ms dla F_CPU = 16 MHz
TIMSK1 |= (1 << OCIE1A);// odblokowanie przerwania CompareMatch

// włączenie przerwań
sei();

while(1) {
/***** sprawdzenie stanu przycisków *****/
if(!(PIN(SW_FLASH_PORT) & (1 << SW_FLASH_PIN))) sw_flash = 1;// jeśli wciśnięty przycisk SW_FLASH, ustaw flagę sw_flash
if(!(PIN(SW_NORMAL_PORT) & (1 << SW_NORMAL_PIN)) && (tryb_pracy == 1 || tryb_pracy == 2)) {// jeśli wciśnięty przycisk SW_NORMAL i układ w trybie
// żółtego światła pulsującego
tryb_pracy = 3;// ustaw tryb pracy na 3
sekwencja = 0;// zeruj zmienną sekwencja
sw_flash = 0;// zeruj flagę sw_flash
}
// jeśli wciśnięty przycisk aktywujący zielone światło dla pieszych dla kierunku1, ustaw flagę k1p
if(!(PIN(SW_K1P_PORT) & (1 << SW_K1P_PIN)) && tryb_pracy == 4) k1p = 1;
// jeśli wciśnięty przycisk aktywujący zielone światło dla pieszych dla kierunku2, ustaw flagę k2p
if(!(PIN(SW_K2P_PORT) & (1 << SW_K2P_PIN)) && tryb_pracy == 4) k2p = 1;

/***** sterowanie podświetleniem przycisków aktywujących zielone światło dla pieszych *****/
if(Timer2 == 0) {
Timer2 = 30;// czas migania światła
if(k1p) FLASH_SW_K1P;// jeśli ustawiona flaga wciśnięcia przycisku SW_K1P, zmień stan podświetlania przycisku na przeciwny
else
LED_SW_K1P_OFF;// jeśli flaga wciśnięcia przycisku SW_K1P wyzerowana, wyłącz podswietlanie przycisku

if(k2p) FLASH_SW_K2P;// jeśli ustawiona flaga wciśnięcia przycisku SW_K2P, zmień stan podświetlania przycisku na przeciwny
else
LED_SW_K2P_OFF;// jeśli flaga wciśnięcia przycisku SW_K2P wyzerowana, wyłącz podswietlanie przycisku
}

/**** tryb pulsującego żółtego światła *****/
if(tryb_pracy == 0 && Timer1 == 0) {
lamps_off();// wyłącz wszystkie światła
k1p = 0;// zeruj flagi wciśnięcia przycisków aktywujących zielone światło dla pieszych
k2p = 0;
tryb_pracy = 1;// ustaw tryb pracy 1
}
// żółte światło ostrzegawcze powinno pulsowac z częstotliwością 2 Hz i czas włączenia do czasu wyłączenia powinien wynosic 0.6 : 0.4
if(tryb_pracy == 1 && Timer1 == 0) {// jeśli ustawiony jest tryb pracy 1 i minął czas 0.2 s
Timer1 = 30;// wpisz do Timera1 czas 300 ms
K12_A_Y_ON;// włącz żółte światła
tryb_pracy = 2;// ustaw tryb pracy 2
}

if(tryb_pracy == 2 && Timer1 == 0) {// jeśli ustawiony jest tryb pracy 2 i minął czas 0.3 s
Timer1 = 20;// wpisz do Timera1 czas 200 ms
K12_A_Y_OFF;// wyłącz światła żółte
tryb_pracy = 1;// ustaw tryb pracy 1
}

/***** wstępne ustawienie świateł przy przejściu od trybu pulsującego żółtego do trybu normalnej zmiany świateł *****/
if(tryb_pracy == 3) {
Timer1 = 300;// wpisz do timera1 czas 3 s
K1_A_Y_ON;// dla Kierunku1, dla Aut, Yellow - żółte światło, ON - włącz
K1_P_R_ON;// dla Kierunku1, dla Pieszych, Red - czerwone światło, ON - włącz
K2_A_Y_ON;// dla Kierunku2, dla Aut, Yellow - żółte światło, ON - włącz
K2_P_R_ON;// dla Kierunku2, dla Pieszych, Red - czerwone światło, ON - włącz
tryb_pracy = 4;// ustaw tryb pracy 3
}

/***** tryb normalnego działania sygnalizacji świetlnej *****/
if(tryb_pracy == 4 && Timer1 == 0) {// jeśli ustawiony tryb normalnej zmiany świateł i odliczony został kolejny czas
switch(sekwencja) {// ustaw odpowiednią kombinację świateł w zależności od numeru sekwencji
case 0:
Timer1 = T_R;// wpisz do Timera1 czas trwania światła czerwonego dla obydwu kierunków
sekwencja = 1;// wpisz numer kolejnej do wykonania sekwencji świateł
K1_A_R_ON;// dla Kierunku1, dla Aut, Red - czerwone światło, ON - włącz
K1_A_Y_OFF;// dla Kierunku1, dla Aut, Yellow - żółte światło, OFF - wyłącz
K1_A_G_OFF;// dla Kierunku1, dla Aut, Green - zielone światło, OFF - wyłącz
K1_P_R_ON;// dla Kierunku1, dla Pieszych, Red - czerwone światło, ON - włącz
K1_P_G_OFF;// dla Kierunku1, dla Pieszych, Green - zielone światło, OFF - wyłącz

K2_A_R_ON;// itd...
K2_A_Y_ON;
K2_A_G_OFF;
K2_P_R_ON;
K2_P_G_OFF;
break;

case 1:
if(k2p) {// jeśli ustawiona flaga wciśnięcia przycisku aktywacji zielonego światła dla pieszych, dla kierunku 2
Timer1 = (T_K2_G - N_MIGNIEC * 2 * T_P); // wpisz do Timera1 czas trwania swiatła zielonego dla kierunku 2,
// pomniejszony o czas trwania sekwencji migania światła zielonego dla pieszych
sekwencja = 2;// ustaw numer następnej sekwencji do wykonania
K2_A_R_OFF;// ustaw odpowiednio światła sygnalizatorów
K2_A_Y_OFF;
K2_A_G_ON;
K2_P_R_OFF;
K2_P_G_ON;
k2p = 0;// zeruj flagę wciśnięcia przycisku aktywacji zielonego światła dla pieszych dla kierunku 2
break;
}
else {// jesli flaga nie ustawiona
Timer1 = T_K2_G;// wpisz do Timera1 czas trwania zielonego światła dla kierunku 2
sekwencja = 4;// ustaw numer następnej sekwencji
K2_A_R_OFF;// ustaw odpowiednio światła sygnalizatorów
K2_A_Y_OFF;
K2_A_G_ON;
break;
}

case 2:// sekwencja migania zielonego światła dla pieszych dla kierunku 2
Timer1 = T_P;
if(n_powtorzen == N_MIGNIEC) sekwencja = 4;
else
sekwencja = 3;
K2_P_G_OFF;
break;

case 3:// sekwencja migania zielonego światła dla pieszych dla kierunku 2
Timer1 = T_P;
sekwencja = 2;
n_powtorzen++;
K2_P_G_ON;
break;

case 4:
Timer1 = T_Y;
sekwencja = 5;
n_powtorzen = 0;
K2_A_Y_ON;
K2_A_G_OFF;
K2_P_R_ON;
break;

case 5:
Timer1 = T_R;
sekwencja = 6;
K2_A_R_ON;
K2_A_Y_OFF;
if(sw_flash) tryb_pracy = 0;// sprawdzenie czy nie został wciśnięty przycisk trybu pulsującego światła żoltego
break;

case 6:
Timer1 = T_R;
sekwencja = 7;
K1_A_Y_ON;
break;

case 7:
if(k1p) {// jeśli ustawiona flaga wciśnięcia przycisku aktywacji zielonego światła dla pieszych, dla kierunku 1
Timer1 = (T_K1_G - N_MIGNIEC * 2 * T_P);
sekwencja = 8;
K1_A_R_OFF;
K1_A_Y_OFF;
K1_A_G_ON;
K1_P_R_OFF;
K1_P_G_ON;
k1p = 0;
break;
}
else {
Timer1 = T_K1_G;
sekwencja = 10;
K1_A_R_OFF;
K1_A_Y_OFF;
K1_A_G_ON;
break;
}

case 8:// sekwencja migania zielonego światła dla pieszych dla kierunku 1
Timer1 = T_P;
if(n_powtorzen == N_MIGNIEC) sekwencja = 10;
else
sekwencja = 9;
K1_P_G_OFF;
break;

case 9:// sekwencja migania zielonego światła dla pieszych dla kierunku 1
Timer1 = T_P;
sekwencja = 8;
n_powtorzen++;
K1_P_G_ON;
break;

case 10:
Timer1 = T_Y;
sekwencja = 11;
n_powtorzen = 0;
K1_A_Y_ON;
K1_A_G_OFF;
K1_P_R_ON;
break;

case 11:
Timer1 = T_R;
sekwencja = 0;// koniec pełnego cyklu zmiany świateł
K1_A_R_ON;
K1_A_Y_OFF;
if(sw_flash) tryb_pracy = 0;// sprawdzenie czy nie został wciśnięty przycisk trybu pulsującego światła żoltego
break;
}
}
}
}

/* Obsługa przerwania */
ISR(TIMER1_COMPA_vect)
{
uint16_t x;

x = Timer1;
if(x) Timer1 = --x;

x = Timer2;
if(x) Timer2 = --x;
}

/* Inicjalizacja portów */
void lamp_port_init(void) {
// podciągnięcie pinów przycisków do Vcc
PORT(SW_FLASH_PORT) |= (1 << SW_FLASH_PIN);
PORT(SW_NORMAL_PORT) |= (1 << SW_NORMAL_PIN);
PORT(SW_K1P_PORT) |= (1 << SW_K1P_PIN);
PORT(SW_K2P_PORT) |= (1 << SW_K2P_PIN);

// ustawiamy odpowiednie piny jako wyjście
DDR(K1_A_R_PORT) |= (1 << K1_A_R_PIN);
DDR(K1_A_Y_PORT) |= (1 << K1_A_Y_PIN);
DDR(K1_A_G_PORT) |= (1 << K1_A_G_PIN);
DDR(K1_P_R_PORT) |= (1 << K1_P_R_PIN);
DDR(K1_P_G_PORT) |= (1 << K1_P_G_PIN);

DDR(K2_A_R_PORT) |= (1 << K2_A_R_PIN);
DDR(K2_A_Y_PORT) |= (1 << K2_A_Y_PIN);
DDR(K2_A_G_PORT) |= (1 << K2_A_G_PIN);
DDR(K2_P_R_PORT) |= (1 << K2_P_R_PIN);
DDR(K2_P_G_PORT) |= (1 << K2_P_G_PIN);

DDR(LED_SW_K1P_PORT) |= (1 << LED_SW_K1P_PIN);
DDR(LED_SW_K2P_PORT) |= (1 << LED_SW_K2P_PIN);

// wyłączamy wszystkie lampy
lamps_off();

// sprawdzimy czy wszystko jest dobrze podłączone
lamp_test();

}

/* Testowanie lamp */
void lamp_test(void) {
K1_A_R_ON;
_delay_ms(T_TEST);
K1_A_R_OFF;
K1_A_Y_ON;
_delay_ms(T_TEST);
K1_A_Y_OFF;
K1_A_G_ON;
_delay_ms(T_TEST);
K1_A_G_OFF;
K1_P_R_ON;
_delay_ms(T_TEST);
K1_P_R_OFF;
K1_P_G_ON;
_delay_ms(T_TEST);
K1_P_G_OFF;
_delay_ms(T_TEST);
LED_SW_K1P_ON;
_delay_ms(T_TEST);
LED_SW_K1P_OFF;
_delay_ms(2 * T_TEST);
K2_A_R_ON;
_delay_ms(T_TEST);
K2_A_R_OFF;
K2_A_Y_ON;
_delay_ms(T_TEST);
K2_A_Y_OFF;
K2_A_G_ON;
_delay_ms(T_TEST);
K2_A_G_OFF;
K2_P_R_ON;
_delay_ms(T_TEST);
K2_P_R_OFF;
K2_P_G_ON;
_delay_ms(T_TEST);
K2_P_G_OFF;
_delay_ms(T_TEST);
LED_SW_K2P_ON;
_delay_ms(T_TEST);
LED_SW_K2P_OFF;
_delay_ms(2 * T_TEST);
}

void lamps_off(void) {
K1_A_R_OFF;
K1_A_Y_OFF;
K1_A_G_OFF;
K1_P_R_OFF;
K1_P_G_OFF;

K2_A_R_OFF;
K2_A_Y_OFF;
K2_A_G_OFF;
K2_P_R_OFF;
K2_P_G_OFF;

LED_SW_K1P_OFF;
LED_SW_K2P_OFF;
}[/syntax]
[syntax=c]/*
* makra.h
*
* Created on: 2012-08-23
* Author: Janusz M.
*/

#ifndef MAKRA_H_
#define MAKRA_H_

// Makra upraszczające dostęp do portów
// *** PORT
#define PORT(x) XPORT(x)
#define XPORT(x) (PORT##x)
// *** PIN
#define PIN(x) XPIN(x)
#define XPIN(x) (PIN##x)
// *** DDR
#define DDR(x) XDDR(x)
#define XDDR(x) (DDR##x)

#endif /* MAKRA_H_ */[/syntax]

Statystyki: Napisane przez janusz17 — 11 wrz 2016, o 09:02

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-09T08:26:36+01:00

Dokładnie puki co pracuje nad programem co niejako jest ćwiczeniem, jak tylko rozbuduje makietę wtedy będę mógł sprawdzić na żyjącym organizmie i wtedy pewne nowe kłopoty wypłyną, czyli nowe wyzwania.

Statystyki: Napisane przez black_currant — 9 sie 2016, o 08:26

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-05T02:54:56+01:00

Instrukcje zerujące rejestr licznika TCNT0 z linii 23 oraz 104 możesz śmiało usunąć. Stan tego rejestru po włączeniu zasilania układu oraz po resecie wynosi 0, zaś po przepełnieniu się tego rejestru licznik zaczyna zliczać od zera, gdyż jego pojemność wynosi 8 bitów.

Stosuj makra i/lub typy wyliczeniowe enum, które zwiększą czytelność programu. Obecnie można jedynie zgadywać, które światła sterowane są którymi pinami układu. Staraj się, by wiersze w edytorze nie były dłuższe niż 80 znaków. To również ułatwia czytanie kodu.

Jeden wielki switch w pętli głównej nie jest najszczęśliwszym rozwiązaniem. Owszem, działa, ale z fajnym programem ma niewiele wspólnego. Postaraj się podzielić kod na funkcje, w ten sposób ograniczysz również dublujące się instrukcje.

Pozdrawiam.

PS. Ćwicz, ćwicz... przez ćwiczenia do mistrzostwa. Zaczynałem bardzo podobnie

Statystyki: Napisane przez skandal_obyczajowy — 5 sie 2016, o 02:54

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-03T13:44:41+01:00

Racja. Kilka razy o ty czytałem, oglądałem filmik o maskowaniu bitów, wydawało mi się że mnie to nie spotka. Ale chyba na tym polega nauka. Poprawiłem program , na szybko zaadaptowałem obsługę przycisku i o dziwo działa. Żadnych samoczynnych nie planowanych zmian stanów, i dziwnych zachowań programu. Zamierzam rozszerzyć całość i rozbudować, ale bazę mam już solidną.

Wielkie dzięki za pomoc i sugestie. Jeśli uda mi się domknąć całość wrzucę na forum może się komuś przyda.

Ostateczny działający program:

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;
int przycisk;

int main(void)

{

// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
// timer
TIMSK |= (1< TCCR0 |= (1< TCNT0 = 0; //początkowa wartość licznika

przycisk=0;

sei();

while(1)

{

if( !(PIND & (1<{
przycisk=1;
}

switch(cnt)

{

case 80:// 1 krok : zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
//PORTC &= ~((1<PORTC |= (1<PORTB |= (1<PORTD |= (1<break;

case 180:
if(przycisk==1)//kiedy przycisk==1
{
PORTD &= ~((1<PORTD |= (1<przycisk=0;
}
break;

case 280 : //2 krok : zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
//przycisk=0;
PORTC |= (1<PORTB &= ~((1<PORTB |= (1<PORTD &= ~((1<PORTD |= (1<break;

case 480: //3 krok : czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
//przycisk=0;
PORTC &= ~((1<PORTC |= (1<PORTB &= ~((1<PORTB |= (1<PORTD |= (1<break;

case 680: //4 krok : czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
//przycisk=0;
PORTC &= ~((1<PORTC |= (1<PORTB |= (1<PORTD |= (1<//cnt=80;
break;

case 880: //5 krok : zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
//przycisk=0;
PORTC &= ~((1<PORTC |= (1<PORTB &= ~((1<PORTB |= (1<PORTD |= (1<cnt=0;
break;

}

}

}

ISR(TIMER0_OVF_vect)//procedura obsługi przerwania od przepełnienia timera

{
TCNT0 = 0;
cnt++;
}[/syntax]

Statystyki: Napisane przez black_currant — 3 sie 2016, o 13:44

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-02T13:37:36+01:00

A ten przycisk podłaczony do pinu PD4, to masz podciągnięty rezystorem zewnętrznym do Vcc? Bo jeśli nie to pojawiają się tam przypadkowe stany i nawet nie przyciskając przycisku możesz mieć tam stan niski.
Myślę, że chciałeś raczej podciągać ten pin programowo, bo wpisujesz jedynkę do portu na samym początku przy konfiguracji portów. Ale popatrz teraz na koniec programu. Wpisujesz do portu D wartość 0 na wszystkich pinach. I tak po pierwszym obiegu pętli while, podciągania wejścia do Vcc już nie ma.
To jest właśnie przykład na to, że dobrze się nauczyć pewnych zasad poprawnego pisania kodu. Jedną z tych zasad jest to, aby nie ustawiać stanów portu przez wpisywanie konkretnej liczby. Powinno się to robić tak aby zmiany jednego czy kilku pinów nie zmieniały pozostałych.
[syntax=c]// np. ustawienie stanu wysokiego na pinie 2 portu D
PORTD |= (1 << PD2);
// zerowanie tego pinu
PORTD &= ~(1 << PD2);[/syntax]

Statystyki: Napisane przez janusz17 — 2 sie 2016, o 13:37

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-02T06:54:06+01:00

Jeśli chodzi o zerowanie flagi to wykonuje się w kroku drugim (case 280), tylko odnoszę wrażenie, że nie do końca się to sprawdza. Czasami kiedy program zrobi jeden pełen obieg i nie zostanie wciśnięty przycisk to przy następnym obiegu reaguje jak był by wciśnięty, podejrzewam że mam jakieś błędy składniowe i staram się je namierzyć.

Program wgrywam z eclipsy za pomocą atnelowskiego ATB-USBASP, cały układ mam na stykówce. Wiem że stykówki mają opinie wysoce nie stabilnych i awaryjnych, ale moje problemy mają dość stały charakter i co jakiś czas sprawdzam sobie na przykład działanie samego przycisku na innym programie, więc fizycznie powinno być ok.

#

Poniżej program który ma za zadanie skrócić czas trwania pętli jeśli wciśnie się przycisk, dodaje do wartości zmiennej i 100. Pierwszy obieg trwa około 34 sekundy, a następny nawet jak nie jest wciśnięty przycisk już tylko 2 sekundy. Wygląda to taj jak by po wciśnięciu przycisku lub jednym obiegu głównej pętli przycisk na stałe miał wartość 1. To chyba z powodu problemu z wyzerowaniem przycisku mam kłopoty z tą sygnalizacją.

[syntax=cpp]#include
#include
#include

int przycisk;
int i;

int main(void)
{
//************************ustawienia portow
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
while(1)
{

i=0;//zmienna i uzywana w petli

//************************petla ktora podczas wykonywania sprawdza stan przycisku

while(i<200)//ilosc petli ktora determinuje czas zapalenia diod
{
if( !(PIND & (1<{
przycisk=1;
}

if(przycisk==1)//jesli przycisk==1 to zmienna i zwieksza o 100
{
i=i+100;
}
PORTC = 0b11111111;//zapalenie diod na portach c ib
PORTB = 0b11111111;
_delay_ms(500);
i++;
}

i=0;//po wykonaniu petli zeruja sie zmienn i , przycisk
przycisk=0;
PORTC = 0b00000000;//gasna diody
PORTB = 0b00000000;
PORTD = 0b11111111;//zapala sie port c aby widoczny byl koniec petli
_delay_ms(3000);
PORTD = 0b0000000;

}
}[/syntax]

Statystyki: Napisane przez black_currant — 2 sie 2016, o 06:54

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-01T13:41:31+01:00

Quote:

nie jestem pewien czy takie wplatanie przycisków w procedury przerwań nie jest dla nich zbyt dużym obciążeniem?

Ale w tym wariancie obsługę przycisku masz wstawioną w pętli głównej.
Mnie tu brakuje tylko zerowania flagi wciśnietego przycisku. No bo teraz jak juz raz wciśniesz przycisk to ta flaga przycisk jest ustawiana na 1 i tak trwa w nieskończoność. Trzeba by ją wyzerować w tym if sprawdzającym czy ona jest ustawiona.

Quote:

I jeszcze jedno techniczne pytanie: czy to normalne że nie zawsze wgrywa mi się program do mikrokontrolera? Naciskam upload i proces wykonuje się poprawnie ale zawartość jednostki się nie zmienia, dopiero za drugim lub trzecim razem jest ok. Na początku wprowadzało to sporo zamętu.

To napewno nie jest normalne. A czym wgrywasz program do procka? I jak masz wogóle ten układ zrobiony (na zestawie ATB, stykówce, płytka drukowana...)?

Statystyki: Napisane przez janusz17 — 1 sie 2016, o 13:41

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-08-01T11:31:30+01:00

Rzeczywiście mój błąd, całość działa poprawnie aż do momentu próby dodania obsługi przycisku. Kiedy w drugim kroku dodaje instrukcje która ma się spełnić dopiero po wciśnięciu przycisku to wykonuje się ona od razu. Nie wiem czy źle interpretuje zasadę działania, sama instrukcja do obsługi przycisku działa poprawnie w innym programie.

Cały czas kłopoty napotykam przy łączeniu obsługi przycisku i przerwań. nie jestem pewien czy takie wplatanie przycisków w procedury przerwań nie jest dla nich zbyt dużym obciążeniem?

I jeszcze jedno techniczne pytanie: czy to normalne że nie zawsze wgrywa mi się program do mikrokontrolera? Naciskam upload i proces wykonuje się poprawnie ale zawartość jednostki się nie zmienia, dopiero za drugim lub trzecim razem jest ok. Na początku wprowadzało to sporo zamętu.

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;
int przycisk;

int main(void)

{

// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
// timer
TIMSK |= (1< TCCR0 |= (1< TCNT0 = 0; //początkowa wartość licznika

przycisk=0;

sei();

while(1)

{

if( !(PIND & (1<{
przycisk=1;
}

switch(cnt)

{

case 80:// 1 krok : zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001010;
break;

case 180:
if(przycisk==1)//kiedy przycisk=1
{
PORTD = 0b00000101;
}
break;

case 280 : //2 krok : zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
przycisk=0;
PORTC = 0b00110110;
PORTB = 0b00010010;
PORTD = 0b00001010;
break;

case 480: //3 krok : czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
PORTC = 0b00001001;
PORTB = 0b00100100;
PORTD = 0b00001010;
break;

case 680: //4 krok : czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
PORTC = 0b00010010;
PORTB = 0b00110110;
PORTD = 0b00001010;
break;

case 880: //5 krok : zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001010;
cnt=0;
break;

}

}

}

ISR(TIMER0_OVF_vect)//procedura obsługi przerwania od przepełnienia timera

{
TCNT0 = 0;
cnt++;
}[/syntax]

Statystyki: Napisane przez black_currant — 1 sie 2016, o 11:31

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-28T14:26:01+01:00

No jak miała by działać ta pierwsza wersja skoro w pętli głównej wstawiłeś while(1); Czyli po inicjalizacji portów i timera nic się już dalej nie wykonuje oprócz oczywiście zwiększania cnt w przerwaniu. Ale jeśli usuniesz średnik za while, to zapewne i ta wersja będzie działać. A w obsłudze przerwania naprawdę wstawia się możliwie najkrótszy kod.

Statystyki: Napisane przez janusz17 — 28 lip 2016, o 14:26

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-27T10:41:21+01:00

Zrobiłem jak zasugerowałeś, jednak układ nie reaguje, nie wykonuje się żaden krok programu.

Poniżej kod:

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;
int przycisk;

int main(void)

{

// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
// timer
TIMSK |= (1< TCCR0 |= (1< TCNT0 = 0; //początkowa wartość licznika

przycisk=0;

sei();

while(1);

{

if( !(PIND & (1<{
przycisk=1;
}

switch(cnt)

{

case 80:// 1 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;

if(przycisk==1)
{
PORTD = 0b00001001;
}
break;

case 160 : //2 sekwencja: zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00011011;
//PORTD = 0b00001001;
break;

case 240: //3 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
PORTC = 0b00001001;
PORTB = 0b00100100;
//PORTD = 0b00000110;
break;

case 320: //4 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
PORTC = 0b00011011;
PORTB = 0b00100100;
//PORTD = 0b00000110;
break;

case 400: //5 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;
//PORTD = 0b00001001;
cnt=0;
break;

}

}

}

ISR(TIMER0_OVF_vect)//procedura obsługi przerwania od przepełnienia timera

{
TCNT0 = 0;
cnt++;
}[/syntax]

Jednak trochę pozmieniałem wcześniejszą wersję i o dziwo działa, program się wykonuje a po naciśnięciu przycisku wykonuje się zawarta po nim pętla. Poniżej kod może się komuś przyda.

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;

int przycisk;

int main(void)
{
// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
// timer
TIMSK |= (1< TCCR0 |= (1< TCNT0 = 0; //początkowa wartość licznika

sei();

while(1);

}

//procedura obsługi przerwania od przepełnienia timera
ISR(TIMER0_OVF_vect)
{
TCNT0 = 0;
cnt++;

{

przycisk=0;//jeśli przycisk wciśnięty to zmienna przycisk=1
if( !(PIND & (1< {
przycisk=1;
}

if(cnt>80) // 1 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{

PORTC = 0b00100100;
PORTB = 0b00001001;

if(przycisk==1)//jeśli przycisk wciśnięty to oprócz zadanych stanów dochodzą jeszcze te z portu d
{
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001001;
}

}

if(cnt>160) //2 sekwencja: zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{
przycisk=0;
PORTD = 0b00000000;
PORTC = 0b00100100;
PORTB = 0b00011011;
if(przycisk==1)
{
PORTD = 0b00001001;
}

}

if(cnt>240) //3 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
{

PORTC = 0b00001001;
PORTB = 0b00100100;
if(przycisk==1)
{
PORTD = 0b00001001;
}

}

if(cnt>320) //4 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
{
PORTC = 0b00011011;
PORTB = 0b00100100;
if(przycisk==1)
{
PORTD = 0b00001001;
}

}

if(cnt>400) //5 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{
PORTC = 0b00100100;
PORTB = 0b00001001;
if(przycisk==1)
{
PORTD = 0b00001001;
}

cnt=0;
}

}

}[/syntax]

Co prawda całość wymaga jeszcze totalnej optymalizacji, na razie jedynie mam szkielet tego jak mogło by być. Puki co zauważyłem że jeśli umieszczę opóźnienie lub spróbuje zmienić wartość cnt w pętli zagnieżdżonej w drugiej to program się wysypuje. Szału nie ma ale jest światełko w tunelu.

Statystyki: Napisane przez black_currant — 27 lip 2016, o 10:41

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-20T15:07:29+01:00

Ja proponuje zrobić coś takiego. W obsłudze przerwania zostaw tylko inkrementację licznika cnt. Instrukcję switch przenieś do pętli while.
W pętli while musi też być zawarta obsługa przycisku. Ale nie z jakimś delayem i sterowaniem portem, tylko z ustawieniem flagi, że przycisk został wciśnięty. Musisz powołać po prostu jeszcze jedną zmienną.
W istrukcji switch umieszczasz wszystkie możliwe stany jakie mają być wyświetlane na semaforach, czyli z sekwencjami świateł dla pieszych tak jakby był wciśnięty przycisk. W instrukcji switch dla tych pozycji, które odpowiadają za włączenie świateł zielonych dla pieszych dodajesz na początku warunek if i sprawdzasz w nim czy ustawiona jest flaga włączenia przycisku. Jeśli tak to dana sekwencja switch się wykona. Jeśli nie ustawiasz cnt na nastepną pozycję która ma być wykonana. Dodatkowo w tej sekwencji switch, w której kończy się sterowanie światłami dla pieszych trzeba będzie skasować flagę przycisku. W ten sposób jesli nie był wciśnięty przycisk zmieniać się będą tylko światła dla samochodów, dla pieszych zawsze czerwone. Jeśli przycisk wciśnięty to zostanie wykonana dodatkowa sekwencja zmiany świateł dla pieszych. Mam nadzieję, że nie napisałem tego bardzo zawile.
I jeszcze taki drobiazg na koniec, main jest typu int a nie void.

Statystyki: Napisane przez janusz17 — 20 lip 2016, o 15:07

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-20T12:23:09+01:00

Witam, udało się oprzeć cały schemat działania na instrukcji switch, ale mimo wielu prób nie mogę zaadoptować udziału przycisku w całej procedurze. Umieszczałem instrukcje obsługi przycisku w poszczególnych case, w pętli głównej i nijak nie chce działać. Powątpiewam już czy możliwe jest użycie w jednym programie przerwań od przepełnienia timera i przycisku w czasie realnym.

Poniżej poprawiony kod i instrukcja do przycisku w komentarzu pod nim.

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;
int przycisk;

void main(void)

{

// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<
PORTD |= (1<
// timer
TIMSK |= (1<TCCR0 |= (1<TCNT0 = 0; //początkowa wartość licznika

sei();

while(1);

}

ISR(TIMER0_OVF_vect)//procedura obsługi przerwania od przepełnienia timera
{
TCNT0 = 0;
cnt++;

{

switch(cnt)

{

case 80:// 1 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001001;
break;

case 160 : //2 sekwencja: zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00011011;
PORTD = 0b00001001;
break;

case 240: //3 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
PORTC = 0b00001001;
PORTB = 0b00100100;
PORTD = 0b00000110;
break;

case 320: //4 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
PORTC = 0b00011011;
PORTB = 0b00100100;
PORTD = 0b00000110;
break;

case 400: //5 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001001;
cnt=0;
break;

}
}
}

/*instrukcja do przycisku

if( !(PIND & (1<{
PORTB ^= 0b0111111;
_delay_ms(3000);
}

*/[/syntax]

Statystyki: Napisane przez black_currant — 20 lip 2016, o 12:23

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-01T20:30:25+01:00

Rzeczywiście cały trzon programu będzie się realizował w pętli głównej, cnt będzie jedynie wyznaczały takty zmian świateł. Na pewno spróbuje to wcielić w życie tylko nie fartownie zaczynam urlop więc najszybciej za około dwa tygodnie. Dam znać czy udało mi się uporać z problemem.

Statystyki: Napisane przez black_currant — 1 lip 2016, o 20:30

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-01T13:02:15+01:00

Nie no, nie jest tak źle. Powinieneś w przerwaniu tylko zwiększać wartość licznika cnt. Resztę przenieś do pętli głównej i tam sprawdzaj warunki, jaki jest stan. Jeśli zrobisz to instrukcją if to porównuj konkretną wartość np. if(cnt==160). Wtedy faktycznie wykona się tylko warunek dla tej wartości. To wystarczy bo wtedy ma się zmienić układ świateł. Potem przez chwilę nic się nie dzieje. Dopiero jak zostanie osiągnięty następny warunek nastąpi kolejna zmiana. Świetnie nadaje się do tego właśnie istrukcja switch().
[syntax=c]switch(cnt)
{
case 80: /*tu wpisujesz odpowiednią wartość do portu*/ break;
case 160: /* następna wartość*/ break;
//i tak dalej
case 400: cnt = 0; /*następna wartość*/ break;
}[/syntax]
Spróbuj tylko pokombinować jak w zależności od stanu przycisku dodać wykonywanie dodatkowych pozycji wyświetlania świateł.

Statystyki: Napisane przez janusz17 — 1 lip 2016, o 13:02

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-07-01T06:38:12+01:00

Rzeczywiście gołym okiem w tym przypadku nie widać tego problemu, dzięki za zwrócenie uwagi. Gdyby to rzutowało na działanie programu to może użycie _delay_ms z krótkim czasem pod koniec pętli rozwiązało by problem? Choć czytałem żeby go unikać w przerwaniach, ale w sumie i tak nie zamuli programu bo cały mój główny program to to przerwanie.

Po dłuższych próbach i konsultacjach mam wrażenie że w takiej formie ten program nie ma racji bytu, muszę albo go gruntownie przebudować albo zacząć od nowa. Obsługę przycisków prawdopodobnie muszę zawrzeć w głównej pętli, w przerwaniach się raczej nie sprawdzą.

Statystyki: Napisane przez black_currant — 1 lip 2016, o 06:38

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-06-30T19:28:49+01:00

Quote:

Ogólnie wszystkie wartości zawarte w instrukcjach pętli ustawiają żądaną konfigurację diod. Co do zliczania cnt, to wydaje mi się, że kiedy dojdzie do 80 ustawia konfiguracje z tej pętli, dalej liczy i ustawia kolejną, tą ze 160. Sprawdziłem to na płytce, cały cykl przejścia świateł działa poprawnie.

Ale jeśli w if masz warunek cnt>80, to oczywiście , że dla wartości 160 wykona się kolejny if ale wczesniej na ułamek sekundy wykona się też warunek poprzedni. Dla kazdej następnej wartości cnt będą się wykonywały warunki poprzednie. Dzieje się to bardzo szybko i nawet tego nie zauważysz. W tym przypadku to zapewne nie jest problem, ale chodzi o pewne zasady w programowaniu i zrozumienie jak się to będzie wykonywać. W pewnych przypadkach to może być poważny problem, a co najgorsze bardzo trudny do wychwycenia.

Statystyki: Napisane przez janusz17 — 30 cze 2016, o 19:28

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-06-29T15:49:30+01:00

black_currant napisał(a):

Co do komentarzy i sposobu pisania kodu to rzeczywiście jeszcze nie nabrałem nawyku, czytałem o tym że to ułatwia prace z kodem tylko kwestia żebym się przyzwyczaił.

Przyjmij na wiarę, warto dodawać komentarze !
Zdziwisz się , jak po pewnym czasie powrócisz do własnego kodu (bez komentarzy), zaczniesz go analizować i dojdziesz do wniosku...: "co autor miał na myśli ?".
Nie komentowanie programu to bardzo pozorna oszczędność czasu.
Pozdr.

Statystyki: Napisane przez maverick_as — 29 cze 2016, o 15:49

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-06-29T14:55:09+01:00

Jeśli chodzi o rozszycie diod to w układzie mam dwie pary świateł dla każdej z dróg (proste skrzyżowanie, dwie przecinające się drogi), dla pojazdów i pieszych.

Pierwsza z dróg: PB2,PB5-czerwone ; PB1,PB4-żółte ; PB0,PB3-zielone ; PD3,PD2-czerwone,zielone dla pieszych;

Druga z dróg: PC5,PC2-czerwone ; PC4,PC1-żółte ; PC3,PC0-zielone ; PD1,PD0-czerwone,zielone dla pieszych;

Co do komentarzy i sposobu pisania kodu to rzeczywiście jeszcze nie nabrałem nawyku, czytałem o tym że to ułatwia prace z kodem tylko kwestia żebym się przyzwyczaił.

Ogólnie wszystkie wartości zawarte w instrukcjach pętli ustawiają żądaną konfigurację diod. Co do zliczania cnt, to wydaje mi się, że kiedy dojdzie do 80 ustawia konfiguracje z tej pętli, dalej liczy i ustawia kolejną, tą ze 160. Sprawdziłem to na płytce, cały cykl przejścia świateł działa poprawnie. Chciałem aby wciśnięcie przycisku zmieniało wartość cnt, tak aby kiedy przycisk nie jest wciśnięty cykl światła czerwonego dla pojazdów trwał dwa razy dłużej (po przez ustawienie wartości cnt tak aby powtórzyć pętle), kiedy pieszy wciska przycisk krócej czeka. Kwestia czy realizacja jest możliwa.

Z flagą walczyłem dziś rano, ale muszę jeszcze zgłębić temat bo wychodziły mi dziwne rzeczy. Jeśli chodzi o switch to rzeczywiście pozwoliło by to rozpatrzenie kilku wariantów, z wciśniętym przyciskiem lub nie.

Po szybkiej lekturze artykułu na temat maszyny stanów, wydaje mi się że pasował by idealnie, tylko kwestia doboru narzędzi w postaci timerów i obsługi przycisków.

Statystyki: Napisane przez black_currant — 29 cze 2016, o 14:55

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-06-29T13:04:02+01:00

Trochę trudno to analizować bo nic nie piszesz o tym gdzie masz podłączone lampki.
Ale ponieważ dopiero się uczysz, to staraj się bardziej czytelnie pisać kod. Dodawaj komentarze. Wpisywanie wartości do portu w postaci binarnej nie jest dobrym pomysłem. Nie ma potrzeby inicjalizować zerem portów mikrokontrolera bo one sa zerowane po resecie. To samo dotyczy rejestru TCNT. W tym przypadku może nie ma to dużego znaczenia , ale kod realizowany w przerwaniu powinien być jak najkrótszy. Zwróć też uwagę, że w tym kodzie dla cnt=80 wykona się tylko pierwszy warunek. Jednak im większa wartość cnt to bedą się wykonywać kolejno wszystkie warunki po kolei, a to chyba nie tak ma działać. Tu raczej bardziej pasowała by instrukcja switch().
Co do samej ideii działania takiego układu to ja zrobił bym to tak. Powołuje sobie zmienną - taką flagę w której będzie zapisana informacja czy przycisk został wciśnięty. Światła powinny normalnie się przełączać z pominieciem stanu włączenia zielonego dla pieszych. Dopiero kiedy spełniony jest warunek, że przycisk został wciśnięty powinna wykonywać sie dodatkowa sekwencja włączenia światła zielonego dla pieszych.

Statystyki: Napisane przez janusz17 — 29 cze 2016, o 13:04

Re: sterowanie sygnalizacją świetlną na skrzyżowaniu drogowy

2016-06-29T06:40:53+01:00

Witaj,
sugeruję lekturę na temat; maszyny stanów.
Na początek np. to:
http://ep.com.pl/files/1436.pdf

Z pomocą forumowej "szukajki" znajdziesz posty odnośnie jej (maszyny stanów) implementacji na AVR.
Pozdr.

Statystyki: Napisane przez maverick_as — 29 cze 2016, o 06:40

sterowanie sygnalizacją świetlną na skrzyżowaniu drogowym

2016-06-29T15:03:04+01:00

Witam, w oparciu o artykuł "LED sterowany przez Timer" który opracował drzasiek postanowiłem spróbować napisać program sterujący sygnalizacją świetlną na skrzyżowaniu drogowym.

Jeśli chodzi o sam proces zmiany świateł to nie miałem żadnych problemów, kłopoty zaczęły się kiedy chciałem dodać przycisk dla pieszych który miał by skracać czas trwania światła zielonego dla samochodów. Całą idę oparłem na schemacie że jeżeli zmienna pomocnicza licznika przekroczy odpowiednią wartość to zostanie wykonana instrukcja zawarta w pętli if ( if(cnt>...) ), w moim przypadku zmieni się stan diod.

Kiedy umieszczam podobną instrukcję ale zawierającą obsługę przycisku lub zerowanie cnt, program zaczyna dziwnie reagować, albo nie wykonują się żadne zmiany stanu diod albo działa tylko instrukcja obsługiwana przez przycisk. Wydaje mi się, że albo wpisuje ją w złym miejscu albo ma ona złą formę. Same połączenie przycisku oraz kod który go uruchamia raczej są w porządku gdyż w innym testowym programie zapalają i gaszą diody.

Jak zapewne nie trudno wywnioskować z powyższej lektury jeśli chodzi o mikrokontrolery dopiero zaczynam swoją przygodę, chciał bym prosić o sugestie czy w oparciu o taki timer i techniki których próbuje użyć do rozwiązania tego problemu ten projekt ma rację bytu? Ewentualnie jak inaczej można by podejść do zagadnienia przycisku dla pieszych na takim domniemanym skrzyżowaniu?

Na samym dole kodu zamieściłem w komentarzach dwie pętle których próbowałem użyć, zawarte w nich instrukcje mają charakter jedynie testowy.

Kod programu:

[syntax=cpp]#include
#include
#include

volatile uint16_t cnt=0;

void main(void)
{
// I/O
DDRB = 0b0111111;
DDRC = 0b0111111;
DDRD = 0b0011111;
DDRD &= ~(1<// stany poczatkowe
PORTB = 0b00000000;
PORTC = 0b00000000;
PORTD = 0b00000000;

PORTD |= (1<
// timer
TIMSK |= (1< TCCR0 |= (1< TCNT0 = 0;// //początkowa wartość licznika

sei();

while(1);

}

//procedura obsługi przerwania od przepełnienia timera
ISR(TIMER0_OVF_vect)
{
TCNT0 = 0;
cnt++;

{

if(cnt>80) // 1 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001001;
//cnt=0;
}

if(cnt>160) //2 sekwencja: zielone i zolte dla pojazdow czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{
PORTC = 0b00100100;
PORTB = 0b00011011;
PORTD = 0b00001001;
//cnt=0;
}

if(cnt>240) //3 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone dla pojazdow czerwone dla pieszych
{
PORTC = 0b00001001;
PORTB = 0b00100100;
PORTD = 0b00000110;
//cnt=0;
}

if(cnt>320) //4 sekwencja: czerwone dla pojazdow, zielone dla pieszych, druga droga zielone i zolte dla pojazdow czerwone dla pieszych
{
PORTC = 0b00011011;
PORTB = 0b00100100;
PORTD = 0b00000110;
//cnt=0;
}

if(cnt>400) //5 sekwencja: zielone dla pojazdow,czerwone dla pieszych,druga droga czerwone dla pojazdow zielone dla pieszych
{
PORTC = 0b00100100;
PORTB = 0b00001001;
PORTD = 0b00001001;
cnt=0;
}

}
}

/*

if( !(PIND & (1< {
PORTB ^= 0b0111111;
_delay_ms(3000);
}

if( !(PIND & (1< {
cnt=0;
}

*/[/syntax]

Statystyki: Napisane przez black_currant — 28 cze 2016, o 21:09