ATNEL tech-forum

Re: Sterownik skręcarki Atmega 8

2014-01-16T21:53:42+01:00

Witam ponownie. Poradziłem sobie już z funkcją automatycznego cofania o zaprogramowana liczbę impulsów, ale dalej nie wiem jak mam zrobić zapamiętanie wartości licznika np. po wciśnięciu klawisza wyboru kierunku (klawisz 6 i 7) a po zakończeniu pracy (zadeklarowane zmienne) wypisać tą zapamiętaną wartość do n. Chyba, że czegoś nie kumam. Prosiłbym żeby ktoś pokazał na przykładnie jak to można rozwiązać.

[syntax=c]/*
* main.c
*
* Created on: 2014-01-01
* Author: hopek
* wersja 1.4
*/

#include
#include
#include "LCD/lcd44780.h"

//definicja pinu dla diody LED
#define LED_PIN (1<#define LED_OFF PORTC &= ~(1<#define LED_ON PORTC |= (1<
//piny dla styczników
#define LEWO (1<#define PRAWO (1<
#define LEWO_ON PORTB &= ~LEWO
#define PRAWO_ONPORTB &= ~PRAWO
#define LEWO_OFF PORTB |= LEWO
#define PRAWO_OFF PORTB |= PRAWO

//definicje klawiszy
#define KEY1 (1<#define KEY4 (1<#define KEY3 (1<#define KEY2 (1<#define KEY5 (1<#define KEY6 (1<#define KEY7 (1<
#define BUZ (1<#define BUZ_OFF PORTC &= ~BUZ
#define BUZ_ON PORTC |= BUZ
#define BUZ_TOG PORTC ^= BUZ

//pin czujnika
#define IMP (1<

//definicje własnych znaków LCD
uint8_t tab1 [] = {16,24,28,30,28,24,16,32}; //strzałka prawo
uint8_t tab2 [] = {1,3,7,15,7,3,1,32};//strzałak lewo
uint8_t tab3 [] = {2,4,14,16,14,1,30,32};//litera s
uint8_t tab4 [] = {2,4,14,16,16,17,14,32};//litera ć
uint8_t tab5 [] = {2,4,14,17,17,17,14,32};//litera ó
uint8_t tab6 [] = {32,32,14,17,31,16,14,2}; //litera ę

uint8_t imp_lock, key1_lock, key2_lock, key3_lock, key4_lock, key5_lock, key6_lock, key7_lock;
uint8_t czujnik1(void);
uint16_t licznik(void);
uint8_t praca_lewo; //zmienna pomocnicza
uint8_t praca_prawo;//zmienna pomocnicza
uint16_t n;//zmienna pomocnicza

void beep_on (void);
void beep_ready (void);
void beep_klik (void);
void beep_wrong (void);

