ATNEL tech-forum 2016-01-11T18:56:41+01:00 https://forum.atnel.pl/feed.php?f=58&t=14141&mode 2016-01-11T18:56:41+01:00 2016-01-11T18:56:41+01:00 https://forum.atnel.pl/viewtopic.php?t=14141&p=150277#p150277 <![CDATA[Re: Problem z podciąganiem pinu PD2 do Vcc]]>
janusz17 napisał(a):

Moim zdaniem trzeba by tu dodać wpisywanie jedynki na bicie INT0_PIN

Dziękuję janusz17, zaproponowany przez Ciebie sposób rozwiązał problem :!:

Statystyki: Napisane przez oowan — 11 sty 2016, o 18:56

]]> 2016-01-10T09:50:11+01:00 2016-01-10T09:50:11+01:00 https://forum.atnel.pl/viewtopic.php?t=14141&p=150142#p150142 <![CDATA[Re: Problem z podciąganiem pinu PD2 do Vcc]]> [syntax=c]if(licznik==4) LED_DATA = pgm_read_byte( &cyfry[cyf1] ); // gdy zapalony wyśw.1 podaj wartość zmiennej cyf1
else if(licznik==8) LED_DATA = pgm_read_byte( &cyfry[cyf2] ); // gdy zapalony wyśw.2 podaj wartość zmiennej cyf2
else if(licznik==16) LED_DATA = pgm_read_byte( &cyfry[cyf3] ); // gdy zapalony wyśw.3 podaj wartość zmiennej cyf3
else if(licznik==32) LED_DATA = pgm_read_byte( &cyfry[cyf4] ); // gdy zapalony wyśw.4 podaj wartość zmiennej cyf4[/syntax]

Moim zdaniem trzeba by tu dodać wpisywanie jedynki na bicie INT0_PIN:
[syntax=c]if(licznik==4) LED_DATA = pgm_read_byte( &cyfry[cyf1] ) | INT0_PIN; // gdy zapalony wyśw.1 podaj wartość zmiennej cyf1
else if(licznik==8) LED_DATA = pgm_read_byte( &cyfry[cyf2] ) | INT0_PIN; // gdy zapalony wyśw.2 podaj wartość zmiennej cyf2
else if(licznik==16) LED_DATA = pgm_read_byte( &cyfry[cyf3] ) | INT0_PIN; // gdy zapalony wyśw.3 podaj wartość zmiennej cyf3
else if(licznik==32) LED_DATA = pgm_read_byte( &cyfry[cyf4] ) | INT0_PIN; // gdy zapalony wyśw.4 podaj wartość zmiennej cyf4[/syntax]

Statystyki: Napisane przez janusz17 — 10 sty 2016, o 09:50

]]> 2016-01-11T18:37:47+01:00 2016-01-10T00:54:44+01:00 https://forum.atnel.pl/viewtopic.php?t=14141&p=150129#p150129 <![CDATA[Problem z podciąganiem pinu PD2 do Vcc]]> Buduję zegar z wyświetlaczami LED. Są to pierwsze, nieśmiałe próby praktycznego zastosowana tego co się nauczyłem.

Obrazek Obrazek

Procesor Atmega8 taktuje wewnętrzny oscylator 8 MHz.
Czas pobierany jest z PCF8583 - książkowy przykład z BB.
Poniżej kod:

[ panie szanowny kolego - proszę jak najszybciej poprawić wstawiony kod na forum - przecież masz DOKŁADNĄ instrukcję topic7402.html - mirekk36 ]

[syntax=c]/*
* main.c
*/

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

#include "disp_led.h"// dołączenie pliku nagłówkowego z obsługą LED
#include "I2C_TWI/i2c_twi.h"

// UWAGA - wybierz adres jak niżej **
#define PCF8583_ADDR 0xA0// gdy A0 --> GND
// #define PCF8583_ADDR 0xA2// gdy A0 --> VCC

//** konfiguracja migania kropki sekundnika
#define INT0_PIN (1<<PD2)// wejście przerwania PD2
#define PIN_KROPKI (1<<PB1)// wyjście kropki sekundnika
#define LED_MIG PORTB ^= PIN_KROPKI// zmiana stanu kropki (segment DP)

// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec);

// konwersja liczby BCD na cyfrę jednostek dla wyśw. LED
uint8_t bcd2cyf1(uint8_t bcd);

// konwersja liczby BCD na cyfrę dziesiątek dla wyśw. LED
uint8_t bcd2cyf10(uint8_t bcd);

// flaga zmieniana w przerwaniu INT0
volatile uint8_t int0_flag;

// zmienne przechowujące wartości czasu odczytane z RTC
volatile uint8_t sek_jedn;// jednostki sekund
volatile uint8_t sek_dzies;// dziesiątki sekund
volatile uint8_t min_jedn;// jednostki minut
volatile uint8_t min_dzies;// dziesiątki minut
volatile uint8_t godz_jedn;// jednostki godzin
volatile uint8_t godz_dzies;// dziesiątki godzin

