Skocz do zawartości

[C] Problem z wywołaniem alarmów w NIOSII

booyaka

Przez booyaka,
w Układy programowalne

 Udostępnij

Pomocna odpowiedź

booyaka Aktywny debiutant

booyaka

Napisano
Napisano

Witam,

Ogólna treść zadania brzmi tak:

Zaprojektować sterownik pracy pralki automatycznej. 6 dostępnych funkcji (blokada drzwi, blokada przed zalaniem, blokada przed

przegrzaniem, blokada przycisków, poziom detergentu I, poziom detergentu II); wybieranie za pomocą Slider Switches (SW), po wybraniu odpowiedniej funkcji zostaje uruchomiona odpowiadająca numerowi slidera dioda zielona lub czerwona w przypadku błędu (braku blokady drzwi).

Mamy wprowadzić opóźnienia za pomocą alarmów, 3 sek dla wł., 2 sek dla wył. i 1 sek dla błędu.

Wcześniej mogliśmy używać opóźnień przy pomocy zegara i pętli while i nasz sprawny kod wyglądał tak:

/*
* "Hello World" example.
*
* This example prints 'Hello from Nios II' to the STDOUT stream. It runs on
* the Nios II 'standard', 'full_featured', 'fast', and 'low_cost' example
* designs. It runs with or without the MicroC/OS-II RTOS and requires a STDOUT
* device in your system's hardware.
* The memory footprint of this hosted application is ~69 kbytes by default
* using the standard reference design.
*
* For a reduced footprint version of this template, and an explanation of how
* to reduce the memory footprint for a given application, see the
* "small_hello_world" template.
*
*/

#include <stddef.h>
#include <stdio.h>
#include <system.h>
#include <stddef.h>

#include "altera_up_avalon_character_lcd.h"
#include "altera_up_avalon_parallel_port.h"
#include "sys/alt_irq.h"
#include "sys/alt_timestamp.h"

#define  SW0 0x00000001
#define  SW1 0x00000002
#define  SW2 0x00000004
#define  SW3 0x00000008
#define  SW4 0x00000010
#define  SW5 0x00000020
#define  SW6 0x00000040
#define  SW7 0x00000080
#define  SW8 0x00000100
#define  SW9 0x00000200
#define  SW10 0x00000400
#define  SW11 0x00000800
#define  SW12 0x00001000
#define  SW13 0x00002000
#define  SW14 0x00004000
#define  SW15 0x00008000
#define  SW16 0x00010000
#define  SW17 0x00020000

#define  KEY1 0x00000002
#define  KEY2 0x00000004
#define  KEY3 0x00000008

#define  LEDR0 0x00000001

#define  LEDG1 0x00000002
#define  LEDG2 0x00000004
#define  LEDG3 0x00000008
#define  LEDG4 0x00000010
#define  LEDG5 0x00000020
#define  LEDG6 0x00000040
#define  LEDG7 0x00000080

#define P 0x73
#define r 0x50
#define o 0x5c
#define E 0x79
#define hex1 0x6
#define hex2 0x5B
#define hex3 0x4F
#define hex4 0x64
#define hex5 0x6d
#define hex6 0x7d

#define CZAS_ON 3
#define CZAS_OFF 2
#define CZAS_ERR 1

typedef enum { false, true } bool;

struct alt_up_dev
{
alt_up_parallel_port_dev * uchwytSW;
alt_up_parallel_port_dev * uchwytLEDG;
alt_up_parallel_port_dev * uchwytLEDR;
alt_up_parallel_port_dev * uchwytHEX30;
alt_up_parallel_port_dev * uchwytHEX74;
alt_up_character_lcd_dev * uchwytLCD;
};

int bl_drzwi; //blokada drzwi
int bl_zal; //blokada przed zalaniem
int bl_przegrz; //blokada przed przegrzaniem
int bl_przyc; //blokada przyciskow
int det1; //poziom detergentu 1
int det2; //poziom detergentu 2

void LCD(struct alt_up_dev *up_dev) //funkcja wyswietlajaca na LCD informacje o aktywnych blokadach
{
alt_up_character_lcd_init(up_dev->uchwytLCD);
if(bl_drzwi)
{
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B1|");
}

if(bl_zal)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 3, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B2|");
}