int main(void)
{
DDRC |= LED_PIN; //kierunek pinu PC7 wyjściowy
PORTC &= ~LED_PIN; //wyłączenie diody
DDRD &= ~ (IMP | KEY1 | KEY2 | KEY3 | KEY4 | KEY5); //kierunki portów jako wejściowe
PORTD |= IMP | KEY1 | KEY2| KEY3 | KEY4 | KEY5;//klawisze do VCC
DDRB &= ~(KEY6 | KEY7);
PORTB |= KEY6 | KEY7;
DDRB |= LEWO | PRAWO;
PORTB |= LEWO | PRAWO;
DDRC |= BUZ;
PORTC |= BUZ;

BUZ_OFF;

LEWO_OFF;
PRAWO_OFF;

lcd_init(); //inicjalizacja LCD

lcd_defchar ( 0x80, tab1);
lcd_defchar( 0x81, tab3);
lcd_defchar( 0x82, tab4);
lcd_defchar ( 0x83, tab5);
lcd_defchar ( 0x84, tab6);
lcd_defchar ( 0x85, tab2);

lcd_locate(0,0);

//efekty specjalne

/* lcd_str("S");
_delay_ms(100);

lcd_locate(0,1);
lcd_str("t");
_delay_ms(100);

lcd_locate(0,2);
lcd_str("e");
_delay_ms(100);

lcd_locate(0,3);
lcd_str("r");
_delay_ms(100);

lcd_locate(0,4);
lcd_str("o");
_delay_ms(100);

lcd_locate(0,5);
lcd_str("w");
_delay_ms(100);

lcd_locate(0,6);
lcd_str("n");
_delay_ms(100);

lcd_locate(0,7);
lcd_str("i");
_delay_ms(100);
lcd_locate(0,8);

lcd_str("k");
_delay_ms(100);

lcd_locate(1,0);
lcd_str("S");
_delay_ms(100);

lcd_locate(1,1);
lcd_str("k");
_delay_ms(100);

lcd_locate(1,2);
lcd_str("r");
_delay_ms(100);

lcd_locate(1,3);
lcd_str("\x84");
_delay_ms(100);
lcd_locate(1,4);
lcd_str("c");
_delay_ms(100);

lcd_locate(1,5);
lcd_str("a");
_delay_ms(100);

lcd_locate(1,6);
lcd_str("r");
_delay_ms(100);
lcd_locate(1,7);
lcd_str("k");
_delay_ms(100);

lcd_locate(1,8);
lcd_str("i");
_delay_ms(500);

lcd_locate(1,10);
lcd_str(" v1.4");

_delay_ms(500);

beep_on();
*/

//
while(1)
{
if(czujnik1())
{
licznik();
}

lcd_locate(0,0);
lcd_str("Ilo\x81\x82 impuls\x83w:");
lcd_locate (1,0);
lcd_int(n);
lcd_str(" ");

//OBSŁUGA DRGAŃ STYKÓW I KLAWISZY

//klawisz 1 (zmniejszanie o 1)
if( !key1_lock && !(PIND & KEY1 ) )
{
key1_lock=1;
n--;
//beep_klik();

}
else if( key1_lock && (PIND & KEY1 ) )
key1_lock=0;

//klawisz 2 (zwiększanie o 1)
if( !key2_lock && !(PIND & KEY2 ) )
{
key2_lock=1;
n ++;
//beep_klik();

}
else if( key2_lock && (PIND & KEY2 ) )
key2_lock=0;

//klawisz 3 (zwiększanie o 10)
if( !key3_lock && !(PIND & KEY3 ) )
{
key3_lock=1;
n +=10;
//beep_klik();
}
else if( key3_lock && (PIND & KEY3 ) )
key3_lock=0;

//klawisz 4 (zwiększanie o 100)
if( !key4_lock && !(PIND & KEY4 ) )
{
key4_lock=1;
n +=100;
//beep_klik();
}
else if( key4_lock && (PIND & KEY4 ) )
key4_lock=0;

//klawisz 5 (kasowanie licznika)
if( !key5_lock && !(PIND & KEY5 ) )
{
key5_lock=1;
n =0;
//beep_wrong();
praca_lewo=0;
praca_prawo=0;
LEWO_OFF;
PRAWO_OFF;
}
else if( key5_lock && (PIND & KEY5 ) )
key5_lock=0;

//--------------------------------KLAWISZE WYBORU KIERUNKU PRACY------------------------------

//klawisz 6 (obroty lewo)
if( !key6_lock && !(PINB & KEY6 ) )
{

key6_lock=1;
praca_lewo=1;
LEWO_ON;
//beep_klik();

}
else if( key6_lock && (PINB & KEY6 ) )
key6_lock=0;

//klawisz 7 (obroty prawo)
if( !key7_lock && !(PINB & KEY7 ) )
{
key7_lock=1;

PRAWO_ON;
praca_prawo=1;
//beep_klik();

}
else if( key7_lock && (PINB & KEY7 ) )
key7_lock=0;
//--------------------------------KLAWISZE WYBORU KIERUNKU PRACY------------------------------

//funkcja która zatrzymuje i cofa maszyne o 5 impulsów wstecz żeby odprężyć materiał
if (praca_lewo)

{

if (!(PINB & LEWO) & (n==0))
{
LEWO_OFF;
_delay_ms(1500);
n=5;
_delay_ms(500);
PRAWO_ON;
}

if (!(PINB & PRAWO) & (n==0))
{
PRAWO_OFF;
praca_lewo=0;
//beep_ready();

}

}

if (praca_prawo)

{

if (!(PINB & PRAWO) & (n==0))
{
PRAWO_OFF;
_delay_ms(1500);
n=5;
_delay_ms(500);
LEWO_ON;
}

if (!(PINB & LEWO) & (n==0))
{
LEWO_OFF;
praca_prawo=0;
//beep_ready();

}

}

//warunek nie pozwalający na ujemne stany licznika
if (n >= -1)
{
n=0;

}
//blokowanie klawiszy wyboru kierunku skręcania podczas gdy urzadzenie nie pracuje
if ((n==0) || (praca_lewo || praca_prawo))
{
key6_lock=1;//wybór kierunku LEWO
key7_lock=1;//wybór kierunku PRAWO
}

//warunek blokujący klawisze podczas pracy, żeby nie było bum. Klawisz reset aktywny.
if ((!(PINB & LEWO)) || (!(PINB & PRAWO)))
{
key1_lock=1;//zmniejszanie o 1
key2_lock=1;//zwiększanie o 1
key3_lock=1;//zwiększanie o 10
key4_lock=1;//zwiększanie o 100
}
}
}

