Re: PWM i zwieszanie się procesora

2015-04-02T22:20:06+01:00

Gdy używałem programu:[syntax=c]/*
* main.c
* Created on: 2014-06-13
* Autor: M.Bajgrowicz
* ------------
* | | | |
* | | | |
* | | | |
* | M1 M2 |
* | | | |
* ------------
*
*/

#include
#include
#include "hardware.h" // plik nagłówkowy z ustawieniami PCB

int main(void)
{

LED_DIR |= 0xFF; // kierunek portu z diodami - WYjściowy
KEY_DIR &= ~(W1_PIN | W2_PIN | W3_PIN | W4_PIN); // kierunek pinów przycisków - WEjściowy
KEY_PORT |= W1_PIN | W2_PIN | W3_PIN | W4_PIN; // podciagniecie pinów rezystorem do +Vcc
_delay_ms(20); // czas potrzebny na podciągnięcie pinów do +Vcc

while(1)
{

if ( !KEY1 && !KEY2 && !KEY3 && !KEY4 ) // Brak czynności
{
LED_PORT = 0x00;
}

else if ( KEY1 && !KEY2 && !KEY3 && !KEY4 ) // Do Przodu (M1 i M2 obr Prawe)
{ D1_ON; D4_ON;}
//else { D1_OFF; D4_OFF;}

else if ( !KEY1 && KEY2 && !KEY3 && !KEY4 ) // Do Tyłu (M1 i M2 obr Lewe)
{ D2_ON; D3_ON; }
//else { D2_OFF; D3_OFF; }

else if ( !KEY1 && !KEY2 && KEY3 && !KEY4 ) // W Prawo (M1 obr prawe, M2 obr lewe)
{ D3_ON; D4_ON; }
//else { D3_OFF; D4_OFF; }

else if ( !KEY1 && !KEY2 && !KEY3 && KEY4 ) // W Lewo (M1 obr lewe, M2 obr Prawe)
{ D1_ON; D2_ON;}
//else { D1_OFF; D2_OFF; }

else if ( KEY1 && !KEY2 && KEY3 && !KEY4 ) // Do przodu i w prawo (M1 obr Prawe)
{ D4_ON; }
//else { D4_OFF; }

else if ( KEY1 && !KEY2 && !KEY3 && KEY4 ) // Do przodu i w lewo (M2 obr Prawe)
{ D1_ON; }
//else { D1_OFF; }

else if ( !KEY1 && KEY2 && KEY3 && !KEY4 ) // Do tyłu i w prawo (M1 obr Lewe)
{ D3_ON; }
//else { D3_OFF; }

else if ( !KEY1 && KEY2 && !KEY3 && KEY4 ) // Do tyłu i w lewo (M2 obr Lewe)
{ D2_ON; }
//else { D2_OFF; }

} //koniec pętli while(1)
} //koniec programu[/syntax] To nie występowało "blokowanie się" procesora a jedynie działo się coś w rodzaju bardzo częstej utraty sygnału-tj po kilku sekundach jakby gubił sygnał i trzeba było ponawiać komendę..

Myślałem nad czymś w rodzaju watchdoga ale nie wiem jak to zrealizować

Statystyki: Napisane przez Rygart_z_Tarrs — 2 kwi 2015, o 22:20

Re: PWM i zwieszanie się procesora

2015-04-02T19:39:51+01:00

WoodPaker napisał(a):

Ds3 napisał(a):

Albo ja dzisiaj dziwnie widzę, albo ten schemat nie jest pełny, albo jest coś z nim nie tak.!

Dziwnie widzisz bo nie ma przecież żadnego schematu.

To bardzo ciekawe... Widziałem go od samego początku. Niemniej chodziło mi o płytkę PCB

A jeśli napiszesz prosty program - samo PWM to też po jakimś czasie zawiesza się mikrokontroler?

Pozdrawiam!