if(bl_przegrz)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 6, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B3|");
}

if(bl_przyc)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 9, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B4|");
}

if(det1)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 12, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B5|");
}

if(det2)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 0, 1);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B6");
}
}

void SW1_01(struct alt_up_dev *up_dev) //zmiana stanu SW1 z 0 na 1
{
int czas;

bl_drzwi = 1; //aktywowane blokady drzwi
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG1); //zapalenie diody LEDG1
alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex1 << 24)); //wyswietlenie na HEX
}

void SW1_10(struct alt_up_dev *up_dev) //zmiana stanu SW1 z 1 na 0
{
int czas;

bl_drzwi = 0; //wylaczenie blokady drzwi
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG1); //zgaszenie LEDG1
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex1 << 24));
}

void SW2_01(struct alt_up_dev *up_dev) //zmiana stanu SW2 z 0 na 1
{
int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_zal = 1; //aktywowane blokady przed zalaniem
	LCD(up_dev);
	czas = alt_nticks(); //pobranie aktualnego czasu
	while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie
	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG2); //zapalenie diody LEDG2
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex2 << 16)); //wyswietlenie na HEX
}
}

void SW2_10(struct alt_up_dev *up_dev) //zmiana stanu SW2 z 1 na 0
{
int czas;

bl_zal = 0; //wylaczenie blokady przed zalaniem
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie
   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG2); //zgaszenie LEDG2
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex2 << 16));
}

void SW3_01(struct alt_up_dev *up_dev) //zmiana stanu SW3 z 0 na 1
{
int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_przegrz = 1; //aktywowane blokady przed przegrzaniem
	LCD(up_dev);
	czas = alt_nticks(); //pobranie aktualnego czasu
	while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie
	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG3); //zapalenie diody LEDG3
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex3 << 8)); //wyswietlenie na HEX
}
}

void SW3_10(struct alt_up_dev *up_dev) //zmiana stanu SW3 z 1 na 0
{
int czas;

bl_przegrz = 0; //wylaczenie blokady przed przegrzaniem
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie
   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG3); //zgaszenie LEDG3
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex3 << 8));
}

void SW4_01(struct alt_up_dev *up_dev) //zmiana stanu SW4 z 0 na 1
{
int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_przyc = 1; //aktywowane blokady przyciskow
	LCD(up_dev);
	czas = alt_nticks(); //pobranie aktualnego czasu
	while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie
	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG4); //zapalenie diody LEDG4
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex4)); //wyswietlenie na HEX
}
}

void SW4_10(struct alt_up_dev *up_dev) //zmiana stanu SW4 z 1 na 0
{
int czas;

bl_przyc = 0; //wylaczenie blokady przed zalaniem
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie
   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG4); //zgaszenie LEDG4
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex4));
}

void SW5_01(struct alt_up_dev *up_dev) //zmiana stanu SW5 z 0 na 1
{
int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	det1 = 1; //poziom detergentu 1
	LCD(up_dev);
	czas = alt_nticks(); //pobranie aktualnego czasu
	while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie
	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG5); //zapalenie diody LEDG5
	alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan | (hex5 << 24)); //wyswietlenie na HEX
}
}

void SW5_10(struct alt_up_dev *up_dev) //zmiana stanu SW5 z 1 na 0
{
int czas;

det1 = 0; //poziom detergentu 1
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie
   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG5); //zgaszenie LEDG5
   alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan^(hex5 << 24));
}

void SW6_01(struct alt_up_dev *up_dev) //zmiana stanu SW6 z 0 na 1
{
int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	det2 = 1; //poziom detergentu 2
	LCD(up_dev);
	czas = alt_nticks(); //pobranie aktualnego czasu
	while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie
	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG6); //zapalenie diody LEDG6
	alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan | (hex6 << 16)); //wyswietlenie na HEX
}
}

void SW6_10(struct alt_up_dev *up_dev) //zmiana stanu SW6 z 1 na 0
{
int czas;

det2 = 0; //poziom detergentu 2
LCD(up_dev);
czas = alt_nticks(); //pobranie aktualnego czasu
while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie
   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG6); //zgaszenie LEDG6
   alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan^(hex6 << 16));
}