uint8_t czujnik1(void)
{
if( !imp_lock && !(PIND & IMP ) )
{
imp_lock=1;
n--;

// mignij diodą z każdym impulsem
LED_ON;
_delay_ms(2);
LED_OFF;
}
else if( imp_lock && (PIND & IMP ) ) imp_lock=0;
return 0;
}

uint16_t licznik(void)
{
static uint16_t licznik; //definicja zmiennej statycznej
n = licznik++;
return n;
}

void beep_klik(void)
{
uint8_t i;
for(i=0; i<70; i++)
{
_delay_us(250);
BUZ_TOG;

}
BUZ_OFF;
}

void beep_on (void)
{
uint8_t i;
for(i=0; i<100; i++)
{
_delay_us(250);
BUZ_TOG;
}
_delay_ms(80);

for(i=0; i<150; i++)
{
_delay_us(200);
BUZ_TOG;
}
BUZ_OFF;
}

void beep_ready (void)
{
uint16_t i;
for(i=0; i<350; i++)
{
_delay_us(200);
BUZ_TOG;
}
_delay_ms(80);

for(i=0; i<350; i++)
{
_delay_us(250);
BUZ_TOG;
}

BUZ_OFF;
}

void beep_wrong (void) {
uint8_t i;
for(i=0; i<70; i++)
{
_delay_us(400);
BUZ_TOG;

}
_delay_ms(100);
for(i=0; i<70; i++)
{
_delay_us(400);
BUZ_TOG;

}
_delay_ms(100);
for(i=0; i<70; i++)
{
_delay_us(400);
BUZ_TOG;

}
_delay_ms(100);
BUZ_OFF;
}[/syntax]

Problem rozwiązany.

Statystyki: Napisane przez hopek — 16 sty 2014, o 21:53

Re: Sterownik skręcarki Atmega 8

2014-01-07T23:48:12+01:00

To musisz stworzyć kolejną zmienną w której będziesz pamiętał ten twój pierwotny niejako stan impulsów i po skończonym cyklu PRACA program zatrzyma się na pytaniu "co dalej?" Powtórka cyklu czy nowy cykl.
Jak powtórka to przepiszesz tą zapamiętaną wartość znowu do "n" a jak nowy cykl to przechodzisz to ustawiania liczby impulsów i po zatwierdzeniu znowu zapisujesz już nowo wpisaną liczbę impulsów do "n" i do zmiennej do pamiętania.

