Po wielu bojach udało mi się uruchomić sterownik. Na samym początku musiałem zmienić koncepcję, ponieważ okazało się, że do obudowy Z104 na szynę DIN będzie ciężko zmieścić złącza śrubowe, które pomieszczą 42 przewody o średnicy 1 mm2 (14 stopni x 3).
Postanowiłem sterować każdym stopniem z osobna, a kanały R,G,B połączyć razem z racji tego iż w założeniach nie miałem potrzeby sterować podświetleniem każdego stopnia z osobna. Tak narodził się schemat i płytka PCB:
Tranzystory odpowiadające to BD136 sterowane poprzez BC817 ( docelowo zmieniłem rezystory 100R/1W w bazie BD na 1K 0.5W), natomiast za kolory odpowiadają mosfety IRFZ44N. Na schemacie brakuję rezystorów 1K podciągających wejścia czujników przy przycisków do VCC ( w późniejszym czasie okazało się to konieczne, programowe podciągnięcie nie wystarczyło ). Po zlutowaniu i złożeniu całość prezentuje się tak:
Użyłem czujników odbiciowych E18-D80NK, które po zlokalizowaniu przeszkody wystawiają stan niski na pin procesora. Jako czujnik zmierzchu wykorzystany został fotorezystor, który tworzy wraz z potencjometrem dzielnik napięcia.
Sterownik do komunikacji wykorzystuje technologię Bluetooth - model modułu to HC05. Aplikacja na telefonie niestety nie została napisana przeze mnie w B4A, tylko w programie "roboremo", do tego zastosowania nadaje się w 100%. Prosty interfejs umożliwia szybkie sterowanie. W textlog'u wyświetlają się aktualne parametry sterownika takiej jak wartość kanałów R,G,B, moc świecenia, czas podświetlenia czy wartość ADC czujnika jak i wartość ADC suwaka.
Sterownik posiada dwie opcje sterowania taśmami LED:
1) Poprzez czujnik zmierzchu: możliwość precyzyjnego ustawienia wartości zadziałania układu oraz mocy świecenia taśm. Zadziałanie czujnik optycznego albo przełącznika ściennego powoduje rozjaśnianie wartości mocy świecenia do 100% (od ustawionej wcześniejszej mocy). Następnie sterownik odlicza czas podświetlenia który został ustawiony przez użytkownika w aplikacji (od 0 sekund do 255), a następnie wraca do poprzedniej mocy świecenia robiąc to w sposób płynny i przyjazny dla oka. Każde kolejne zadziałanie czujnika czy przycisku powoduje doliczenie do czasu podświetlenia dodatkowych sekund przez co kolejny mieszkaniec nie musi się martwić, że w połowie wejścia po schodach taśmy zgasną.
2) Drugą opcją jest wyłączenie czujnika zmierzchu, a załączenie sekwencyjnego zapalania stopni. Zadziałanie czujnika zmierzchu czy przycisku ściennego powoduje załączenie sekwencyjne każdego stopnia- powolne rozświetlanie oraz ściemnianie. Po odliczeniu czasu podświetlenia stopnie zaczynają ściemniać się od strony zadziałania czujnika/przycisku.
Video niestety nie pokazuje działania na schodach... niedługo filmik zaktualizuję
[youtube]v= (https://www.youtube.com/watch?v=FBcUG3uMQsY&)[/youtube]
Jeśli chodzi o kod programu to udostępniam:
W kodzie na pewno do poprawy są deleye, które nie powinny się tam znaleźć..
[syntax=c]/*
* main.c
*
* Created on: 17 sie 2017
* Author: Marci
*/
#include "main.h"
int main(void)
{
LED_OUT;
LED_OFF;
ST1_OUT; ST2_OUT; ST3_OUT; ST4_OUT; ST5_OUT; ST6_OUT; ST7_OUT;
ST8_OUT; ST9_OUT; ST10_OUT; ST11_OUT; ST12_OUT; ST13_OUT; ST14_OUT;
ST1_OFF; ST2_OFF; ST3_OFF; ST4_OFF; ST5_OFF; ST6_OFF; ST7_OFF;
ST8_OFF; ST9_OFF; ST10_OFF; ST11_OFF; ST12_OFF; ST13_OFF; ST14_OFF;
R_OUT; G_OUT; B_OUT;
R_ON; G_ON; B_ON;
CZUJNIK_DOL_OUT;
CZUJNIK_GORA_OUT;
KEY_DOL_OUT;
KEY_PULLUP_DOL;
KEY_GORA_OUT;
KEY_PULLUP_GORA;
TCCR2 |= (1<<WGM21); //TRYB CTC
TCCR2 &= ~( (1<<CS20)|(1<<CS21)|(1<<CS22) );
// Timer 0
TCCR0 |= (1<<WGM01);// tryb CTC
TCCR0 |= (1<<CS00)|(1<<CS02);// preskaler = 1024
OCR0 = 194;// dodatkowy podział częsttotliwości przez 194 10ms
TIMSK |= (1<<OCIE0);// zezwolenie na przerwanie CompareMatch
// Timer 1 - PWM
TCCR1B |= (1<<WGM12); // tryb CTC
TCCR1B |= (1<<CS10); // preskaler = 1
OCR1A = 1300; // dodatkowy podział (rej. przepełnienia)
TIMSK |= (1<<OCIE1B); // zezwolenie na przerwanie CompareMatch
// ADC - Czujnik zmierzchu
ADCSRA |= (1<<ADEN);// Inicjalizacja ADC
ADCSRA |= (1<<ADPS0)|(1<<ADPS1);
ADMUX |= (1<<REFS0);// zródło odniesienia - 5V
// Przerwanie INT0
DDRD &= ~(1<<PD2); //INT0 jako wejscie
MCUCR |= (1<<ISC01); // wyzwalanie zboczem opadajacym
GICR |= (1<<INT0); // odblokowanie przerwania
PORTD |= (1<<PD2); // podciągnięcie pinu INT0 do VCC
// Przerwanie INT1
DDRD &= ~(1<<PD3); //INT1 jako wejscie
MCUCR |= (1<<ISC11); // wyzwalanie zboczem opadajacym
GICR |= (1<<INT1); // odblokowanie przerwania
PORTD |= (1<<PD3); // podciągnięcie pinu INT0 do VCC
USART_Init(__UBRR);// Inicjalizacja UART
// rejestracja własnej funkcji do analizowania danych odebranych przez UART
register_uart_str_rx_event_callback( parse_rs232 );
pwm_r = eeprom_read_byte((uint8_t *)1);
pwm_g = eeprom_read_byte((uint8_t *)2);
pwm_b = eeprom_read_byte((uint8_t *)3);
czas = eeprom_read_byte((uint8_t *)4);
moc_swiecenia = eeprom_read_byte((uint8_t *)5);
czujnik_zmierzchu = eeprom_read_byte((uint8_t *)6);
adc = eeprom_read_word ((uint16_t *)7);
sei();
while(1)
{
czas_pauza = czas * 100;
UART_RX_STR_EVENT( uart_buf );// zdarzenie odbiorcze UART
#if LED_STAN == 1
if ( !Timer1 )
{
LED_TOG;
Timer1 = 80;
}
#endif
#if uart_tx == 1
if ( !Timer3 )
{
uart_puts ("Kanal R: ");
uart_putint (pwm_r, 10);
uart_puts ("\r\n");
uart_puts ("Kanal G: ");
uart_putint (pwm_g, 10);
uart_puts ("\r\n");
uart_puts ("Kanal B: ");
uart_putint (pwm_b, 10);
uart_puts ("\r\n");
uart_puts ("Czas: ");
uart_putint (czas, 10);
uart_puts (" sekund");
uart_puts ("\r\n");
uart_puts ("Moc: ");
uart_putint (moc_swiecenia, 10);
uart_puts ("\r\n");
uart_puts ("ADC: ");
uart_putint (srednia, 10);
uart_puts ("\r\n");
uart_puts ("Suwak ADC: ");
uart_putint (adc, 10);
uart_puts ("\r\n");
Timer3 = 100;
}
#endif
fotorezystor();
przyciski ();
efekt_dol ();
efekt_gora ();
efekt_rozjasnanie ();
}
}
ISR(TIMER0_COMP_vect)
{
uint16_t n;
n = Timer1; // Dioda LED
if (n) Timer1 = --n;
n = Timer2; // oczekiwanie na wygaszenie
if (n) Timer2 = --n;
n = Timer3; // Wysyłanie Uart
if (n) Timer3 = --n;
n = Timer4; // Zmiana koloru - chwilowe załączenie
if (n) Timer4 = --n;
}
void parse_rs232(char * buf)
{
if( (RED = strcasestr(buf, "RED")) != NULL)// Kolor czerwony
{
strtok(RED,"=");
RED = strtok(NULL,",");
pwm_r =atoi(RED);
eeprom_write_byte((uint8_t *)1,pwm_r);
}
if( (GREEN = strcasestr(buf, "GREEN")) != NULL)// Kolor zielony
{
strtok(GREEN,"=");
GREEN = strtok(NULL,",");
pwm_g =atoi(GREEN);
eeprom_write_byte((uint8_t *)2,pwm_g);
}
if( (BLUE = strcasestr(buf, "BLUE")) != NULL)// Kolor niebieski
{
strtok(BLUE,"=");
BLUE = strtok(NULL,",");
pwm_b =atoi(BLUE);
eeprom_write_byte((uint8_t *)3,pwm_b);
}
if( (CZAS = strcasestr(buf, "CZAS")) != NULL)// Czas podświetlenia
{
strtok(CZAS,"=");
CZAS = strtok(NULL,",");
czas =atoi(CZAS);
eeprom_write_byte((uint8_t *)4,czas);
}
if( (MOC = strcasestr(buf, "MOC")) != NULL)// Moc podświetlenia
{
strtok(MOC,"=");
MOC = strtok(NULL,",");
moc_swiecenia =atoi(MOC);
eeprom_write_byte((uint8_t *)5,moc_swiecenia);
}
if( (ZMIERZCH = strcasestr(buf, "ADC")) != NULL)// Czujnik zmierzchu
{
strtok(ZMIERZCH,"=");
ZMIERZCH = strtok(NULL,",");
adc =atoi(ZMIERZCH);
eeprom_write_word ((uint16_t *)7,adc);
}
if( !strcmp (buf, "ON") ) // Czujnik zmierzchu - ON
{
czujnik_zmierzchu = 1;
eeprom_write_byte((uint8_t *)6,czujnik_zmierzchu);
}
if( !strcmp (buf, "OFF") ) // Czujnik zmierzchu - OFF
{
czujnik_zmierzchu = 0;
eeprom_write_byte((uint8_t *)6,czujnik_zmierzchu);
}
}
uint16_t pomiar (uint8_t kanal)
{
ADMUX = (ADMUX & 0xF8) | kanal;
ADCSRA |= (1<<ADSC);//start konwersja
while (ADCSRA & (1<<ADSC));
return ADCW;
}
void fotorezystor (void)
{
wynik = pomiar (CZUJNIK_ZMIERZCHU);
srednia = srednia * dt;
srednia = srednia + wynik;
srednia = srednia / (dt+1);
if ( czujnik_zmierzchu == 1)
{
if ((adc - histereza ) > srednia )
{
pwm[1] = moc_swiecenia;
pwm[2] = moc_swiecenia;
pwm[3] = moc_swiecenia;
pwm[4] = moc_swiecenia;
pwm[5] = moc_swiecenia;
pwm[6] = moc_swiecenia;
pwm[7] = moc_swiecenia;
pwm[8] = moc_swiecenia;
pwm[9] = moc_swiecenia;
pwm[10] = moc_swiecenia;
pwm[11] = moc_swiecenia;
pwm[12] = moc_swiecenia;
pwm[13] = moc_swiecenia;
pwm[14] = moc_swiecenia;
if ( CZUJNIK_GORA_AKTYWNY)
{
start = 5;
}
if ( CZUJNIK_DOL_AKTYWNY)
{
start = 4;
}
}
if ( (adc + histereza) < srednia)
{
pwm[1] = 0;
pwm[2] = 0;
pwm[3] = 0;
pwm[4] = 0;
pwm[5] = 0;
pwm[6] = 0;
pwm[7] = 0;
pwm[8] = 0;
pwm[9] = 0;
pwm[10] = 0;
pwm[11] = 0;
pwm[12] = 0;
pwm[13] = 0;
pwm[14] = 0;
}
if( (adc>(srednia - histereza )) && (adc<(srednia + histereza)) )
{
pwm[1] = 0;
pwm[2] = 0;
pwm[3] = 0;
pwm[4] = 0;
pwm[5] = 0;
pwm[6] = 0;
pwm[7] = 0;
pwm[8] = 0;
pwm[9] = 0;
pwm[10] = 0;
pwm[11] = 0;
pwm[12] = 0;
pwm[13] = 0;
pwm[14] = 0;
}
}else
{
pwm[1] = 0;
pwm[2] = 0;
pwm[3] = 0;
pwm[4] = 0;
pwm[5] = 0;
pwm[6] = 0;
pwm[7] = 0;
pwm[8] = 0;
pwm[9] = 0;
pwm[10] = 0;
pwm[11] = 0;
pwm[12] = 0;
pwm[13] = 0;
pwm[14] = 0;
czujnik_zmierzchu = 0;
}
}
ISR(INT0_vect)
{
if ( CZUJNIK_GORA_TICK )
{
start = 2;
}
}
ISR(INT1_vect)
{
if ( CZUJNIK_DOL_TICK )
{
start = 1;
}
}
ISR(TIMER1_COMPB_vect)
{
static uint8_t cnt; // definicja naszego licznika PWM
// bezpośrednie sterowanie wyjściami kanałów PWM
if(cnt>=pwm[1]) ST1_OFF; else ST1_ON;
if(cnt>=pwm[2]) ST2_OFF; else ST2_ON;
if(cnt>=pwm[3]) ST3_OFF; else ST3_ON;
if(cnt>=pwm[4]) ST4_OFF; else ST4_ON;
if(cnt>=pwm[5]) ST5_OFF; else ST5_ON;
if(cnt>=pwm[6]) ST6_OFF; else ST6_ON;
if(cnt>=pwm[7]) ST7_OFF; else ST7_ON;
if(cnt>=pwm[8]) ST8_OFF; else ST8_ON;
if(cnt>=pwm[9]) ST9_OFF; else ST9_ON;
if(cnt>=pwm[10]) ST10_OFF; else ST10_ON;
if(cnt>=pwm[11]) ST11_OFF; else ST11_ON;
if(cnt>=pwm[12]) ST12_OFF; else ST12_ON;
if(cnt>=pwm[13]) ST13_OFF; else ST13_ON;
if(cnt>=pwm[14]) ST14_OFF; else ST14_ON;
if(cnt>=pwm_r) R_ON; else R_OFF;
if(cnt>=pwm_g)G_ON; else G_OFF;
if(cnt>=pwm_b)B_ON; else B_OFF;
cnt++;// zwiększanie licznika o 1
}
uint8_t klawisz_wcisniety (uint8_t klawisz)
{
if( (klawisz) )// klawisz wciśnięty ?
{
_delay_ms(80);// czas drgań styków
if (klawisz) return 1; // jeśli wciśnięty? zakończ funkcję - rezultat = 1
}
return 0;// jeśli nie wciśnięty klawisz, zakończ funkcję, rezultat = 0
}
void przyciski (void)
{
if (klawisz_wcisniety(KEY_DOL))
{
start = 1;
}
if (klawisz_wcisniety(KEY_GORA))
{
start = 2;
}
if ( klawisz_wcisniety(KEY_DOL) & klawisz_wcisniety(KEY_GORA) )
{
start = 3;
}
}
void efekt_dol (void)
{
if ( (start == 1) & (czujnik_zmierzchu == 0) )
{
for (int j=1; j<15;j++)
{
for(i=60;i<255;i++)
{
pwm[j] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[j]=255;
}
Timer2 = czas_pauza;
while( Timer2 )
{
if (CZUJNIK_GORA_TICK )
{
_delay_ms (500);
flaga ++;
if (flaga > 2)
{
Timer2 = czas_pauza + czas_pauza;
}
}
if (CZUJNIK_DOL_TICK)
{
_delay_ms (200);
Timer2 = czas_pauza + czas_pauza;
}
}
for (int j=1; j<15;j++)
{
for(i=255;i;i--)
{
pwm[j] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[j]=0;
}
start = 0;
flaga = 0;
}
}
void efekt_gora (void)
{
if ( (start == 2) & (czujnik_zmierzchu == 0) )
{
for (int p=14; p; p--)
{
for(i=60;i<255;i++)
{
pwm[p] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[p]=255;
}
Timer2 = czas_pauza;
while( Timer2 )
{
if (CZUJNIK_GORA_TICK )
{
_delay_ms (200);
Timer2 = czas_pauza + czas_pauza;
}
if (CZUJNIK_DOL_TICK)
{
_delay_ms (500);
flaga ++;
if (flaga > 2)
{
Timer2 = czas_pauza + czas_pauza;
}
}
}
for (int p=14; p; p--)
{
for(i=255;i;i--)
{
pwm[p] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[p]=0;
}
start = 0;
flaga = 0;
}
}
void efekt_rozjasnanie (void)
{
if (start == 4) // Dół
{
for(i=moc_swiecenia; i<255; i++)
{
pwm[1] = i;
pwm[2] = i;
pwm[3] = i;
pwm[4] = i;
pwm[5] = i;
pwm[6] = i;
pwm[7] = i;
pwm[8] = i;
pwm[9] = i;
pwm[10] = i;
pwm[11] = i;
pwm[12] = i;
pwm[13] = i;
pwm[14] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[1] = 255;
pwm[2] = 255;
pwm[3] = 255;
pwm[4] = 255;
pwm[5] = 255;
pwm[6] = 255;
pwm[7] = 255;
pwm[8] = 255;
pwm[9] = 255;
pwm[10] = 255;
pwm[11] = 255;
pwm[12] = 255;
pwm[13] = 255;
pwm[14] = 255;
Timer2 = czas_pauza;
while( Timer2 )
{
if (CZUJNIK_GORA_TICK )
{
_delay_ms (500);
flaga ++;
if (flaga > 2)
{
Timer2 = czas_pauza + czas_pauza;
}
}
if (CZUJNIK_DOL_TICK)
{
_delay_ms (200);
Timer2 = czas_pauza + czas_pauza;
}
}
for(i=255; i>= moc_swiecenia; i--)
{
pwm[1] = i;
pwm[2] = i;
pwm[3] = i;
pwm[4] = i;
pwm[5] = i;
pwm[6] = i;
pwm[7] = i;
pwm[8] = i;
pwm[9] = i;
pwm[10] = i;
pwm[11] = i;
pwm[12] = i;
pwm[13] = i;
pwm[14] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
start = 0;
flaga = 0;
}
if (start == 5) // Góra
{
for(i=moc_swiecenia; i<255; i++)
{
pwm[1] = i;
pwm[2] = i;
pwm[3] = i;
pwm[4] = i;
pwm[5] = i;
pwm[6] = i;
pwm[7] = i;
pwm[8] = i;
pwm[9] = i;
pwm[10] = i;
pwm[11] = i;
pwm[12] = i;
pwm[13] = i;
pwm[14] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
pwm[1] = 255;
pwm[2] = 255;
pwm[3] = 255;
pwm[4] = 255;
pwm[5] = 255;
pwm[6] = 255;
pwm[7] = 255;
pwm[8] = 255;
pwm[9] = 255;
pwm[10] = 255;
pwm[11] = 255;
pwm[12] = 255;
pwm[13] = 255;
pwm[14] = 255;
Timer2 = czas_pauza;
while( Timer2 )
{
if (CZUJNIK_GORA_TICK )
{
_delay_ms (200);
Timer2 = czas_pauza + czas_pauza;
}
if (CZUJNIK_DOL_TICK)
{
_delay_ms (500);
flaga ++;
if (flaga > 2)
{
Timer2 = czas_pauza + czas_pauza;
}
}
}
for(i=255; i>= moc_swiecenia; i--)
{
pwm[1] = i;
pwm[2] = i;
pwm[3] = i;
pwm[4] = i;
pwm[5] = i;
pwm[6] = i;
pwm[7] = i;
pwm[8] = i;
pwm[9] = i;
pwm[10] = i;
pwm[11] = i;
pwm[12] = i;
pwm[13] = i;
pwm[14] = i;
if(i>50) _delay_ms(2);
else _delay_ms(5);
}
start = 0;
flaga = 0;
}
}[/syntax]
Rzeczą z którą miałem ciężko sobie poradzić to doliczanie czasu kiedy kolejna osoba przechodziła przez czujnik. Ja zapisałem to w ten sposób :
[syntax=c]Timer2 = czas_pauza;
while( Timer2 )
{
if (CZUJNIK_GORA_TICK )
{
_delay_ms (200);
Timer2 = czas_pauza + czas_pauza;
}
if (CZUJNIK_DOL_TICK)
{
_delay_ms (500);
flaga ++;
if (flaga > 2)
{
Timer2 = czas_pauza + czas_pauza;
}
}
}[/syntax]
Jeśli następuje "CZAS_PAUZY" (ustalony z aplikacji) i w tym momencie ktoś przejdzie przez czujnik to dolicza się dodatkowo czas pauzy, ale problem było to iż osoba która idzie po schodach z dołu do góry to zadziała czujnik górny który nie może dodać kolejnego czasu więc dałem flagę. Jeśli jest większa od 2 to w tedy doda czas.
To by było na tyle, sterownik działa, ma się dobrze, kod do poprawy. Ale się starałem
, może komuś się przyda Pozdrawiam
Marcin
Statystyki: Napisane przez Morcinek92 — 24 wrz 2017, o 18:13
]]>
tu nie ma co gadać - to na 100% będzie śmigać 