int main()
{
 //printf("Hello from Nios II!\n");
 struct alt_up_dev up_dev;
 alt_up_parallel_port_dev *uchwytSW = alt_up_parallel_port_open_dev("/dev/parallel_port_0");
 alt_up_parallel_port_dev *uchwytLEDG = alt_up_parallel_port_open_dev("/dev/parallel_port_1");
 alt_up_parallel_port_dev *uchwytLEDR = alt_up_parallel_port_open_dev("/dev/parallel_port_2");
 alt_up_parallel_port_dev *uchwytHEX30 = alt_up_parallel_port_open_dev("/dev/parallel_port_3");
 alt_up_parallel_port_dev *uchwytHEX74 = alt_up_parallel_port_open_dev("/dev/parallel_port_4");
 alt_up_character_lcd_dev *uchwytLCD = alt_up_character_lcd_open_dev("/dev/character_lcd_0");


 if (uchwytSW != NULL)
 up_dev.uchwytSW = uchwytSW;
 if (uchwytLEDG != NULL)
 up_dev.uchwytLEDG = uchwytLEDG;
 if (uchwytLEDR != NULL)
 up_dev.uchwytLEDR = uchwytLEDR;
 if (uchwytHEX30 != NULL)
 up_dev.uchwytHEX30 = uchwytHEX30;
 if (uchwytHEX74 != NULL)
 up_dev.uchwytHEX74 = uchwytHEX74;
 if (uchwytLCD != NULL)
 up_dev.uchwytLCD = uchwytLCD;

 int stan_sw;

 while(1)
 {
  int stan_error;
  stan_sw = alt_up_parallel_port_read_data(up_dev.uchwytSW); // odczyt stanu SW

  if( (stan_sw & SW1) && bl_drzwi == 0) SW1_01(&up_dev);
  if( !(stan_sw & SW1) && bl_drzwi == 1) SW1_10(&up_dev);

  if( (stan_sw & SW2) && bl_zal == 0) SW2_01(&up_dev);
  if( !(stan_sw & SW2) && bl_zal == 1) SW2_10(&up_dev);

  if( (stan_sw & SW3) && bl_przegrz == 0) SW3_01(&up_dev);
  if( !(stan_sw & SW3) && bl_przegrz == 1) SW3_10(&up_dev);

  if( (stan_sw & SW4) && bl_przyc == 0) SW4_01(&up_dev);
  if( !(stan_sw & SW4) && bl_przyc == 1) SW4_10(&up_dev);

  if( (stan_sw & SW5) && det1 == 0) SW5_01(&up_dev);
  if( !(stan_sw & SW5) && det1 == 1) SW5_10(&up_dev);

  if( (stan_sw & SW6) && det2 == 0) SW6_01(&up_dev);
  if( !(stan_sw & SW6) && det2 == 1) SW6_10(&up_dev);

  if(!bl_drzwi || !bl_zal || !bl_przegrz || !bl_przyc || (!det1 && !det2)) //wystapienie bledu
  {
	  int czas;
	  czas = alt_nticks(); //pobranie aktualnego czasu
	  while( (alt_nticks() - czas) < CZAS_ERR * alt_ticks_per_second() ){} //oczekiwanie
	  alt_up_parallel_port_write_data(up_dev.uchwytLEDR, LEDR0); //zapalenie diody LEDR0
	  int HEX30_stan = alt_up_parallel_port_read_data(up_dev.uchwytHEX30);
	  alt_up_parallel_port_write_data(up_dev.uchwytHEX30, HEX30_stan | ( (E << 8) | r ) ); //wyswietlenie na HEX
	  if(!bl_drzwi) alt_up_parallel_port_write_data(up_dev.uchwytLEDG, 0x00); //zgaszenie wszystkich LEDG
	  stan_error = 1;
  } else
  {
	  alt_up_parallel_port_write_data(up_dev.uchwytLEDR, 0x00); //zgaszenie LEDR
	  int HEX30_stan = alt_up_parallel_port_read_data(up_dev.uchwytHEX30);
	  if(stan_error)
	  {
		  alt_up_parallel_port_write_data(up_dev.uchwytHEX30, HEX30_stan^( (E << 8) | r ));
		  stan_error = 0;
	  }
  }
 }

 return 0;
}