Statystyki: Napisane przez niemy — 7 sty 2014, o 23:48

Re: Sterownik skręcarki Atmega 8

2014-01-07T23:05:03+01:00

Nie, nie żadnych gotowców, od tego jest forum żeby się czegoś nauczyć Ale z podpowiedzi jak zrobić te 2 rzezy chętnie skorzystam. Program pisałem sam, a ze jestem jeszcze początkujący w prockach to pytam. Wartość licznika ma powracać do tej ustawionej na początku ustawień czyli nabijam 300 impulsów klawiszami, wrzucam do pamięci ram, klikam kierunek, licznik dobija zera, cofa w kierunku przeciwnym ileś tam i po opóźnieniu z pamięci ram nabija znowu 300.

Statystyki: Napisane przez hopek — 7 sty 2014, o 23:05

Re: Sterownik skręcarki Atmega 8

2014-01-07T22:43:45+01:00

Chcesz gotowy program, czy podpowiedź do algorytmu działania.
Tak jak zawsze mówi Pan Mirek - kartka długopis i wyrysować sobie.

Ja bym zrobił to w ten sposób, że wprowadziłbym kolejną zmienną np. PRACA aby określić czy już skręcasz drut czy jesteś jeszcze w ustawieniach. I potem prosto jeżeli n=0 (bo to chyba ilość impulsów) a PRACA ciągle trwa to poczekaj sekundkę i obróć kierunek i pięć impulsików w górę i wtedy koniec PRACY.

A z zapamiętaniem wartości to chcesz ją zapamiętać powiedzmy na zawsze czy chcesz tylko zapamiętać na następny cykl pracy czyli jakby aktualna ilość skrętów na dzisiaj?

OK moje rozważania ?

Statystyki: Napisane przez niemy — 7 sty 2014, o 22:43

Sterownik skręcarki Atmega 8

2014-01-07T00:47:18+01:00

Witam. Panie i Panowie, przyszło mi napisać sterownik do skręcarki prętów metalowych. Udało mi się to zrobić i na stoliku układ działa poprawnie.
Zasada działania:
Silnik 3 fazowy sterowany lewo, prawo przez styczniki 24v. Na wałku silnika znajduje się przekładnia z 1400 obr/min. na 30 obr/min. Dalej na wałku zdawczym z przekładni mam założone koło zębate z ABS i czujnik indukcyjny 24V ze stykami NO i NC zwieranymi do masy. Program działa tak:
1. Zrobiony jest licznik do którego klawiszami nabijam żądaną wartość impulsów (klawisze do wyboru: -1, +100, +10, +1).
2. Jednym z 2 klawiszy wybieram kierunek skręcania (lewo, prawo).
3. Po kliknięciu klawiszem wyboru kierunku załączam stycznik i impulsy z czujnika odejmują po jednym z wartości początkowej licznika aż do wartości 0 gdzie w tym momencie wyłączam stycznik i silnik się zatrzymuje. Podczas pracy silnika (odejmowania impulsów) klawisze wyboru kierunku, dodawania i odejmowania wartości są zblokowane. Aktywny jest tylko przycisk RESET/STOP, który podczas pracy zatrzymuje silnik i zeruje wartość licznika a podczas stanu oczekiwania tylko zeruje licznik. Oczywiście wszystko wyświetlam na LCD

Chciałbym jeszcze dorobić 2 rzeczy czyli automatyczne cofanie (odprężanie materiału) o np. 5 impulsów z opóźnieniem 1 sekundy od zatrzymania, oraz zapamiętywanie wartości początkowej licznika, żeby nie nabijać tego od nowa klawiszami.
I tu zwracam się z prośbą do Was o poradę jak...

Wiem że może dla większości wygląda to śmiesznie, ale no cóż działa