// definicja typu wyliczeniowego jako
// wskazania na indeksy w tablicy (buforze)
enum {ss, mm, hh};
uint8_t bufor[3];// rezerwacja bufora na 3 bajty

int main(void) {

// Inicjalizacja wyświetlacza LED
disp_led_init ();

sei();// włączenie globalnego zezwolenia na przerwania


// Przerwanie INT0
MCUCR |= (1<<ISC01);// wyzwalanie zboczem opadającym
GICR |= (1<<INT0);// odblokowanie przerwania
DDRD &= ~INT0_PIN;// port PD2 jako wejście (INT0)
PORTD |= INT0_PIN;// podciąganie pinu INT0 do VCC

// port PB1 jako wyjście
DDRB |= PIN_KROPKI;


// Ustawienie linii I2C
PORTC |= (1<<PC4) | (1<<PC5);// podciąganie pinu PC4 i PC5 do VCC

// predkość na magistrali I2C - 100 kHz
i2cSetBitrate( 100 );

// Ustawianie czasu na godzinę: 20:33:12
/*
//bufor[0] = 0;// setne częci sekundy
bufor[0] = dec2bcd(10);// sekundy
bufor[1] = dec2bcd(2);// minuty
bufor[2] = dec2bcd(19);// godziny
// zapis 4 bajtów z bufora pod adres 0x01 w pamięci RAM naszego RTC
TWI_write_buf( PCF8583_ADDR, 0x02, 3, bufor );
*/

while(1) {

if ( int0_flag ) {

LED_MIG;// zmień stan kropki na przeciwny

//odczyt 3 bajtów do bufora od adresu 0x02 z pamięci RAM układu RTC
TWI_read_buf( PCF8583_ADDR, 0x02, 3, bufor );

sek_jedn = bcd2cyf1( bufor[ss] );
sek_dzies = bcd2cyf10( bufor[ss] );
min_jedn = bcd2cyf1( bufor[mm] );
min_dzies = bcd2cyf10( bufor[mm] );
godz_jedn = bcd2cyf1( bufor[hh] );
godz_dzies = bcd2cyf10( bufor[hh] );

// Przekazywanie obliczonych wyżej wartości na poszczególne cyfry wyświetlacza.
if (godz_dzies == 0) cyf1 = 10; // Gdy wartość cyf1=0, to
else cyf1 = godz_dzies;// wyświetlacz jest wygaszony.
cyf2 = godz_jedn;
cyf3 = min_dzies;
cyf4 = min_jedn;

int0_flag = 0;

}

}


}


// procedura obsługi przerwania INT0
ISR( INT0_vect ) {
int0_flag = 1;
}


// konwersja liczby dziesiętnej na BCD (dla ustawiania zegara)
uint8_t dec2bcd(uint8_t dec) {
return ((dec / 10)<<4) | (dec % 10);
}

// konwersja liczby BCD na cyfrę jednostek dla wyśw. LED
uint8_t bcd2cyf1(uint8_t bcd) {
return ((bcd) & 0x0F);
}

// konwersja liczby BCD na cyfrę dziesiątek dla wyśw. LED
uint8_t bcd2cyf10(uint8_t bcd) {
return (((bcd) >> 4) & 0x0F);
}[/syntax]

[syntax=c]/*
* disp_led.h
*/

#ifndef _disp_led_h// dyrektywy zabezpieczające przed wielokrotnym dołączaniem
#define _disp_led_h// tego samego pliku nagłówkowego jeśli będzie dołączany
// w wielu rónych plikach programu

// definicje portów i pinów wyświetlacza jako stałe preprocesora
#define LED_DATA PORTD // port segmentów
#defineLED_DATA_DIR DDRD // port jako wyjście dla "katod" wyświetlaczy
#define ANODY_PORT PORTB // port anod - PB2, PB3, PB4, PB5
#define ANODY_DIR DDRB // port jako wyjście dla anod wyświetlaczy


#define A1 (1<<PB2)// A1 oznacza bit nr.0 portu D
#define A2 (1<<PB3)// A2 oznacza bit nr.1 portu D
#define A3 (1<<PB4)// A3 oznacza bit nr.4 portu D
#define A4 (1<<PB5)// A4 oznacza bit nr.5 portu D

#define MASKA_ANODY (A1|A2|A3|A4)

// definicje bitów dla segmentów LED. Pin PD2 jest pominięty,
// bo jest wejściem przerwania INT0 1Hz.
#define SEG_A (1<<0)
#define SEG_B (1<<1)
#define SEG_C (1<<3)
#define SEG_D (1<<4)
#define SEG_E (1<<5)
#define SEG_F (1<<6)
#define SEG_G (1<<7)
// #define SEG_DP (1<<7)// w zegarze DP jest sterowany z portu PB1,


