Założenia projektu:
2 przyciski- wyższy bieg, niższy bieg
7-segmentowy wyświetlacz LED wskazujący aktualną pozycję. Co to znaczy? Ano tylko tyle, że gdy naciskamy + na wyświetlaczu dostajemy 1,2,3,4,5 gdy minus 5,4,3,2,1. Oczywiście gdy np jesteśmy na stanie wyświetlacza 3 i naciskamy - to otrzymamy 2 i analogicznie gdy mamy 3 i naciśniemy + dostaniemy 4. Zakres to 1-5.
2 elektromagnesy załączające się w zależności który przycisk naciśniemy
czujnik biegu- sprzężenie zwrotne pozwalające sprawdzić czy po wyzwoleniu siłownika bieg wszedł czy też nie udało się go wbić. W wypadku gdy się nie powiodło stan wyświetlacza zostaje niezmieniony. Płytkę i schemat sprawdziłem 150 000 razy i tam błędów nie stwierdziłem. Wyświetlacz to wyświetlacz ze wspólną katodą- sterowany 1kami z procesora. Siłowniki wyzwalane są 0-1kowo za pomocą 2 mosfetów.
Przyciski podłaczone do JP2, JP5 obsługuje wyświetlacz, JP7 siłowniki natomiast JP3 odbiera sygnały z czujnika biegu- aktualny bieg daje stan wysoki na odpowiedni pin złącza, tam do działania wkraczają transoptory które złączają odpowiednie piny procesora do masy.
Teraz troszkę o programie:
program zawiera 3 podstawowe moduly
klawiatura (keyboard.c)
wyswietlacz (display.c)
elektromagnesy ( elektro.c)
czujnik biegu(gsens.c)
kazdy modul ma swoje zadanie i zdarzenia z niego lub informacje sa odbierane lub wysylane w aplikacji.
klawiatura :
funkcja init ktora zawsze raz na poczatku inicjuje rozne zeczy.
z kontekstu przerwania sprawdzany jest stan obydwu przyciskow
jezeli jest on stabilny przez 50ms to znaczy ze drgania stykow sie skonczyly i mozna powiedzec ze przycisk jest nacisniety. Przerwanie wtedy ustawia odpowieno dla tego przycisku flage signal. Potem przychodzi kontekst Main i widzi ze jeden z przyciskow ma flage do zgloszenia i zglasza funkcje callback ktora jest odbierana w glownej aplikacji. Po czym flaga jest zerowana.
display jest prosty i chyba nie trzeba wiele tlumaczyc.
elektromagnesy przyjmuja rozkazy z aplikacji.
jezeli dany elektromagnes zostanie pobudzony to wtedy jest on zalaczany i zostaje ustawiony licznik ktory jest co 1ms dekrementowany w przerwaniu.
Jezeli dekrementacja osiagnie zero ( po 500ms ) to wtedy zostaja wylaczone elektromagnesy.
czujnik biegu sprawdza czy po odpaleniu trigger'ze czyli naciśnięciu przycisku wszedł kolejny lub poprzedni bieg, jeżlei tak to wszystko gra jeżeli coś się nie zgadza- biegu nie udało się wrzucić to dekrementuje lub inkrementuje cyfrę na wyświetlaczu. Po co? By nie doszło do sytuacji, że wskazanie wyświetlacza rozjedzie się z aktualnym przełożeniem.
Na czym polega problem?
Po podłączeniu zasilania nic się nie grzeje napięcia są ok jednak na wyświetlaczu palą się segmenty a, b, g oraz dp. Gdy naciskam przyciski nie dzieje się nic, nie załączają się ani mosfety ani nie zmienia się nic na wyświetlaczu. Nie mam pojęcia gdzie może leżeć błąd.
Nie ukrywając, kod jest dość mocno skomplikowany a stworzony został w istnych męczarniach (do tej pory znałem język C lecz tylko od strony programowania komputerowego- pierwszy raz programuję procesory), dlatego też prosiłem o pomoc osoby z forum ponieważ sam nie jestem jeszcze na takim etapie zaawansowania by to obsłużyć.
Na pomysły w czym rzecz czekam gorąco, zwłaszcza interesuje mnie wypowiedź kolegi Mirka ponieważ między innymi jego książką i blogiem się pożytkowałem podczas tworzenia kodu 
Pozdrawiam, Krzysiek!
Kody:
display:
[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include "macros.h"
#include "display.h"
// user definitions
#define DISPLAY_PORTC
// program definitions
#define DISP_DDRDDR_MACRO(DISPLAY_PORT)
#define DISP_PORTPORT_MACRO(DISPLAY_PORT)
uint8_t test;
static uint8_t PROGMEM convTab[10]={0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0xEF }; //0-9 cyfry
void IDisp_Init(void)
{
DISP_PORT|=0xFF;
DISP_DDR|=0xFF;
}
void IDisp_Puts(uint8_t digit)
{
if(digit > 9 ) digit = 0;
PORTD = pgm_read_byte( convTab + digit );
}[/syntax]
[syntax=c]#ifndef _DISPLAY_H
#define _DISPLAY_H
void IDisp_Init(void);
void IDisp_Puts(uint8_t digit);
#endif[/syntax]
electro:
[syntax=c]#include <avr/io.h>
#include "macros.h"
#include "elektro.h"
// user definitions
#define ELEKTRO_PORTB
#define ELEK_1_LINE_BV(0)
#define ELEK_2_LINE_BV(1)
#define ELEK_PROBE_LINE_BV(2)
#define ELEKTRO_TIME500 // gives 500 ms
// program definitions
#define ELEK_DDRDDR_MACRO(ELEKTRO_PORT)
#define ELEK_PORTPORT_MACRO(ELEKTRO_PORT)
#define ELEKTRO_LINES( ELEK_1_LINE | ELEK_2_LINE | ELEK_PROBE_LINE )
#define ELEKTRO1_ON()ELEK_PORT |= ELEK_1_LINE | ELEK_PROBE_LINE
#define ELEKTRO2_ON()ELEK_PORT |= ELEK_2_LINE | ELEK_PROBE_LINE
#define ELEKTRO_ALL_OFF()ELEK_PORT&=~(ELEKTRO_LINES);
static volatile uint16_t xTime = 0;
void IElektro_Init(void)
{
ELEK_PORT &= ~ELEKTRO_LINES;
ELEK_DDR |= ELEKTRO_LINES;
}
void IElektro_Trigger(uint8_t which)
{
if(which) ELEKTRO1_ON();
else ELEKTRO2_ON();
xTime = ELEKTRO_TIME;
}
void IElektro_Tick(void)
{
if(xTime)
{
if(--xTime == 0)
{
ELEKTRO_ALL_OFF();
IElektro_TriggerFinishCallback();
}
}
}[/syntax]
[syntax=c]#ifndef _ELEKTRO_H_
#define _ELEKTRO_H_
void IElektro_Init(void);
void IElektro_Tick(void);
void IElektro_Trigger(uint8_t which);
extern void IElektro_TriggerFinishCallback(void);
#endif[/syntax]
gsens:
[syntax=c]#include <avr/io.h>
#include "gsens.h"
#include "macros.h"
// user definitions
#define IGEAR_PORTA
#define IGEAR_USAGE_MASK0x0F
#define IGEAR_COUNT5
#define GEAR_DDRDDR_MACRO(IGEAR_PORT)
#define GEAR_PORTPORT_MACRO(IGEAR_PORT)
#define GEAR_PINPIN_MACRO(IGEAR_PORT)
uint8_t IGsens_Init(void)
{
GEAR_DDR&=~IGEAR_USAGE_MASK;
GEAR_PORT|=IGEAR_USAGE_MASK;
for(uint8_t i=0; i<IGEAR_COUNT; i++)
{
if(GEAR_PIN & ( 1 << i ) ) continue;
return ++i;
}
return 0;
}
uint8_t IGsens_Get(uint8_t gear)
{
gear--;
return ( GEAR_PIN & ( 1 << gear ) ) ;
}[/syntax]
[syntax=c]#ifndef _GSENS_H_
#define _GSENS_H_
uint8_t IGsens_Init(void);
uint8_t IGsens_Get(uint8_t gear);
#endif[/syntax]
keyboard:
[syntax=c]#include <avr/io.h>
#include "macros.h"
#include "keyboard.h"
// user definitions
#define KEYBOARD_PORTD
#define KEY_UP_LINE_BV(2)
#define KEY_DOWN_LINE_BV(3)
#define KEY_JITTER50 // 50 * 1 ms = 50 ms
#define KEY_COUNT 2
// program definitions
#define KEY_DDRDDR_MACRO(KEYBOARD_PORT)
#define KEY_PORTPORT_MACRO(KEYBOARD_PORT)
#define KEY_PINPIN_MACRO(KEYBOARD_PORT)
static void key_configure(void)
{
KEY_PORT|=( KEY_UP_LINE | KEY_DOWN_LINE );
KEY_DDR &= ~( KEY_UP_LINE | KEY_DOWN_LINE );
}
typedef struct
{
uint8_t keyTime;
volatile uint8_t keySignal;
} KeyData_ts;
static KeyData_ts KeyData[KEY_COUNT];
static uint8_t keyTab[KEY_COUNT] = { KEY_UP_LINE , KEY_DOWN_LINE };
void IKey_Init( void )
{
key_configure();
for(uint8_t k=0; k<KEY_COUNT; k++)
{
KeyData[k].keyTime = 0;
KeyData[k].keySignal = 0;
}
}
void IKey_Main(void)
{
for(uint8_t k=0; k<KEY_COUNT; k++)
{
if(KeyData[k].keySignal == 0) continue;
IKey_EventCallback(k);
KeyData[k].keySignal = 0;
}
}
void IKey_Tick(void)
{
for( uint8_t k=0; k<KEY_COUNT; k++)
{
if( KEY_PIN & keyTab[k] )
{
KeyData[k].keyTime = 0;
return;
}
if( KeyData[k].keyTime < KEY_JITTER )
{
if(++KeyData[k].keyTime >= KEY_JITTER)
{
KeyData[k].keySignal = 1;
}
}
}
}[/syntax]
[syntax=c]#ifndef _KEYBOARD_H_
#define _KEYBOARD_H_
typedef enum
{
eKeyUp = 0,
eKeyDown = 1
} TEKey_t;
void IKey_Init(void);
void IKey_Main(void);
void IKey_Tick(void);
extern void IKey_EventCallback(TEKey_t aKey);
#endif[/syntax]
atmega 16
[syntax=c]#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include "system.h"
#define RELOAD_VAL 6
int main (void)
{
TCCR0=0x8B;
TCNT0 = RELOAD_VAL;
TIMSK=(1<<TOIE0);
wdt_enable(WDTO_1S);
sys_init();
sei();
while(1)
{
wdt_reset();
sys_main();
}
}
SIGNAL( SIG_OVERFLOW0 ) // 1 ms
{
TCNT0 = RELOAD_VAL;
sys_tick();
}[/syntax]
[syntax=c]#ifndef MAIN_H
#define MAIN_H
#include <avr/io.h>
#endif[/syntax]
macros
[syntax=c]#ifndef _MACROS_H_
#define _MACROS_H_
#define JOIN(a,b)a##b
#define DDR_MACRO(x)JOIN(DDR,x)
#define PORT_MACRO(x)JOIN(PORT,x)
#define PIN_MACRO(x)JOIN(PIN,x)
#endif[/syntax]
system
[syntax=c]#include "system.h"
#include "display.h"
#include "keyboard.h"
#include "elektro.h"
#include "gsens.h"
uint8_t myNumber;
int8_t failBit;
void IKey_EventCallback(TEKey_t aKey)
{
if(aKey == eKeyUp)
{
if(myNumber < 5 )
{
myNumber++;
IElektro_Trigger(1);
failBit = -1; // in case of fail need to decrement
}
}
if(aKey == eKeyDown)
{
if( myNumber > 1 )
{
myNumber--;
IElektro_Trigger(0);
failBit = 1; // in case of fail need to increment
}
}
IDisp_Puts(myNumber);
}
// from interrupt context
void IElektro_TriggerFinishCallback(void)
{
if( IGsens_Get(myNumber) ) // check if gear success // if not then rollback display
{
myNumber+= failBit;
IDisp_Puts(myNumber);
}
}
void sys_init(void)
{
IKey_Init();
IDisp_Init();
IElektro_Init();
myNumber = IGsens_Init(); // get current gear from sensor
IDisp_Puts(myNumber);// put current gear on display
}
void sys_main(void)
{
IKey_Main();
}
void sys_tick(void)
{
IKey_Tick();
}[/syntax]
[syntax=c]#ifndef SYSTEM_H
#define SYSTEM_H
#include <avr/io.h>
void sys_init(void);
void sys_tick(void);
void sys_main(void);
#endif[/syntax]Statystyki: Napisane przez lewytolewy — 3 mar 2014, o 00:56
]]>