Niżej podaję kod programu:
[syntax=c]/*
* main.c
*
* Created on: 2014-01-01
* Author: hopek
* wersja 1.1
*/

#include
#include
#include
#include
#include "LCD/lcd44780.h"

//definicja pinu dla diody LED
#define LED_PIN (1<#define LED_ON PORTC &= ~(1<#define LED_OFF PORTC |= (1<
//piny dla styczników
#define OUT1 (1<#define OUT2 (1<
#define OUT1_ON PORTB &= ~OUT1;
#define OUT2_ONPORTB &= ~OUT2;
#define OUT1_OFF PORTB |= OUT1;
#define OUT2_OFF PORTB |= OUT2;

//definicje klawiszy
#define KEY1 (1<#define KEY2 (1<#define KEY3 (1<#define KEY4 (1<#define KEY5 (1<#define KEY6 (1<#define KEY7 (1<
//sprawdzanie stanów klawiszy (czy wcisnięte)
#define KEY1_DOWN !(PIND & KEY1)
#define KEY2_DOWN !(PIND & KEY2)
#define KEY3_DOWN !(PIND & KEY3)
#define KEY4_DOWN !(PIND & KEY4)
#define KEY5_DOWN !(PIND & KEY5)
#define KEY6_DOWN !(PINB & KEY6)
#define KEY7_DOWN !(PINB & KEY7)

//pin czujnika
#define IMP (1<

//definicje własnych znaków LCD
uint8_t tab1 [] = {16,24,28,30,28,24,16,32}; //strzałka prawo
uint8_t tab2 [] = {1,3,7,15,7,3,1,32};//strzałak lewo
uint8_t tab3 [] = {2,4,14,16,14,1,30,32};//litera s
uint8_t tab4 [] = {2,4,14,16,16,17,14,32};//litera ć
uint8_t tab5 [] = {2,4,14,17,17,17,14,32};//litera ó
uint8_t tab6 [] = {32,32,14,17,31,16,14,2}; //litera ę

uint8_t imp_lock, key1_lock, key2_lock, key3_lock, key4_lock, key5_lock, key6_lock, key7_lock;
uint8_t czujnik1(void);
uint16_t licznik(void);
uint16_t n=0;