Staramy się go przerobić na alarmy tak:

/*
* "Hello World" example.
*
* This example prints 'Hello from Nios II' to the STDOUT stream. It runs on
* the Nios II 'standard', 'full_featured', 'fast', and 'low_cost' example
* designs. It runs with or without the MicroC/OS-II RTOS and requires a STDOUT
* device in your system's hardware.
* The memory footprint of this hosted application is ~69 kbytes by default
* using the standard reference design.
*
* For a reduced footprint version of this template, and an explanation of how
* to reduce the memory footprint for a given application, see the
* "small_hello_world" template.
*
*/

#include <io.h>
#include <stdio.h>
#include <system.h>
#include "altera_up_avalon_parallel_port.h"
#include "altera_up_avalon_character_lcd.h"
#include <sys/alt_irq.h>
#include "sys/alt_alarm.h"
#include "alt_types.h"

#define  SW0 0x00000001
#define  SW1 0x00000002
#define  SW2 0x00000004
#define  SW3 0x00000008
#define  SW4 0x00000010
#define  SW5 0x00000020
#define  SW6 0x00000040
#define  SW7 0x00000080
#define  SW8 0x00000100
#define  SW9 0x00000200
#define  SW10 0x00000400
#define  SW11 0x00000800
#define  SW12 0x00001000
#define  SW13 0x00002000
#define  SW14 0x00004000
#define  SW15 0x00008000
#define  SW16 0x00010000
#define  SW17 0x00020000

#define  KEY1 0x00000002
#define  KEY2 0x00000004
#define  KEY3 0x00000008

#define  LEDR0 0x00000001

#define  LEDG1 0x00000002
#define  LEDG2 0x00000004
#define  LEDG3 0x00000008
#define  LEDG4 0x00000010
#define  LEDG5 0x00000020
#define  LEDG6 0x00000040
#define  LEDG7 0x00000080

#define P 0x73
#define r 0x50
#define o 0x5c
#define E 0x79
#define hex1 0x6
#define hex2 0x5B
#define hex3 0x4F
#define hex4 0x64
#define hex5 0x6d
#define hex6 0x7d

#define CZAS_ON 3
#define CZAS_OFF 2
#define CZAS_ERR 1

typedef enum { false, true } bool;

struct alt_up_dev
{
alt_up_parallel_port_dev * uchwytSW;
alt_up_parallel_port_dev * uchwytLEDG;
alt_up_parallel_port_dev * uchwytLEDR;
alt_up_parallel_port_dev * uchwytHEX30;
alt_up_parallel_port_dev * uchwytHEX74;
alt_up_character_lcd_dev * uchwytLCD;
};

int bl_drzwi; //blokada drzwi
int bl_zal; //blokada przed zalaniem
int bl_przegrz; //blokada przed przegrzaniem
int bl_przyc; //blokada przyciskow
int det1; //poziom detergentu 1
int det2; //poziom detergentu 2

// zmienne alarmow
static alt_alarm SW1_01;
static alt_alarm SW1_10;
static alt_alarm SW2_01;
static alt_alarm SW2_10;
static alt_alarm SW3_01;
static alt_alarm SW3_10;
static alt_alarm SW4_01;
static alt_alarm SW4_10;
static alt_alarm SW5_01;
static alt_alarm SW5_10;
static alt_alarm SW6_01;
static alt_alarm SW6_10;