Statystyki: Napisane przez Ds3 — 2 kwi 2015, o 19:39

Re: PWM i zwieszanie się procesora

2015-04-02T17:47:23+01:00

Tam jest kabelek;] Silniki raczej nie generują aż takich zakłóceń(jak już to biją po przetwornicy)-a na 100% nie maja wpływu na sygnały wejściowe;]

PS linki naprawione

Statystyki: Napisane przez Rygart_z_Tarrs — 2 kwi 2015, o 17:47

Re: PWM i zwieszanie się procesora

2015-04-02T16:29:37+01:00

Ds3 napisał(a):

Albo ja dzisiaj dziwnie widzę, albo ten schemat nie jest pełny, albo jest coś z nim nie tak.!

Dziwnie widzisz bo nie ma przecież żadnego schematu.

Statystyki: Napisane przez WoodPaker — 2 kwi 2015, o 16:29

Re: PWM i zwieszanie się procesora

2015-04-02T15:53:18+01:00

Albo ja dzisiaj dziwnie widzę, albo ten schemat nie jest pełny, albo jest coś z nim nie tak.
Gdzie na płytce jest podłączony pin reset do VCC przez rezystor?
Część kondensatorów wisi w powietrzu, a część jest zwarta ścieżką.
Gdzie jest podłączona połowa masy mikrokontrolera - nóżka 8?

Dobrze byłoby dodać kondensator 10uF przy mikrokontrolerze.

Pozdrawiam!

Statystyki: Napisane przez Ds3 — 2 kwi 2015, o 15:53

Re: PWM i zwieszanie się procesora

2015-04-02T12:49:15+01:00

Może zawiesza się od zakłóceń generowanych przez silniki.

Statystyki: Napisane przez 0livaw — 2 kwi 2015, o 12:49

PWM i zwieszanie się procesora

2015-04-02T17:56:49+01:00