int main(void)
{
DDRC |= LED_PIN; //kierunek pinu PC7 wyjściowy
PORTC |= LED_PIN; //wyłączenie diody
DDRD &= ~ (IMP | KEY1 | KEY2 | KEY3 | KEY4 | KEY5); //kierunki portów jako wejściowe
PORTD |= IMP | KEY1 | KEY2| KEY3 | KEY4 | KEY5;//klawisze do VCC
DDRB &= ~(KEY6 | KEY7);
PORTB |= KEY6 | KEY7;
DDRB |= OUT1 | OUT2;
PORTB |= OUT1 | OUT2;
OUT1_OFF;
OUT2_OFF;

lcd_init(); //inicjalizacja LCD

lcd_defchar ( 0x80, tab1);
lcd_defchar( 0x81, tab3);
lcd_defchar( 0x82, tab4);
lcd_defchar ( 0x83, tab5);
lcd_defchar ( 0x84, tab6);

lcd_locate(0,0);

//efekty specjalne
lcd_str("S");
_delay_ms(100);

lcd_locate(0,1);
lcd_str("t");
_delay_ms(100);

lcd_locate(0,2);
lcd_str("e");
_delay_ms(100);

lcd_locate(0,3);
lcd_str("r");
_delay_ms(100);

lcd_locate(0,4);
lcd_str("o");
_delay_ms(100);

lcd_locate(0,5);
lcd_str("w");
_delay_ms(100);

lcd_locate(0,6);
lcd_str("n");
_delay_ms(100);

lcd_locate(0,7);
lcd_str("i");
_delay_ms(100);
lcd_locate(0,8);

lcd_str("k");
_delay_ms(100);

lcd_locate(1,0);
lcd_str("S");
_delay_ms(100);

lcd_locate(1,1);
lcd_str("k");
_delay_ms(100);

lcd_locate(1,2);
lcd_str("r");
_delay_ms(100);

lcd_locate(1,3);
lcd_str("\x84");
_delay_ms(100);

lcd_locate(1,4);
lcd_str("c");
_delay_ms(100);

lcd_locate(1,5);
lcd_str("a");
_delay_ms(100);

lcd_locate(1,6);
lcd_str("r");
_delay_ms(100);

lcd_locate(1,7);
lcd_str("k");
_delay_ms(100);

lcd_locate(1,8);
lcd_str("i");
_delay_ms(500);

lcd_locate(1,10);
lcd_str(" v1.1");

_delay_ms(1000);

while(1)
{
if(czujnik1())
{
licznik();
}

lcd_locate(0,0);
lcd_str("Ilo\x81\x82 impuls\x83w:");
lcd_locate (1,0);
lcd_int(n);
lcd_str(" ");

//OBSŁUGA DRGAŃ STYKÓW I KLAWISZY

//klawisz 1 (zmniejszanie o 1)
if( !key1_lock && !(PIND & KEY1 ) )
{
key1_lock=1;
n--;
}
else if( key1_lock && (PIND & KEY1 ) ) key1_lock=0;

//klawisz 2 (zwiększanie o 1)
if( !key2_lock && !(PIND & KEY2 ) )
{
key2_lock=1;
n ++;
}
else if( key2_lock && (PIND & KEY2 ) ) key2_lock=0;

//klawisz 3 (zwiększanie o 10)
if( !key3_lock && !(PIND & KEY3 ) )
{
key3_lock=1;
n +=10;
}
else if( key3_lock && (PIND & KEY3 ) ) key3_lock=0;

//klawisz 4 (zwiększanie o 100)
if( !key4_lock && !(PIND & KEY4 ) )
{
key4_lock=1;
n +=100;
}
else if( key4_lock && (PIND & KEY4 ) ) key4_lock=0;

//klawisz 5 (kasowanie licznika)
if( !key5_lock && !(PIND & KEY5 ) )
{
key5_lock=1;
n =0;
}
else if( key5_lock && (PIND & KEY5 ) ) key5_lock=0;

//klawisz 6 (stycznik 1)
if( !key6_lock && !(PINB & KEY6 ) )
{
key6_lock=1;
OUT1_ON;
}

else if( key6_lock && (PINB & KEY6 ) )
key6_lock=0;

//klawisz 7 (stycznik 2)
if( !key7_lock && !(PINB & KEY7 ) )
{
key7_lock=1;
OUT2_ON;
}
else if( key7_lock && (PINB & KEY7 ) ) key7_lock=0;

//warunek wyłączający oba wyjscia styczników gdy licznik osiągnie wartosć 0
if(n==0)
{
OUT1_OFF;
OUT2_OFF;
}

//warunek nie pozwalający na ujemne stany licznika
if (n==-1)
{
n=0;
}

//warunek blokujący klawisze podczas pracy, żeby nie było bum. Klawisz reset aktywny.
if ((!(PORTB & OUT1)) || (!(PINB & OUT2)))
{
key1_lock=1;
key2_lock=1;
key3_lock=1;
key4_lock=1;
key6_lock=1;
key7_lock=1;
}
}
}

uint8_t czujnik1(void)
{
if( !imp_lock && !(PIND & IMP ) )
{
imp_lock=1;
n--;

// mignij diodą z każdym impulsem
LED_ON;
_delay_ms(10);
LED_OFF;
}
else if( imp_lock && (PIND & IMP ) ) imp_lock=0;
return 0;

}
uint16_t licznik(void)
{
static uint16_t licznik; //definicja zmiennej statycznej
n = licznik++;
return n;
}[/syntax]

Statystyki: Napisane przez hopek — 7 sty 2014, o 00:47