Skocz do zawartości

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


booyaka

Pomocna odpowiedź

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

Dołącz do dyskusji, napisz odpowiedź!

Jeśli masz już konto to zaloguj się teraz, aby opublikować wiadomość jako Ty. Możesz też napisać teraz i zarejestrować się później.
Uwaga: wgrywanie zdjęć i załączników dostępne jest po zalogowaniu!

Anonim
Dołącz do dyskusji! Kliknij i zacznij pisać...

×   Wklejony jako tekst z formatowaniem.   Przywróć formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Twój link będzie automatycznie osadzony.   Wyświetlać jako link

×   Twoja poprzednia zawartość została przywrócona.   Wyczyść edytor

×   Nie możesz wkleić zdjęć bezpośrednio. Prześlij lub wstaw obrazy z adresu URL.

×
×
  • 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.