Recommendation: The above method applies only to learn just under the serial programming NiosII friends, if you want your system to integrate two or more serial peripherals (including jtag_uart), then please use the second method.
every time I see this post I want to reply to him, but felt hard to describe, software development manual which is an example, but unfortunately not detailed enough, so even if the reply to a thread they have a lot of people , I feel like a sentence is always lots to talk about. Now in NiosII Step by Step inside for everyone to talk about this part of the UART. Note that this is just my personal experience of using the UART IP, IP-number may be on the low-level details are not involved, or there are some features I do not know or has not been used. So here is open to everyone how to use UART IP header, the specific application of broader and deeper have to rely on us to continue to share your experience. After all, this is just getting started documentation, however, is not very complicated for the application (such as participation in competitions) should be almost the same, huh, huh.
IOWR_ALTERA_AVALON_PIO_EDGE_CAP (LED_PIO_BASE, 0×00);
temp = c;
GPS (Global Positioning System), is highly intelligent embedded devices, today more and more important functions in one device, and a bright future. So can you hang a NiosII embedded GPS module on the system is still very good (although feeling a little modeling and old-fashioned, huh, huh), and many commercially available GPS modules use serial communication, so to achieve it is also relative to other interface (eg USB) simple. Here an overview of how to write NiosII communicate with the GPS module program:
# define LED_PIO_BASE 0xffffffff / / user definition here
# include
} often point in different forums a lot of the new school Nios / NiosII friends asked almost the same problem,
# include “alt_types.h”
# include “sys / alt_alarm.h” / / system clock service header files
# include / / include the appropriate header files
# error “No definition of LED_PIO core. \ n”
j = 0;
the “OK” to send the two characters to the standard output , this time, you can see from the GSM greeting! Oh …
# ifndef KEY_PIO_IRQ / / This is the interrupt number KEY_PIO nuclear
which is what we mentioned in this article part1 standard serial device operation method: first define a file pointer, then use it as handle (handle) to open the appropriate serial device can be friends. Here I define the GPS serial port UART IP under the name of the SOPCBuilder called gps_uart.
again, this time you run the project (Run As NiosII Hardware) you will find “Hello from NiosII!” does not show! Oh, note that the results just do not appear in the console under which NiosII IDE, but does not mean do not show. On the contrary, the results turn sent pc_uart this interface, rather than jtag_uart interface. This means that when you debug tools on a PC serial port can be seen only under the corresponding results (the prerequisite is to some of the serial port baud rate and other basic settings must match).
# error “No definition of KEY_PIO core. \ n”
charat [3] = { 0×0d};
done -;
temp = c
the CPU reset address is set to ext_flash, then the IDE Flash Programmer in Flash programming, the program will be added before the user guide copy program (Boot-Copier Program), when the program began to run, this section to guide the user copy the program will first copy the program to SDRAM, and then run in SDRAM.
}
Here, you should know that in fact the first method is the second method in which the implicit NiosII IDE integration, in fact, behind the graphical user interface is the second method, but also the procedures just stdin / stdout / stder nothing specified by you, huh, huh. (Estimated to be three options for Altera design is to facilitate the lazy and the beginner, huh, huh)
# error “No definition of KEY_PIO_IRQ. \ N”
IOWR_ALTERA_AVALON_PIO_IRQ (base, data) to write interrupt mask register. data is written to the interrupt mask register data
There no buffering of the data being sent or received in the UART, so if you can keep up, it will drop data … Could this possibly be what you e seeing?
enter “ATDxxxxxxxxxxx”, is to let the module call the appropriate phone number;
led = 0×00;
old_state = new_state; / / save the state of the LED
really could not be more familiar with the familiar. But this program is worth to say.
1) UART IP introduces the need for debugging tools for serial communication;
} # include
saw in the middle of the three “jtag_uart” it? Now the stdout \ stdin \ stderr are oriented jtag_uart, so when you run the project (Run As NiosII Hardware), you can see “Hello from NiosII!” Displayed on the console display NiosII IDE box below. Because there is jtag_uart interface user interface.
Here I use the GPS device is Motorola M12 modules, software configuration QuartusII5.0 NiosII5.0. Note, this GPS module can send the appropriate commands from the user to change some of the feature set, implementation method is through the serial port to send commands. But did not intend to say here how to send commands to this module, how to send data on the operation of this section we will in terms of GSM module inside (because of the need for two-way GSM debugging). On the GPS itself, in fact, it is only considered acceptable by the data sent over the serial port is enough to use.
This is a complete packet. GPS devices for different packet formats may be different, these differences we can refer you are using the GPS user manual. Here we have to resolve what in the end what is the meaning of these data is limited to the length of a line, I just bits of data analysis in the previous section, followed by data analysis method is the same:
IOWR_ALTERA_AVALON_PIO_DIRECTION (LED_PIO_BASE, LEDCON); < br /> real 1: GPS
3) Part I: Simulation and the IP found in the current issue
# ifndef KEY_PIO_BASE / / This is the base address of nuclear KEY_PIO
charreply [10 ]=”";< br /> temp1 = temp>> 4;
{
while (j <2)
● The VALUE field of the mutex register is zero.
fscanf (fp, “% c”,
However, this method has significant limitations. Obviously, System Libraries Properties option is given only under the stdout \ stdin \ stderr three options, and general stderr not much use, so in fact you can only use up to simultaneously communicate with two different serial peripheral modules . Remove debugging NiosII itself with the jtag_uart (to stdout set jtag_uart), you can only use one module, and the input and the module can only be a function. It is not enough, if we try to debug this highly interactive GSM module, you really can not, because you not only need to send commands to it, also need to receive feedback on the module (for example, you send “AT”, It should be fed back “OK”), but also need to jtag_uart console back under the observation of the output and feedback the results of ah. The stdin / stdout are GSM has been accounted for, jtag_uart non-existent, can not see the characters sent to and received (not even sent out), so this is definitely not work.
suggest that you use the serial port for debugging serial debugging gadgets, so there are many online tools, we can easily look for, it is not behind in this post I give you attach a very good use. Only on a PC this small tool is enough to test the module under test sending and receiving.
}
model opens a hello_world project, then open the System Libraries Properties option, you will see:
# include “system.h” / / contains the basic hardware description
printf (“\ nSuccessfully Opened!!! \ n”);
return 0;
parameter name is the name of the mutex device to open, the role is to obtain a pointer to the hardware mutex device structure of the pointer, that is, open the device, ready for you to use the means.
}
key_state = IORD_ALTERA_AVALON_PIO_DATA (KEY_PIO_BASE)
{
printf (fp, “% s”, msg);
■ The mutex register is always readable. A processor (or any
Well, see here, you should be receiving the GPS serial data programming have a general understanding of it, there are some details to their own practice in order to find talk and no action is does not work, huh, huh.
of course, not all peripheral operations are written in a program, it should be written separately, and finally divided into different functions, and then finally into a main function in this regard is the programming details problem, not much to say.
IOWR_ALTERA_AVALON_PIO_DATA (LED_PIO_BASE, old_state); / / initialize the LED Quanmie
}
second function: altera_avalon_mutex_lock ()
}
altera_avalon_mutex_lock (mutex, 1); / / This function uses a second
{
# if LED_PIO_BASE == 0xffffffff
IOWR_ALTERA_AVALON_PIO_DATA (LED_PIO_BASE, 0xff); / / off LED
# ifndef KEY_PIO_BASE / / This is the base address of nuclear KEY_PIO
2, and FLash for EPCS Programming
for (i = 0; i <2; i )
This is AT command in the program should exist inside the definition of the form. is completely in character, because the serial port transceiver equipment has always been a stream of characters Well, so others can do the same command definition. 0×0d is required, it is said that a sign of the end of the AT command, Do not forget that it is actually ASCII code inside the “CR” line.
altera_avalon_mutex_unlock () Unlocks the mutex.
fprintf (fp, “% x”, at [\ i]);
Advanced articles
charat [3] = { 0×0d};
how? With my previous knowledge about the bedding, basically be able to read it? Oh, but still did not fully understand the xdjm give their talk.
■ A processor attempts to acquire the mutex by writing its ID to the
last UART (part 1) have to tell you how Use this IP and two commonly used UART programming skills. this will give you part 2 in about two examples of practical applications, as well as in the past when using the IP problems found.
{
for (i = 0; i <3; i )
# if LED_PIO_BASE == 0xfffffffe
prototype: alt_mutex_dev * alt_hardware_mutex_open (const char * name)
{
# endif
(Rx) @ @ Ha 08 19 07D50F 03 000003E7B1 075977F2175F49B50000A249
for (i = 0; i <5; i )
}
# define KEY_PIO_BASE 0xffffffff / / user definition here
Enter the “AT”, will be fed back to normal if the module “OK”;
volatile alt_u32 done = 0; / / semaphores: to inform the external interrupt event
printf (“\ nPlease REPLY a char. .. \ n “);
}
int main (void)
# define KEY_PIO_BASE 0xffffffff / / user definition here
I met the similar problem when I use the UART in NiosII5 .0 QuartusII 5.0.But I tried an alternative approach via some code programmed by myself to tackle this problem and it seems that it works normal now. The way I program is to capture some fixed digit in my code. But the side effect is evident too, that is the time for processing are prolonged about 1 time.
alt_busy_sleep (5000); / / delay 5ms
while (1)
■ When the VALUE field is 0×0000, the mutex is available (ie,
# include “altera_avalon_pio_regs.h”
, my_alarm_callback, NULL) <0)
printf (“No system clock available \ n”);
● The OWNER field of the mutex register matches the OWNER
# endif
if (fp)
“What should NiosII how to write the next serial process? example let me have a look? quot; br />}
InitPIO ();
IOWR_ALTERA_AVALON_PIO_IRQ_MASK (KEY_PIO_BASE, 0×00);
determine its current state.
altera_avalon_mutex_unlock (mutex); / / This function uses a third .
# include “priv / alt_busy_sleep.h” # defineLEDCON0xff / /
# endif
exclusive role is to release the hardware device, and set the value stored in the mutex is 0
prototype: void altera_avalon_mutex_unlock (alt_mutex_dev * dev)
AT command set is very large, it is proposed that we all go to see the full command information. In fact, most commonly used command is not over 20, so it is still difficult to grasp.
}
IOWR_ALTERA_AVALON_PIO_DIRECTION (LED_PIO_BASE, LEDCON);
… …
# include “priv / alt_busy_sleep.h” # defineLEDCON0xff / / low light
# ifndef LED_PIO_BASE / / This is the base address of nuclear LED_PIO
int main (void)
Avalon-MM master peripheral) can read the mutex register to
printf (“alt_ticks_per_second () is% ld”, alt_ticks_per_second ());
if (0! = done)
Altera IP is not perfect, this IP there are some problems, problems sometimes feel strange, but it does happen, we had to accept or Wait for the update version of the IP appears.
altera_avalon_mutex.h declared alt_mutex_dev of structures and related functions. This gives a first opening and closing the mutex example, we come to learn through examples related functions.
IOWR_ALTERA_AVALON_PIO_DIRECTION (KEY_PIO_BASE, ~ KEYCON);
4) on the simulation and the IP found in the current issue (— ah??? psychologically prepared to accept Oh, Oh)
IORD_ALTERA_AVALON_PIO_IRQ (base) to read the contents of the interrupt mask register
temp = c
altera_avalon_mutex_trylock () Tries to lock the mutex. Returns immediately if it fails to lock
the method described above is that we generally used method, has great flexibility to change the program to add peripherals to overcome the limitations of the first method.
We had the same problem – I tried to use the UART together with DMA. At lower baudrates (up to about 115k2) it worked more or less. But we looked for baudrates up to 2Mbit / s. Finally we wrote our own UART with 512 Byte deep fifos – for rx and tx.
fourth man said: (This is me, because when I debug serial port encountered a similar problem)
while ((c = getc (fp)) == -1)
# if KEY_PIO_BASE == 0xffffffff
multi-core processor can use a mutex to coordinate access to shared resources. Mutex Core provides a protocol (test andset) is also to ensure the exclusive use shared resources.
}
access the mutex core.
int i = 0, j = 0;
altera_avalon_mutex_is_mine () Determines if this CPU owns the mutex.
So if the module really of conscience, to the serial port of a NiosII feedback, how should I look at it? Is this program:
return (0);
in the Nios II IDE projects selected for programming, and then select Tool → FlashProgrammer → NEW. The Main tab is the first project. Elf file to write flash. The second option, the FPGA configuration files can be written EPCS.
for (i = 0; i <2; i )
# define LED_PIO_BASE 0xfffffffe / / user definition here
void InitPIO (void)
number [\ i 1] = temp;
Oh, see here, you are not a little disappointed with Altera the IP?
first look at its header files , indicating that the two issues. First, NiosII programming is to support the ANSI C library; second, used here is the standard IO library, which in the printf statement shows the program is to output to standard output stream. So what is the standard output stream, where is it? See below:
Function NameDescription
third man said:
fifth person said:
the second of which need to include in their programming is written in.
# include “sys / alt_irq.h”
# if KEY_PIO_BASE == 0xffffffff
temp1 = temp>> 4;
InitPIO ();
{
The second man said: We are finding the same or a similar problem. We have 2 devices, we program one to just transmit. Every four seconds we send a blast of data 0-255. If we enable Rx and listen to ourself on that device, we hear all 256 characters nice and clean. We then plug into a second device and enable it to Rx. We loose about one byte in 16. We have tried blocking, non-blocking, read only, read write, disabling the transmitter. We have tried open (), fopen (), we have used getc () and read (), and more.
another extension point, if your system which you want to add four serial stream using the equipment, are the JTAG UART, PC UART, GSM UART, GPS UART, then for each peripheral, as long as the corresponding file write four procedures on the line:
if (fp)
while ((c = getc (fp)) == -1);
InitPIO ();
{
# error “No definition of LED_PIO core … \ n”
while (1) ; / / wait for the clock event
# include
return 0;
fclose (fp);
if (fp)
We know that in Unix / Linux and other operating systems can all be seen as streaming files, NiosII absorb this (probably because Cygwin Nios absorbed many of the features, huh, huh), the operation of the serial stream also as a file operations. Operation of a serial port, it only needs to read and write data in the appropriate device driver just fine.
void InitPIO (void)
{
printf (“hello world. \ n”);
alt_mutex_dev * mutex = altera_avalon_mutex_open (“/ dev / mutex”); / / here use the first function
# if LED_PIO_BASE == 0xfffffffe
Using this method, you can immediately learn by analogy, as long as the changes a little bit, you can operate all the serial peripherals. To change is / dev / jtag_uart, the / dev / peripheral later change the name to change it wants. For example, I want to operate NiosII communication between the PC, as long as changed to / dev / pc_uart to Come.
{
printf (“% c”, reply [\ i]);
# defineKEYCON0xff / / / / users to add and name of the peripheral base address is defined in the SYSTEM user needs Depending on the name to modify here
OWNER field, and writing a non-zero value to VALUE. The
third function: altera_avalon_mutex_unlock ()
This statement means that if the file open no problem, the pointer handle is valid, you can use the fprintf statement to write data to the serial port, here is a string of data to write. Finished after the close the file. You see, all operating under the C language is almost no difference between file operations, Oh, the only difference is that the file is to be operating the peripherals you want to operate, rather than a “document.”
■ After system reset, the RESET bit in the reset register is high.
void InitPIO (void)
# if KEY_PIO_IRQ == 0xffff
int main (void)
means that this device is my take, and the other CPU do not even think of.
by observing the raw data packets, I used a method is to wait (there are many ways you can go try, for example, you can find “@” will appear for every package of a character, but only in once in the beginning, how to do, huh, huh, go try it yourself). That have to do is wait for the appearance of valid data from the location of valid data bits can tell a pack of new data to begin. So before a for loop that reads a file from the port character, and wait for the beginning of the data synchronization character (Rx) @ @ Ha in the past.
So if we change the stdout \ stdin \ stderr position would happen then? See below:
IOWR_ALTERA_AVALON_PIO_DATA (LED_PIO_BASE, new_state);
IOWR_ALTERA_AVALON_PIO_DIRECTION (KEY_PIO_BASE, 0×00);
printf (“test alarm … \ n “);// print a message < br /> (Note: There will be four parts to introduce two part, this is part 1, on the first two parts)
2) parts: the software development process manual analysis and the two most simple example
fprintf (fp, “% x”, at [\ i]);
Well, this is part 1 of the contents of the first to write here, I will talk to later add part 2 of the content. I believe that here, you already NiosII serial programming under a certain understanding of it, refueling, Oh.
IOWR_ALTERA_AVALON_PIO_EDGE_CAP (KEY_PIO_BASE, 0×00);
for (i = 5; i ■ The mutex register is writable only under specific conditions. A
}
/ / users to add and name of the peripheral base address is defined in the SYSTEM, user need to modify depending on the naming here
continue;
return 0;
printf ( “% x”, at [\ i]);
fscanf (fp, “% c”,
if (led == 0xff) {
# include “alt_types.h “
static void KeyDown_interrupts (void * context, alt_u32 id)
these two statements:
printf (“% c “, reply [\ i]);
{
GSM (Global System for Mobile Communications), mobile phones and other mobile devices is a common communication standard, in many embedded systems may have a mobile communications applications. As the GSM network across the country to achieve the interconnection and roaming, with a strong network characteristics. At the same time, it does not limit the number of users, specifically to overcome the traditional communication system investment costs and a high maintenance costs, and network monitoring coverage and a limited number of users defects. Compared to traditional wireless network coverage in the cluster system that has unmatched advantages of SMS with GSM data transmission itself has features that have made these applications has been rapidly gaining popularity. The use of GSM short message system also has a two-way wireless communication data transmission function, stable performance for remote data transmission and monitoring equipment to provide communications support for a strong platform.
{
char * msg = “hello world”;
# endif
static alt_alarm alarm; / / call the API functions provided by the definition of variables
# defineLEDCON 0xff < br />}
return alt_ticks_per_second ();
fp = fopen (“/ dev / jtag_uart”, “r “);< br /> printf (” \ nPlease REPLY a char … \ n “);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP (KEY_PIO_BASE, 0×00);
Oh, this is the actual meaning of a packet of data, more data bits, such as latitude and longitude, speed, what I do not say, specifically in the the location of the packet we can check the user manual, quasi there.
received after the use
(Rx) @ @ Ha081907D50F023B00031765075977F1175F49B30000 A2490000000007597849175F4B270000A249000000000012001 20A440026080310000000000001082BC408A119000000000014 00000000000E0827C308A117000000000008000000000003082 34A08A01C00000000000700000000001A000000000009000000 0000C0000000FFDE00014828002DCD0008005030394F4A58
alt_irq_register (KEY_PIO_IRQ, NULL, KeyDown_interrupts);
key_state = IORD_ALTERA_AVALON_PIO_DATA (KEY_PIO_BASE) < br /> Well, the third part of the actual program on the serial port to write to you, we want to help write the program.
while (1)
3) parts: the real parts: personal use of the IP transfer over parts of two different modules and program analysis
following conditions is true:
and Mutex correlation is defined as follows:
printf (“\ nSuccessfully Opened!!! \ n”);
# define KEY_PIO_IRQ 0xffff / / user definition here
# endif
PIO interrupt mask register Access macro macro definition
how to define the meaning of a simple procedure but it is still more complicated than you think some of it? Oh, do not be afraid, after the above description, you have to NiosII character stream input and output under a certain understanding. In fact, this is a very important character stream redirects. There is also a character stream from the way I was soon directed in the following description. Here I would like to say a few words more this way. If you add in the SOPCBuilder which module to use the serial communication UART interface (for example, the most typical GPS device), you do not write programs can receive data directly from the device, the method is directed to stdin into gps_uart (just from the name) , stdout is set jtag_uart, you will find only the received data packet decomposition process for writing programs on the line, the process of receiving data NiosII IDE has automatically seal the deal, huh, huh.
as long as the serial communication devices are available through the PC serial debugger to debug, it is proposed that the initial debugging from the device itself and the PC serial port began. Of course, no serial debugger that comes with Windows HyperTerminal can also, just a personal feeling not very easy, huh, huh.
# error “No definition of LED_PIO core. \ n”
FILE * fp;
fp = fopen (“/ dev / gsm_uart”, “r “);< br /> write operation changes the mutex register only if one or both of the
# include “system.h”
IOWR_ALTERA_AVALON_PIO_DATA (LED_PIO_BASE, led_state);
fp = fopen (“/ dev / gps_uart”, “r “);
}
done ;
# include” altera_avalon_pio_regs.h “
}
{
claimed the mutex.
FILE * fp ;
old_state = 0xff;
{
Now I have to stdout \ stdin into a pc_uart. This is my own to add in SOPCBuilder inside a UART IP interface for connecting NiosII and PC, is mainly used for debugging communication between the PC can NiosII.
later denied the problem was the issue in the BUFFER
altera_avalon_mutex.c define access mutex core executable function
fp = fopen (“/ dev / gps_uart”, “r “);
led = 0xff;
role is sure to wait until the arrival of the actual data, no data will have to wait cycle. Then, obviously, the second for loop is used to receive real valid data. Cycle in some
# endif
combat 2: About GSM
# ifndef LED_PIO_BASE / / This is the base address of nuclear LED_PIO
first thing to note is: Altera provides The UART IP while achieving asynchronous RS-232 interface, sequential logic, but not directly connected or driven an RS-232 serial port. The reason is that most of Altera FPGA devices do not meet the RS-232 logic-level rules, if they are directly connected to be driven may damage the device. Therefore, RS-232 serial connection through a communication device, the Nios / NiosII and peripheral interfaces to increase the voltage conversion chip (such as Maxim Max232), so as to ensure the electrical on the first no problem. So everyone in the home-made circuit board, do not forget this. Serial communication is used on some of the other bits, such as parity, etc., where not going to be, generally in accordance with the default on it. In addition, one frame of data bits generally are 8 bits, 1 stop bit general will, by default go, do not change. There are a number of options are advanced applications, where not going to get to the bottom. The goal of this article as long as the church you how to use the serial port is enough, huh, huh.
first function: altera_avalon_mutex_open ()
role is to get the hardware mutex and set the corresponding parameters for the normal value is 1, of course, other non-zero value can be.
# include “system.h”
{
# define LED_PIO_BASE 0xfffffffe / / user definition here
example,
# ifndef LED_PIO_BASE / / This is LED_PIO nuclear base Address
in the Nios II IDE is often used in the following header files:
… …
above is a character output stream redirection process. Input flow control can also be analog here. If the re-stdin into jtag_uart, then you NiosII IDE console in the following inside the chip can run on hardware with the NiosII processor from sending and receiving from the user character (can be an ordinary character, it can be a command character) . Similarly, if stdin was used pc_uart, then the transmission from the operator can only serial port on a PC tool to complete.
IOWR_ALTERA_AVALON_PIO_IRQ_MASK (LED_PIO_BASE, 0×00);
altera_avalon_mutex.h define access mutex core data structures and functions with the Mutex
this map, and if value is 1, then the mutex can not (ie, locked), when the unlock (see the third function), then the value is reset to 0.
means that I run out, you can take to use up.
============================================== ==== ===========
{
int main ()
following the procedure for the analysis of this serial:
altera_avalon_mutex_lock () Locks the mutex. Will not return until it has successfully
OWNER field.
IOWR_ALTERA_AVALON_PIO_IRQ_MASK (KEY_PIO_BASE, KEYCON);
fp = fopen (“/ dev / gps_uart”, “r “); < br /> {
int main ()
}
while (1)
simulation, you can choose the software simulation or actual simulation, in accordance with generally SOPCBuilder This set the following can:
First, we need to know is, GPS data is based on a “package” (can also be seen as “Chen”) form to the receiving end of the serial port. The format of each packet of data is the same, which is our analysis of the data reported basis. We take a look at a packet of data is what:
The sixth said:
2011 年 07 月 13 日
FILE * fp;
volatile alt_u32 key_state, old_state, new_state;
to use the IDE Flash Programmer programming, we must first ensure that in SOPC Builder, in the Target Board options area of ??the drop-down list box, select the user current target board Flash programming design. The experimental board can be programmed EPCS and Nor Flash. Nor Flash components labeled U7, EPCS reference component labeled U10. If the Console window to see the IDE is the U7 program, that is, in the Nor Flash programming.
is used to control the number of raw data processing (because the original data is in the definition of Motorola hexadecimal number into decimal so it should be to the user).
} else {
2) application software development manual analysis and the two most simple example;
}
;
a person says: We use the UART in our Nios-II design that comes with Quartus 5.0SP1 and Nios-II 5.0.We face the problem that sometimes the Uart reports wrong RX Bytes from correct RX streams.The serial stream starts with a 0×02 byte but the UART delivers a 0×04 byte . Monitoring the serial signal outside the FPGA and inside the FPGA shortly before it enters the UART shows that the stream correctly contains the 0×02. So no electrical problem. a perfect signal.
IOWR_ALTERA_AVALON_PIO_DIRECTION (LED_PIO_BASE, LEDCON);
# error “No definition of KEY_PIO core. \ n”
{
# endif
{
}
{
# defineKEYCON0xff / / Press the