Witam, napisałem prosty program PWM dla pojazdu gąsienicowego (Napędzany 2 silnikami dc 3V)
Schemat:
Schemat PCB:
(Doszło kilka dodatkowych kondensatorów-ale to nie ma wpływu na program) Sterowanie robotem zostało zrealizowane za pomocą "modułu radiowego" ze zdalnie sterowanego autka(kable które bezpośrednio zasilały silniki teraz służą do podawania sygnałów binarnych-Za pomocą tranzystorów NPN zwierają piny procesora do masy
A teraz najważniejsze(program):

[syntax=c]/*
* Data utworzenia: 14-3-2015
* Author: M.Bajgrowicz
*
* ------------
* | | | |
* | | | |
* | | | |
* | M1 M2 |
* | | | |
* ------------
*
*
*DRV8833 - dwukanałowy sterownik silników DC, prąd na kanał 1,2 A (chwilowy do 2 A), zasilanie od 2,7 do 10,8 V.
*
*
*
*/

#include
#include
#include
#include "hardware.h"

volatile uint8_t pwm1, pwm2, pwm3, pwm4, pwm5, pwm6, pwm7, pwm8, pwm9, pwm10; // programowy OCR, określa współczynnik wypełnienia PWM
volatile uint8_t tryb=0;// 8 - bitowa zmienna trybów jazdy (256 trybów)
uint8_t i;// licznik zmiany współczynnika wypełnienia kanałów PWM

int main(void)
{

//***** PROGRAMOWY PWM - 4 KANAŁOWY, Generator zewnętrzny 16MHz, uP = ATmega8 *******

OUT_DIR |= ( (1< OUT_PORT &= ~( (1<
KEY_DIR &= ~( W1_PIN | W2_PIN | W3_PIN | W4_PIN );// kierunek pinów przycisków - WEjściowy
KEY_PORT |= ( W1_PIN | W2_PIN | W3_PIN | W4_PIN ); // podciagniecie pinów rezystorem do +Vcc
_delay_ms(20);

// zegar dla sygnału PWM z 8-bitowego TIMER2 w trybie CTC
TCCR2 |= (1< TCCR2 |= (1< OCR2 = 100; // zliczamy od 0 do 100, f = 2MHz/100 = 20kHz, przerwanie co 50us (T=1/f)
TIMSK |= (1<
sei(); // odblokowanie globalne przerwań

while(1)
{

/***************************************************************************************************/
// TRYB 0: HAMOWANIE
/***************************************************************************************************/

if ( !KEY1 && !KEY2 && !KEY3 && !KEY4 )
{
tryb = 0;
i=0;// resetuje podtrzymanie PWM max

// Sposób zatrzymywania silników A i B:
A_IN1_OFF; A_IN2_OFF;// wybieg silnika M1, A_IN1 = 0, A_IN2 = 0
B_IN1_OFF; B_IN2_OFF;// wybieg silnika M2, B_IN1 = 0, B_IN2 = 0

//A_IN1_ON; A_IN2_ON;// hamowanie silnika M1, A_IN1 = 1, A_IN2 = 1
//B_IN1_ON; B_IN2_ON;// hamowanie silnika M2, B_IN1 = 1, B_IN2 = 1

//_delay_ms(30);
}

/***************************************************************************************************/
// TRYB 1: DO PRZODU (KEY1)
/***************************************************************************************************/

if ( KEY1 && !KEY2 && !KEY3 && !KEY4 )
{
tryb = 1;

if(i<255)
{
for(i=254; i<255; i++)
{
if(KEY1) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm1=i;
//_delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 2: DO TYŁU (KEY2)
/***************************************************************************************************/

if ( !KEY1 && KEY2 && !KEY3 && !KEY4 )
{
tryb = 2;

if(i<255)
{
for(i=254; i<255; i++)
{
if(KEY2) // zmiana pwm tylko w trakcie trzymania KEY2
{
pwm2=i;
//_delay_ms(10);
}

}
}

}

/***************************************************************************************************/
// TRYB 3: OBRÓT W PRAWO (KEY3)
/***************************************************************************************************/
if ( !KEY1 && !KEY2 && KEY3 && !KEY4 )
{
tryb = 3;
tryb = 4;

if(i<255)
{
for(i=254; i<255; i++)
{
if(KEY3) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm3=i;
pwm4=i;
//_delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 4: OBRÓT W LEWO (KEY4)
/***************************************************************************************************/
if ( !KEY1 && !KEY2 && !KEY3 && KEY4 )
{
// tryb = 5;
tryb = 6;

if(i<255)
{
for(i=254; i<255; i++)
{
if(KEY4) // zmiana pwm tylko w trakcie trzymania KEY1
{
//pwm5=i;
pwm6=i;
//_delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 5: DO PRZODU I OBRÓT W PRAWO (KEY1 i KEY3)
/***************************************************************************************************/
if ( KEY1 && !KEY2 && KEY3 && !KEY4 )
{
tryb = 7;

if(i<255)
{
for(i=254; i<255; i++) {
if(KEY1 && KEY3) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm7=i;

//_delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 6: DO PRZODU I OBRÓT W LEWO (KEY1 i KEY4)
/***************************************************************************************************/
if ( KEY1 && !KEY2 && !KEY3 && KEY4 )
{
tryb = 8;

if(i<255)
{
for(i=254; i<255; i++)
{
if(KEY1 && KEY4) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm8=i;
// _delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 7: DO TYŁU I OBRÓT W PRAWO (KEY2 i KEY3)
/***************************************************************************************************/
if ( !KEY1 && KEY2 && KEY3 && !KEY4 )
{
tryb = 9;

if(i<255)
{
for(i=200; i<255; i++)
{
if(KEY2 && KEY3) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm9=i;
//_delay_ms(10);
}

}
}
}

/***************************************************************************************************/
// TRYB 8: DO TYŁU I OBRÓT W LEWO (KEY2 i KEY4)
/***************************************************************************************************/

if ( !KEY1 && KEY2 && !KEY3 && KEY4 )
{
tryb = 10;
if(i<255)
{
for(i=200; i<255; i++)
{
if(KEY2 && KEY4) // zmiana pwm tylko w trakcie trzymania KEY1
{
pwm10=i;
// _delay_ms(10);
}

}
}
}

}//while
}//main

// ciało procedury obsługi przerwania Compare Match Timera2

ISR( TIMER2_COMP_vect )
{
static uint8_t cnt; // definicja licznika PWM

if(tryb == 1) {if ((cnt<=pwm1)) { A_IN1_ON; A_IN2_OFF;B_IN1_OFF; B_IN2_ON; } //m1 i m2 przód
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF; }}

if(tryb == 2) {if ((cnt<=pwm2)) { A_IN1_OFF; A_IN2_ON;B_IN1_ON; B_IN2_OFF; } // m1 i m2 tył
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF; }}

if(tryb == 3) {if ((cnt<=pwm3)) { A_IN1_ON; A_IN2_OFF;} //m1 przód
else { A_IN1_OFF; A_IN2_OFF; }}
if(tryb == 4) {if ((cnt<=pwm3)) {B_IN1_ON; B_IN2_OFF; } // m2 tył
else { B_IN1_OFF; B_IN2_OFF; }}

if(tryb == 5) {if ((cnt<=pwm4)) { A_IN1_OFF; A_IN2_ON; } //m1 tył,
else { A_IN1_OFF; A_IN2_OFF; }}
if(tryb == 6) {if ((cnt<=pwm4)) { B_IN1_OFF; B_IN2_ON; }
else { B_IN1_OFF; B_IN2_OFF; } } // m2 przód

if(tryb == 7) {if ((cnt<=pwm1)) { A_IN1_ON; A_IN2_OFF; } //m1 przód
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF;}}

if(tryb == 8) {if ((cnt<=pwm1)) { B_IN1_OFF; B_IN2_ON;} //m2 przód
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF;}}

if(tryb == 9) {if ((cnt<=pwm2)) { A_IN1_OFF; A_IN2_ON; } //m1 tył
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF;}}

if(tryb == 10) {if ((cnt<=pwm2)) { B_IN1_ON; B_IN2_OFF; } //m2 tył
else { A_IN1_OFF; A_IN2_OFF; B_IN1_OFF; B_IN2_OFF;}}

cnt++; // zwiększanie licznika ilości przerwań

// Przerwanie występuje co T(int) = 50us (ustawienie timera 2 w trybie CTC), czyli f(int) = 20kHz
// Przerwanie zliczane jest 256 razy dzięki zwiększaniu zmiennej cnt (tzw. PWM 8-bitowy)
// Okres sygnału PWM wynosi więc: T(pwm) = 256 * T(int) = 256 * 50us = 12,8ms
// Stąd f(pwm) = 78,125Hz

}[/syntax]

Opis Problemu: Po kilku sekundach otrzymywania tego samego sygnału wejściowego procesor zwiesza się-na dwa sposoby(albo wystawia inną kombinację wyjść albo po prostu przestaje działać) Występuje też "zapamiętywanie" ostatniego polecenia i gdy po kilku sekundach skrętu w prawo zmieniam sygnał na Lewo to czołg uparcie kręci w prawo.

W każdym z tych stanów sygnały wejściowe są ignorowane-dopiero odłączenie zasilania przywraca procek do normalnego działania

Statystyki: Napisane przez Rygart_z_Tarrs — 2 kwi 2015, o 12:09

ATNEL tech-forum

Re: PWM i zwieszanie się procesora

Re: PWM i zwieszanie się procesora

Re: PWM i zwieszanie się procesora

Re: PWM i zwieszanie się procesora

Re: PWM i zwieszanie się procesora

Re: PWM i zwieszanie się procesora

PWM i zwieszanie się procesora