//Funkcje Alarmów
alt_u32 my_alarm_SW1_01 (void* context)
{
   SW1_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW1_10 (void* context)
{
   SW1_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW2_01 (void* context)
{
   SW2_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW2_10 (void* context)
{
   SW2_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW3_01 (void* context)
{
   SW3_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW3_10 (void* context)
{
   SW3_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW4_01 (void* context)
{
   SW4_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW4_10 (void* context)
{
   SW4_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW5_01 (void* context)
{
   SW5_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW5_10 (void* context)
{
   SW5_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW6_01 (void* context)
{
   SW6_01(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}
alt_u32 my_alarm_SW6_10 (void* context)
{
   SW6_10(&up_dev);
return 0; // alarm wy³aczy sie z automatu po jednym wywo³aniu
}


void LCD(struct alt_up_dev *up_dev) //funkcja wyswietlajaca na LCD informacje o aktywnych blokadach
{
alt_up_character_lcd_init(up_dev->uchwytLCD);
if(bl_drzwi)
{
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B1|");
}

if(bl_zal)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 3, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B2|");
}

if(bl_przegrz)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 6, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B3|");
}

if(bl_przyc)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 9, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B4|");
}

if(det1)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 12, 0);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B5|");
}

if(det2)
{
	alt_up_character_lcd_set_cursor_pos(up_dev->uchwytLCD, 0, 1);
	alt_up_character_lcd_string(up_dev->uchwytLCD, "B6");
}
}

void SW1_01(struct alt_up_dev *up_dev) //zmiana stanu SW1 z 0 na 1
{
//int czas;

bl_drzwi = 1; //aktywowane blokady drzwi
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG1); //zapalenie diody LEDG1
alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex1 << 24)); //wyswietlenie na HEX
}

void SW1_10(struct alt_up_dev *up_dev) //zmiana stanu SW1 z 1 na 0
{
//int czas;

bl_drzwi = 0; //wylaczenie blokady drzwi
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG1); //zgaszenie LEDG1
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex1 << 24));
}

void SW2_01(struct alt_up_dev *up_dev) //zmiana stanu SW2 z 0 na 1
{
//int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_zal = 1; //aktywowane blokady przed zalaniem
	LCD(up_dev);

	//czas = alt_nticks(); //pobranie aktualnego czasu
	//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG2); //zapalenie diody LEDG2
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex2 << 16)); //wyswietlenie na HEX
}
}

void SW2_10(struct alt_up_dev *up_dev) //zmiana stanu SW2 z 1 na 0
{
//int czas;

bl_zal = 0; //wylaczenie blokady przed zalaniem
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG2); //zgaszenie LEDG2
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex2 << 16));
}

void SW3_01(struct alt_up_dev *up_dev) //zmiana stanu SW3 z 0 na 1
{
//int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_przegrz = 1; //aktywowane blokady przed przegrzaniem
	LCD(up_dev);

	//czas = alt_nticks(); //pobranie aktualnego czasu
	//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG3); //zapalenie diody LEDG3
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex3 << 8)); //wyswietlenie na HEX
}
}

void SW3_10(struct alt_up_dev *up_dev) //zmiana stanu SW3 z 1 na 0
{
//int czas;

bl_przegrz = 0; //wylaczenie blokady przed przegrzaniem
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG3); //zgaszenie LEDG3
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex3 << 8));
}

void SW4_01(struct alt_up_dev *up_dev) //zmiana stanu SW4 z 0 na 1
{
//int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	bl_przyc = 1; //aktywowane blokady przyciskow
	LCD(up_dev);

	//czas = alt_nticks(); //pobranie aktualnego czasu
	//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG4); //zapalenie diody LEDG4
	alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan | (hex4)); //wyswietlenie na HEX
}
}

void SW4_10(struct alt_up_dev *up_dev) //zmiana stanu SW4 z 1 na 0
{
//int czas;

bl_przyc = 0; //wylaczenie blokady przed zalaniem
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX74_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX74);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG4); //zgaszenie LEDG4
   alt_up_parallel_port_write_data(up_dev->uchwytHEX74, HEX74_stan^(hex4));
}

void SW5_01(struct alt_up_dev *up_dev) //zmiana stanu SW5 z 0 na 1
{
//int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	det1 = 1; //poziom detergentu 1
	LCD(up_dev);

	//czas = alt_nticks(); //pobranie aktualnego czasu
	//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG5); //zapalenie diody LEDG5
	alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan | (hex5 << 24)); //wyswietlenie na HEX
}
}

