Wykorzystać 4 nieblokujące klawisze z następującymi funkcjami:
klawisz 1 - krótkie naciśnięcie start/stop odliczania czasu, długie naciśnięcie reset stopera
klawisz 2 - krótkie naciśnięcie "zatrzymanie" na wyświetlaczu czasu bieżącego, w tle cały czas trwało odliczanie czasu, ponowne naciśnięcie wznowienie wyświetlania czasu
klawisz 3 - krótkie naciśnięcie zmniejszenie intensywności świecenia wyświetlacza, długie naciśnięcie ustawienie intensywności na minimum (na filmie pokazane również odliczanie przy minimalnej intensywności)
klawisz 4 - krótkie naciśnięcie zwiększenie intensywności świecenia wyświetlacza, długie naciśnięcie ustawienie intensywności na maksimum
iframe
Obsługa klawiszy zaczerpnięta z bloga Mirka. A reszta z noty katalogowej MAX7219 i ATmega32.
Poniżej kody. Obsługa SPI jest w max7219.c bo nie chciałem już tworzyć oddzielnej biblioteki.
main.c
[syntax=c]/*
* Obsługa sterownika wyswietlaczy LED 7seg wsp. katoda MAX7219
*
* - sterowanie: SPI
* - mozliwosc kaskadowego łączenia układów
*
* Pliki:max7219.h, max7219.c
* Autor:Grzegorz Strzelec
* Data:02.03.2013
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "MAX7219/max7219.h"
#include "MICROSWITCH/microswitch.h"
#define KEY1 (1<<PC7)
#define KEY2 (1<<PC6)
#define KEY3 (1<<PC5)
#define KEY4 (1<<PC4)
#define START 1
#define HOLD2
button_t key1, key2, key3, key4; // definicja KLAWISZY
volatile uint8_t ssek=0, sek=0, stopwatch_flag=0, stopwatch_status=0; //deklaracja zmiennych dla stopera
void timer0_init();
void intensity_up();
void intensity_max();
void intensity_down();
void intensity_min();
void stopwatch_start_stop();
void stopwatch_reset();
void stopwatch_hold();
int main(void)
{
DDRC &= ~(KEY1 | KEY2 | KEY3 | KEY4); // ustwienie kierunku pinów jako wejscia
PORTC |= KEY1 | KEY2 | KEY3 | KEY4; // podciągnieecie linii klawiszy do VCC
key_init(&key1, &PINC, KEY1, 1, intensity_up, intensity_max);
key_init(&key2, &PINC, KEY2, 1, intensity_down, intensity_min);
key_init(&key3, &PINC, KEY3, 1, stopwatch_start_stop, stopwatch_reset);
key_init(&key4, &PINC, KEY4, 1, stopwatch_hold, 0);
spi_init(); // inicjalizacja SPI
max7219_init();// inicjalizacja MAX7219;
timer0_init();// inicjalizacja timera
sei();// zezwolenie na globalne przerwania
while(1) {
key_press( &key1 ); // obsługa klawiszy
key_press( &key2 );
key_press( &key3 );
key_press( &key4 );
// obsługa wyswietlania cyfr za pomocą MAX7219
if (stopwatch_flag) { // jezeli wystapiła zmiana czasi i potrzeba aktualizacji wyswietlaczy
if (!(stopwatch_status & HOLD)) { // jeżeli wcinięty HOLD nie wysyłaj danych do MAX7219
max7219_send(MAX7219_DIGIT0, ssek % 10);
max7219_send(MAX7219_DIGIT1, ssek / 10);
max7219_send(MAX7219_DIGIT2, ((sek % 10) | MAX7219_DP));
max7219_send(MAX7219_DIGIT3, sek /10);
}
stopwatch_flag = 0; // zerowanie flagi aktualizacji wywietlaczy
}
}
}
void timer0_init(void)
{
TCCR0 |= (1<<WGM01);// TIMER0 tryb CTC
TCCR0 |= (1<<CS02) | (1<<CS00); // ustawienie preskalera
OCR0 = 0x6B; // dodatkowy podzial
TIMSK |= (1<<OCIE0); // zezwolenie na przrwanie
}
ISR (TIMER0_COMP_vect)
{
uint16_t n;
n = key_timer; /* 100Hz key_timer - obsługa klawiszy*/
if (n) key_timer = --n;
stopwatch_flag=1; // ustawienie flagi aktualizacji danych na wywietlaczu
if (stopwatch_status & START) { // jezeli stoper pracuje zwiększ czas
ssek++;
if (ssek>60) {
ssek=0;
sek++;
if (sek>60) {
sek = 0;
}
}
}
}
// własne funkcje obslugi klawiszy
void intensity_up(void) { // zwiekszenie intensywnoci swiecenia wyswietlaczy
if (max7219_set_intensity<15) {
max7219_set_intensity++;
max7219_send(MAX7219_INTENSITY, max7219_set_intensity);
}
}
void intensity_max(void) { // ustawienie maksymalnej intensywnoci swiecenia wyswietlaczy
max7219_set_intensity = 15;
max7219_send(MAX7219_INTENSITY, max7219_set_intensity);
}
void intensity_down(void) { // zmniejszenie intensywnoci wiecenia wyswietlaczy
if (max7219_set_intensity>0) {
max7219_set_intensity--;
max7219_send(MAX7219_INTENSITY, max7219_set_intensity);
}
}
void intensity_min(void) { // ustawienie minimalnej intensywnoci swiecenia wyswietlaczy
max7219_set_intensity = 0;
max7219_send(MAX7219_INTENSITY, max7219_set_intensity);
}
void stopwatch_start_stop(void) { // start / stop odliczania czasu
stopwatch_status ^= START;
}
void stopwatch_reset(void) { // resetowanie stopera
stopwatch_status &= ~( START | HOLD);
ssek=0;
sek=0;
}
void stopwatch_hold(void) { // zatrzymanie danych na wyswietlaczu, w tle odliczanie czasu
stopwatch_status ^= HOLD;
}
[/syntax]
max7219.h
[syntax=c]/*
* max7219.h
* Plik nagłówkowy biblioteki
* Obsługa sterownika wyswietlaczy LED 7seg wsp. katoda MAX7219
*
* - sterowanie: SPI
* - mozliwosc kaskadowego łączenia układów
*
* Pliki:max7219.h, max7219.c
* Autor:Grzegorz Strzelec
* Data:02.03.2013
*/
#ifndef MAX7219_H_
#define MAX7219_H_
// okreslenie liczby wywietlaczy 7seg. sterowanych przy pomocy układu
#define MAX7219_USE_DIGIT4
// -------------------------------------------------------------
// adresy rejestrów układu MAX7219
// -------------------------------------------------------------
#define MAX7219_NOOP0x00// rejestr używany przy kaskadowym połączeniu układów MAX7219 ze wspólną linią CS
#define MAX7219_DIGIT00x01// DIGIT 0..7 - rejestry danych kolejnych wyswietlaczy 7seg LED
#define MAX7219_DIGIT10x02
#define MAX7219_DIGIT20x03
#define MAX7219_DIGIT30x04
#define MAX7219_DIGIT40x05
#define MAX7219_DIGIT50x06
#define MAX7219_DIGIT60x07
#define MAX7219_DIGIT70x08
#define MAX7219_DECODE_MODE0x09 // bity 0..7 opisują sposób dekodowania danych z rejestrów DIGIT0..7 (0 - standard dla 7-seg, 1 - BCD)
#define MAX7219_INTENSITY0x0A// regulacja intensywnoci swiecenia wyswietlaczy
#define MAX7219_SCAN_LIMIT0x0B// okrelenie liczby sterowanych układem wyswitlaczy (bity 0..2) - 0x00 - tylko 1 wys., 0x07 - wszystkie 8 wysw.
#define MAX7219_SHUTDOWN0x0C// tryb pracy wyswietlacza (0 - shutdown, 1 - normal)
#define MAX7219_DISPLAY_TEST0x0F// test wyswietlacza (załączenie wszystkich segmentów)
// -------------------------------------------------------------
// komendy sterujące
// -------------------------------------------------------------
#define MAX7219_SHUTDOWN_MODE0
#define MAX7219_NORMAL_OPPERATION1
// -------------------------------------------------------------
// ustawienie sposobu dekodowania danych na wywietlacz
//
// 0 na bicie reprezentującym wywietlacz - zwykłe kodowanie jak dla 7seg.
// 1 na bicie reprezentującym wywietlacz - kodowanie BCD
//
// -------------------------------------------------------------
#define MAX7219_USE_BCD_DECODE0b11111111
// ustawienie 7 bitu - włączenie znaku "kropka".
#define MAX7219_DP (1<<7)
extern uint8_t max7219_set_intensity;
// definicja funkcji
void spi_init();
void max7219_init();
void max7219_send(uint8_t, uint8_t);
#endif /* MAX7219_H_ */
[/syntax]
max7219.c
[syntax=c]/*
* max7219.c
* Biblioteka
* Obsługa sterownika wyswietlaczy LED 7seg wsp. katoda MAX7219
*
* - sterowanie: SPI
* - mozliwosc kaskadowego łączenia układów
*
* Pliki:max7219.h, max7219.c
* Autor:Grzegorz Strzelec
* Data:02.03.2013
*/
#include <avr/io.h>
#include "max7219.h"
#define MOSI PB5
#define SCK PB7
#define CS PB4
uint8_t max7219_set_intensity = 15; // początkowa intensywnoć swiecenia wywietlaczy;
// inicjalizacja sprzetowego SPI
void spi_init(void)
{
DDRB |= (1<<MOSI) | (1<<SCK) | (1<<CS); // ustawienie kierunku portu B
SPCR |= (1<<SPE) | (1<<MSTR); // SPE - włączenie sprzętowego SPI, MSTR - układ master
SPSR |= (1<<SPI2X); // podwojenie predkosci SPI (taktowanie Fosc/2)
}
// wysłanie 2 bajtów do układu MAX7219
// 1 bajt (adr) - adres rejestru do którego będą pisane dane
// 2 bajt (data) - dane do zapisania
void max7219_send(uint8_t adr, uint8_t data)
{
PORTB &= ~(1<<CS);// ustawienie stanu niskiego na linii CS
SPDR = adr; // bajt do wysłania do SPI data register
while (!(SPSR & (1<<SPIF))); // oczekiwanie na koniec przesyłania danych, sprawdzenie flagi SPIF - pierwszy odczyt po przesłanu danych kasuje flagę
SPDR = data;// bajt do wysłania do SPI data register
while (!(SPSR & (1<<SPIF))); // oczekiwanie na koniec przesyłania danych,
PORTB |= (1<<CS);// ustawienie stanu wysokiego na linii CS (zatrzasnięcie danych w układzie zboczem narastajacym)
}
// inicjalizacja układu MAX7219
void max7219_init(void)
{
max7219_send(MAX7219_SCAN_LIMIT, (MAX7219_USE_DIGIT-1)); // liczba obsługiwanych wywietlaczy
max7219_send(MAX7219_INTENSITY, max7219_set_intensity);// maksymalna jasnosc
#if MAX7219_USE_BCD_DECODE == 0// ustawienie trybu wyswietlania dla poszczególnych wyswietlaczy
max7219_send(MAX7219_DECODE_MODE, 0);
#else
max7219_send(MAX7219_DECODE_MODE, MAX7219_USE_BCD_DECODE);
#endif
max7219_send(MAX7219_SHUTDOWN, MAX7219_NORMAL_OPPERATION);// włączenie układu (normal operation)
}
[/syntax]
microswitch.h
[syntax=c]/*
* microswitch.h
*
* Created on: 09-03-2013
* Author: Grzegorz Strzelec
*/
#ifndef MICROSWITCH_H_
#define MICROSWITCH_H_
extern volatile uint16_t key_timer;
typedef struct {
volatile uint8_t *KPIN;
uint8_t key_mask;
uint8_t wait_time_s;
void (*kfun1)(void);
void (*kfun2)(void);
uint8_t klock;
uint8_t flag;
} button_t;
void key_init( button_t * btn,
volatile uint8_t *KPIN,
uint8_t key_mask,
uint8_t wait_time,
void (*push_proc)(void),
void (*push2_proc)(void) );
void key_press(button_t * btn);
#endif /* MICROSWITCH_H_ */
[/syntax]
microswitch.c
[syntax=c]/*
* microswitch.c
*
* Created on: 09-03-2013
* Author: Grzegorz Strzelec
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include "microswitch.h"
// timery programowy
volatile uint16_t key_timer;
void key_init( button_t * btn, volatile uint8_t * KPIN, uint8_t key_mask, uint8_t wait_time, void (*push_proc)(void), void (*push2_proc)(void) ) {
btn->KPIN = KPIN;
btn->key_mask = key_mask;
btn->wait_time_s = wait_time;
btn->kfun1 = push_proc;
btn->kfun2 = push2_proc;
}
void key_press( button_t * btn ) {
register uint8_t key_press = (*btn->KPIN & btn->key_mask);
if( !btn->klock && !key_press ) {
btn->klock=1;
if(btn->kfun1) btn->kfun1();
btn->flag=1;
key_timer = (btn->wait_time_s*1000)/10;
}
else
if( btn->klock && key_press ) {
(btn->klock)++;
if( !btn->klock ) {
key_timer=0;
btn->flag=0;
}
} else
if( btn->flag && !key_timer ) {
if(btn->kfun2) btn->kfun2();
btn->flag=0;
}
}
[/syntax]
A teraz jeszcze pytanie.
Co radzicie do dokładnego odmierzania czasu? Chodzi o to, ze chciałbym wykonać układ mierzący czas z dokładnością właśnie do 1/100 sek ale pomiary muszą być dokładne. Chodzi o odmierzanie czasu biegu. Wyzwolenie i zatrzymanie tego pomiaru to inna sprawa, obecnie chodzi mi tylko o odmierzenie czasu. Myślałem nad jakimś rtc umożliwiającym generowanie co 10 ms przerwania (chyba jest to stabilniejsze niż zwykły timer w mikrokontrolerze) co o tym sądzicie? A może jakieś inne podpowiedzi?
Statystyki: Napisane przez strzelec — 10 mar 2013, o 14:12
]]>