// Deklaracje zmiennych globalnych przechowujących wartości
// poszczególnych cyfr wyświetlacza
extern volatile uint8_t cyf1;
extern volatile uint8_t cyf2;
extern volatile uint8_t cyf3;
extern volatile uint8_t cyf4;



void disp_led_init(void);

#endif// koniec _disp_led_h[/syntax]

[syntax=c]/*
* disp_led.c
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>// dołączenie pliku nagłówkowego potrzebnego do odczytu
// danych zawartych w pamięci programu FLASH

#include "disp_led.h"// dołączenie naszego pliku nagłówkowego

// definicje zmiennych globalnych przechowujących cyfry do wyświetlania (zmienne ulotne)
volatile uint8_t cyf1;
volatile uint8_t cyf2;
volatile uint8_t cyf3;
volatile uint8_t cyf4;


// definicja tablicy zawierającej definicje bitowe cyfr LED
// katody sterowane przez tranzystory w scalaku MCT1413 (ULN...)
// Przy sterowaniu katod bezpośrednio, wyjścia trzeba zanegować [np. ~(SEG_B|SEG_C),// 1 ]
const uint8_t cyfry[15] PROGMEM = {
(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F),// 0
(SEG_B|SEG_C),// 1
(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G),// 2
(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G),// 3
(SEG_B|SEG_C|SEG_F|SEG_G),// 4
(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G),// 5
(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G),// 6
(SEG_A|SEG_B|SEG_C),// 7 |SEG_F
(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G),// 8
(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G),// 9
0x00 // NIC (wygaszenie cyfry)
};



// definicja funkcji inicjalizującej pracę z wyświetlaczem multipleksowanym
void disp_led_init(void)
{
LED_DATA_DIR = 0b11111011;// wszystkie piny portu D (oprócz PD2) jako WYJŚCIA(katody)
//LED_DATA = 0xFF;// wygaszenie wszystkich katod - stan wysoki (może zanegować?)
ANODY_DIR |= A1 | A2 | A3 | A4;// 4 piny portu B jako WYJŚCIA (anody wyświetlaczy)
//ANODY_PORT |= A1 | A2 | A3 | A4;// wygaszenie wszystkich wyświetlaczy - anody


// Inicjalizacja Timera2
TCCR2 |= (1<<WGM21); // tryb CTC
TCCR2 |= (1<<CS22)|(1<<CS21); // prescaler = 256
OCR2 = 155; // liczba do porównania z licznikiem CTC (rej. przepełnienia)
TIMSK |= (1<<OCIE2); // zezwolenie na przerwanie CompareMatch

}


// PROCEDURA OBSŁUGI PRZERWANIA COMPARE MATCH
ISR(TIMER2_COMP_vect)
{
static uint8_t licznik=4;// zmienna do przełączania kolejno anod wyrwietlacza

ANODY_PORT = (ANODY_PORT | MASKA_ANODY);// wygaszenie wszystkich wyświetlaczy

if(licznik==4) LED_DATA = pgm_read_byte( &cyfry[cyf1] );// gdy zapalony wyśw.1 podaj wartość zmiennej cyf1
else if(licznik==8) LED_DATA = pgm_read_byte( &cyfry[cyf2] );// gdy zapalony wyśw.2 podaj wartość zmiennej cyf2
else if(licznik==16) LED_DATA = pgm_read_byte( &cyfry[cyf3] );// gdy zapalony wyśw.3 podaj wartość zmiennej cyf3
else if(licznik==32) LED_DATA = pgm_read_byte( &cyfry[cyf4] );// gdy zapalony wyśw.4 podaj wartość zmiennej cyf4

ANODY_PORT = (ANODY_PORT & ~MASKA_ANODY) | (~licznik & MASKA_ANODY);// cykliczne przełączanie kolejnej anody w każdym przerwaniu

// operacje cyklicznego przesuwania bitu zapalającego anody w zmiennej licznik
licznik <<= 1;// przesunięcie zawartości bitów licznika o 1 w lewo
if(licznik>32) licznik = 4;// jeśli licznik większy niż 32 to ustaw na 4
// porty anod sterowane kolejno: PB2, PB3, PB4, PB5
}[/syntax]

Pliki disp_led.h i disp_led.c, to zmodyfikowane pliki z BB.

Generalnie zegar działa. Tylko coś wyłącza podciągnie pinu PD2 (INT0) do Vcc. Dlatego musiałem dodać rezystor R1.
Nie mogę tego błędu znaleźć. Przypuszczam, że jest to związane z "pomijaniem" pinu PD2 w ustawianiu portu D jako wyjście dla segmentów.
Dodam, że pierwsze próby zegara robiłem z Atmegą32. Tam porty segmentów "leciały" po kolei i z podciąganiem pinu PD2 do Vcc nie było problemu.

Statystyki: Napisane przez oowan — 10 sty 2016, o 00:54

]]>