void SW5_10(struct alt_up_dev *up_dev) //zmiana stanu SW5 z 1 na 0
{
//int czas;

det1 = 0; //poziom detergentu 1
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG5); //zgaszenie LEDG5
   alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan^(hex5 << 24));
}

void SW6_01(struct alt_up_dev *up_dev) //zmiana stanu SW6 z 0 na 1
{
//int czas;

if(bl_drzwi) //jezeli blokada drzwi jest wlaczona
{
	det2 = 1; //poziom detergentu 2
	LCD(up_dev);

	//czas = alt_nticks(); //pobranie aktualnego czasu
	//while( (alt_nticks() - czas) < CZAS_ON * alt_ticks_per_second() ){} //oczekiwanie

	int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
	int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
	alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan | LEDG6); //zapalenie diody LEDG6
	alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan | (hex6 << 16)); //wyswietlenie na HEX
}
}

void SW6_10(struct alt_up_dev *up_dev) //zmiana stanu SW6 z 1 na 0
{
//int czas;

det2 = 0; //poziom detergentu 2
LCD(up_dev);

//czas = alt_nticks(); //pobranie aktualnego czasu
//while( (alt_nticks() - czas) < CZAS_OFF * alt_ticks_per_second() ){} //oczekiwanie

   int LEDG_stan = alt_up_parallel_port_read_data(up_dev->uchwytLEDG);
   int HEX30_stan = alt_up_parallel_port_read_data(up_dev->uchwytHEX30);
   alt_up_parallel_port_write_data(up_dev->uchwytLEDG, LEDG_stan^LEDG6); //zgaszenie LEDG6
   alt_up_parallel_port_write_data(up_dev->uchwytHEX30, HEX30_stan^(hex6 << 16));
}

int main()
{
 //printf("Hello from Nios II!\n");
 struct alt_up_dev up_dev;
 alt_up_parallel_port_dev *uchwytSW = alt_up_parallel_port_open_dev("/dev/parallel_port_0");
 alt_up_parallel_port_dev *uchwytLEDG = alt_up_parallel_port_open_dev("/dev/parallel_port_1");
 alt_up_parallel_port_dev *uchwytLEDR = alt_up_parallel_port_open_dev("/dev/parallel_port_2");
 alt_up_parallel_port_dev *uchwytHEX30 = alt_up_parallel_port_open_dev("/dev/parallel_port_3");
 alt_up_parallel_port_dev *uchwytHEX74 = alt_up_parallel_port_open_dev("/dev/parallel_port_4");
 alt_up_character_lcd_dev *uchwytLCD = alt_up_character_lcd_open_dev("/dev/character_lcd_0");


 if (uchwytSW != NULL)
 up_dev.uchwytSW = uchwytSW;
 if (uchwytLEDG != NULL)
 up_dev.uchwytLEDG = uchwytLEDG;
 if (uchwytLEDR != NULL)
 up_dev.uchwytLEDR = uchwytLEDR;
 if (uchwytHEX30 != NULL)
 up_dev.uchwytHEX30 = uchwytHEX30;
 if (uchwytHEX74 != NULL)
 up_dev.uchwytHEX74 = uchwytHEX74;
 if (uchwytLCD != NULL)
 up_dev.uchwytLCD = uchwytLCD;

 int stan_sw;

 while(1)
 {
  int stan_error;
  stan_sw = alt_up_parallel_port_read_data(up_dev.uchwytSW); // odczyt stanu SW

  if( (stan_sw & SW1) && bl_drzwi == 0)
       if (alt_alarm_start (&SW1_01, 2*alt_ticks_per_second(), my_alarm_SW1_01, NULL) < 0) // Alarm wlaczy sie po 2 sekundach i wywola funkcje zapalajaca
           {                                                                               // diode, poczym wylaczy alarm bo funkcja zwraca wartosc 0
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW1) && bl_drzwi == 1)
       if (alt_alarm_start (&SW1_10, 3*alt_ticks_per_second(), my_alarm_SW1_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( (stan_sw & SW2) && bl_zal == 0)
       if (alt_alarm_start (&SW2_01, 2*alt_ticks_per_second(), my_alarm_SW2_01, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW2) && bl_zal == 1)
       if (alt_alarm_start (&SW2_10, 3*alt_ticks_per_second(), my_alarm_SW2_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( (stan_sw & SW3) && bl_przegrz == 0)
       if (alt_alarm_start (&SW3_01, 2*alt_ticks_per_second(), my_alarm_SW3_01, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW3) && bl_przegrz == 1)
       if (alt_alarm_start (&SW3_10, 3*alt_ticks_per_second(), my_alarm_SW3_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( (stan_sw & SW4) && bl_przyc == 0)
       if (alt_alarm_start (&SW4_01, 2*alt_ticks_per_second(), my_alarm_SW4_01, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW4) && bl_przyc == 1)
       if (alt_alarm_start (&SW4_10, 3*alt_ticks_per_second(), my_alarm_SW4_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( (stan_sw & SW5) && det1 == 0)
       if (alt_alarm_start (&SW5_01, 2*alt_ticks_per_second(), my_alarm_SW5_01, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW5) && det1 == 1)
       if (alt_alarm_start (&SW5_10, 3*alt_ticks_per_second(), my_alarm_SW5_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( (stan_sw & SW6) && det2 == 0)
       if (alt_alarm_start (&SW6_01, 2*alt_ticks_per_second(), my_alarm_SW6_01, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if( !(stan_sw & SW6) && det2 == 1)
       if (alt_alarm_start (&SW6_10, 3*alt_ticks_per_second(), my_alarm_SW6_10, NULL) < 0)
           {
               printf ("No system clock available\n");
           }

  if(!bl_drzwi || !bl_zal || !bl_przegrz || !bl_przyc || (!det1 && !det2)) //wystapienie bledu
  {
	  //int czas;
	  //czas = alt_nticks(); //pobranie aktualnego czasu
	  //while( (alt_nticks() - czas) < CZAS_ERR * alt_ticks_per_second() ){} //oczekiwanie

	  alt_up_parallel_port_write_data(up_dev.uchwytLEDR, LEDR0); //zapalenie diody LEDR0
	  int HEX30_stan = alt_up_parallel_port_read_data(up_dev.uchwytHEX30);
	  alt_up_parallel_port_write_data(up_dev.uchwytHEX30, HEX30_stan | ( (E << 8) | r ) ); //wyswietlenie na HEX
	  if(!bl_drzwi) alt_up_parallel_port_write_data(up_dev.uchwytLEDG, 0x00); //zgaszenie wszystkich LEDG
	  stan_error = 1;
  } else
  {
	  alt_up_parallel_port_write_data(up_dev.uchwytLEDR, 0x00); //zgaszenie LEDR
	  int HEX30_stan = alt_up_parallel_port_read_data(up_dev.uchwytHEX30);
	  if(stan_error)
	  {
		  alt_up_parallel_port_write_data(up_dev.uchwytHEX30, HEX30_stan^( (E << 8) | r ));
		  stan_error = 0;
	  }
  }
 }

 return 0;
}

Problem polega na tym, że program nie działa w czasie rzeczywistym tj. nie sprawdza cyklicznie zmieniających się warunków w nieskończonej pętli while. Jeżeli wyrzucimy pętle while i uruchomimy program wcześniej włączając któryś ze Switchy to program reaguje tak jak powinien.

Proszę o wyrozumiałość bo jestem początkujący i pomoc w poprawieniu kodu, jakieś wskazówki jak to wykonać. Problemem jest to, że program jest na uczelnie i nie mam na co dzień dostępu do płytki, żeby metodą prób i błędów dojść do rozwiązania. 🙁

Z góry dzień za pomoc,

Link do komentarza
Share on other sites
Treker Numer 1

Treker (Damian Szymański)

(Kody wklejam na inny serwer bo jest dosyć długi i utrudnił odczyt posta!)

To chyba kłamstewko 🙂

Proszę wkleić kod do wiadomości i zamieścić go w tagach CODE, wtedy całość spokojnie się zmieści.

Link do komentarza
Share on other sites

Bądź aktywny - zaloguj się lub utwórz konto!

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto w ~20 sekund!

Zarejestruj nowe konto, to proste!

Zarejestruj się »

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się »
 Udostępnij
Przejdź do listy tematów
×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.

  Rozumiem