void
arm_hardware_pioa_outputs(unsigned long opins, unsigned long initialstate)
{
#if CPUSTYLE_AT91SAM7S

AT91C_BASE_PMC->PMC_PCER = 1UL << AT91C_ID_PIOA; // разрешить тактированние этого блока

AT91C_BASE_PIOA->PIO_SODR = (opins & initialstate); // Установка единицы в регистре данных
AT91C_BASE_PIOA->PIO_CODR = (opins & ~ initialstate); // Установка нулей в регистре данных

AT91C_BASE_PIOA->PIO_OER = opins; // Разрешение выхода
AT91C_BASE_PIOA->PIO_PPUDR = opins; // disable pull-up resistors
AT91C_BASE_PIOA->PIO_MDDR = opins; // Disable open drain output

#elif CPUSTYLE_ATSAM3S || CPUSTYLE_ATSAM4S

PMC->PMC_PCER0 = (1UL << ID_PIOA);

PIOA->PIO_SODR = (opins & initialstate); // Установка единицы в регистре данных
PIOA->PIO_CODR = (opins & ~ initialstate); // Установка нулей в регистре данных

PIOA->PIO_OER = opins; // эти выводы на вывод - похоже, при работе с периферийными устройствами не требуется.
PIOA->PIO_PUDR = opins;
PIOA->PIO_MDDR = opins; // Disable open drain output

#elif CPUSTYLE_STM32F10X

RCC->APB2ENR |= RCC_APB2ENR_IOPAEN; /* I/O port A clock enable */
__DSB();
// Установка начального состояния битов
GPIOA->BSRR = (GPIO_BSRR_BS0 * (initialstate & opins)) | (GPIO_BSRR_BR0 * (~ initialstate & opins));
// Установка режима выводов
arm_stm32f10x_hardware_pio_prog(GPIOA, opins, 0, 1); /* Установить CNF=0 и MODE=1 для указанных битов */

#elif CPUSTYLE_STM32F4XX

RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; /* I/O port A clock enable */
__DSB();
// Установка начального состояния битов
arm_stm32f4xx_hardware_pio_setstate(GPIOA, opins, initialstate);
// Установка режима выводов
arm_stm32f30x_hardware_pio_prog(GPIOA, opins, 1, 1, 0, 0); /* mode, speed, pupdr, typer */

#elif CPUSTYLE_STM32F30X || CPUSTYLE_STM32F0XX

RCC->AHBENR |= RCC_AHBENR_GPIOAEN; /* I/O port A clock enable */
// Установка начального состояния битов
GPIOA->BSRR = (GPIO_BSRR_BS_0 * (initialstate & opins)) | (GPIO_BSRR_BR_0 * (~ initialstate & opins));
// Установка режима выводов
arm_stm32f30x_hardware_pio_prog(GPIOA, opins, 1, 1, 0, 0); /* mode, speed, pupdr, typer */

#else
#error Undefined CPUSTYLE_XXX
#endif
}

#define PIN_OUT   IOPORT_CREATE_PIN(PORTB, 0) // Смотря куда у вас там LED подключен или какую ногу хотите использовать

...
ioport_configure_pin(PIN_OUT, IOPORT_DIR_OUTPUT | IOPORT_INIT_LOW);
...

...
ioport_set_pin_level(PIN_OUT, 1) для вЫсокого уровня (0 - для низкого уровня)
...

...
ioport_toggle_pin_level(PIN_OUT)
...

#include <asf.h>
#include "conf_board.h"
#include "compiler.h"
#include "pio.h"

int main (void)
{    
    gpio_set_pin_high(PORTB);

}

#include "sam.h"
int din = 0;
int dout = 0;
int dacc_in = 0;
int din_1 = 0;
volatile int flag = 0;

int main(void)
{

SystemInit();
//--------------- Включение глобальных прерываний -----------------------------
__enable_irq ();

//--------------- Enable Interrupts in NVIC ----------------------------
NVIC_EnableIRQ(DACC_IRQn);
NVIC_EnableIRQ(ADC_IRQn);
//--------------- Приоритет прерывания ЦАП ниже чем у АЦП
NVIC_SetPriority (DACC_IRQn, 2);
//----------- далее настройка переферии------------------------
.
.
.
//----------------------------------------------------------------------
int main(void)
{
switch(flag)
{
case 0: // если прерывание от АЦП не произошло, моргать светодиодами
{
{PIOA -> PIO_CODR = PIO_CODR_P19 | PIO_CODR_P20;}
for (int i = 0; i < 1000000; i ++){}
{PIOA -> PIO_SODR = PIO_SODR_P19 | PIO_SODR_P20;}
for (int i = 0; i < 1000000; i ++){}
break;
}
case 1: // Если прерывание от АЦП было - гнать данные через ФВЧ
{
dacc_in = dout + din - din_1;
dout = dacc_in * 0.9 + 600;
din_1 = din;
break;
}
default : {break;}
}
return 0;
}

\\ Подпрограммы прерываний
\\------------ АЦП----------------
void ADC_Handler( void )
{
volatile int IRQ_sense = 0;
IRQ_sense = ADC -> ADC_ISR & (ADC_IER_EOCAL | ADC_IER_EOC5);

switch(IRQ_sense)
{
case ADC_IER_EOCAL : // автокалибровка АЦП
{
{PIOA -> PIO_CODR = PIO_CODR_P19 | PIO_CODR_P20;}
{PIOA -> PIO_SODR = PIO_SODR_P19 | PIO_SODR_P20;}
ADC -> ADC_IER = ADC_IER_EOC5;
ADC -> ADC_CR = ADC_CR_START;
return;
}

case ADC_IER_EOC5 :
{
flag = 1; // Говорим что было прерывание от АЦП
din = ADC -> ADC_CDR[5] & ADC_CDR_DATA_Msk; // Данные с АЦП
ADC -> ADC_CR = ADC_CR_START; // Вновь запускаем АЦП
return;
}

default : {return;}
}
}

//-------------------------- ЦАП --------------------------------
void DACC_Handler( void )
{
volatile int IRQ_sense = 0;
IRQ_sense = DACC -> DACC_ISR;// & (DACC_ISR_EOC);
DACC -> DACC_CDR = DACC_CDR_DATA(dout);
return;
}

#include "sam.h"

int din = 0;
int dout = 0;
int dacc_in = 0;
int din_1 = 0;
volatile int flag = 0;

int main(void)
{

SystemInit();
//--------------- Enable Global Interrupts -----------------------------
__enable_irq ();

//--------------- Enable Interrupts in NVIC ----------------------------
NVIC_EnableIRQ(DACC_IRQn);
NVIC_EnableIRQ(ADC_IRQn);

NVIC_SetPriority (DACC_IRQn, 2);

while (1)
{
switch(flag)
{
case 0:// если прерывание от АЦП не произошло, моргать светодиодами
{
{PIOA -> PIO_CODR = PIO_CODR_P19 | PIO_CODR_P20;}
for (int i = 0; i < 1000000; i ++){}
{PIOA -> PIO_SODR = PIO_SODR_P19 | PIO_SODR_P20;}
for (int i = 0; i < 1000000; i ++){}
break;
}
case 1: // Если прерывание от АЦП было - гнать данные через ФВЧ
{
dacc_in = dout + din - din_1;
dout = dacc_in * 0.9 + 600;
din_1 = din;
flag = 0;
break;
}
default : {break;}
}
}
return 0;
}

\\ Подпрограммы прерываний
\\------------ АЦП----------------
void ADC_Handler( void )
{
volatile int IRQ_sense = 0;
IRQ_sense = ADC -> ADC_ISR & (ADC_IER_EOCAL | ADC_IER_EOC5);

switch(IRQ_sense)
{
case ADC_IER_EOCAL : // автокалибровка АЦП
{
{PIOA -> PIO_CODR = PIO_CODR_P19 | PIO_CODR_P20;}
{PIOA -> PIO_SODR = PIO_SODR_P19 | PIO_SODR_P20;}
ADC -> ADC_IER = ADC_IER_EOC5;
ADC -> ADC_CR = ADC_CR_START;
return;
}

case ADC_IER_EOC5 :
{
flag = 1; // Говорим что было прерывание от АЦП
din = ADC -> ADC_CDR[5] & ADC_CDR_DATA_Msk;
ADC -> ADC_CR = ADC_CR_START;
return;
}

default : {return;}
}
}

//-------------------------- ЦАП --------------------------------
void DACC_Handler( void )
{
volatile int IRQ_sense = 0;
IRQ_sense = DACC -> DACC_ISR;
DACC -> DACC_CDR = DACC_CDR_DATA(dout);
return;

}

volatile int IRQ_sense = 0;
IRQ_sense = ADC -> ADC_ISR & (ADC_IER_EOCAL | ADC_IER_EOC5);

ADC -> ADC_CR = ADC_CR_START;

IRQ_sense = ADC -> ADC_ISR & (ADC_IER_EOCAL | ADC_IER_EOC5);
IRQ_sense = DACC -> DACC_ISR;

{PIOA -> PIO_CODR = PIO_CODR_P19 | PIO_CODR_P20;}
for (int i = 0; i < 1000000; i ++){}
{PIOA -> PIO_SODR = PIO_SODR_P19 | PIO_SODR_P20;}
for (int i = 0; i < 1000000; i ++){}

dout = din;

#include "sam.h"

int dout = 300;

void DACC_Handler( void );

int main(void)
{

/* Initialize the SAM system */
SystemInit();

__enable_irq ();

// --------------- Enable Interrupts in NVIC ----------------------------
NVIC_EnableIRQ(DACC_IRQn);

//------------------- Disable Watchdog Timer ---------------------------
WDT -> WDT_MR = WDT_MR_WDDIS; // disable Watchdog Timer
//----------------------------------------------------------------------

//----------------- Switch to fast RC oscillator ----------------------
// Enable Fast RC oscillator but DO NOT switch to RC now
PMC-> CKGR_MOR |= (CKGR_MOR_KEY_PASSWD | CKGR_MOR_MOSCRCEN);

// Wait the Fast RC to stabilize
while (!(PMC -> PMC_SR & PMC_SR_MOSCRCS)){};

// Change Fast RC oscillator frequency
PMC-> CKGR_MOR = (PMC-> CKGR_MOR & ~CKGR_MOR_MOSCRCF_Msk) | CKGR_MOR_KEY_PASSWD |
CKGR_MOR_MOSCRCF_4_MHz;

// Wait the Fast RC to stabilize
while (!(PMC-> PMC_SR & PMC_SR_MOSCRCS)){};

// Switch to Fast RC
PMC-> CKGR_MOR = (PMC -> CKGR_MOR & ~CKGR_MOR_MOSCSEL) | CKGR_MOR_KEY_PASSWD;
//---------------------------------------------------------------------------------------------------------------

//-------------------------- Switch to Main Clock ---------------------------------------------------------------
// Switch to Main Clock
PMC -> PMC_MCKR |= PMC_MCKR_CSS_MAIN_CLK;

// Wait the Fast RC to stabilize
while (!(PMC-> PMC_SR & PMC_SR_MOSCRCS)){};
//---------------------------------------------------------------------------------------------------------------

//-------------------------- PLLA enable ------------------------------------------------------------------------

// Number Wait States Required to Access the Embedded Flash Memory (page 366 and 1183 datasheet)
EFC0 -> EEFC_FMR = (EFC0 -> EEFC_FMR & ~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(6);

// Always stop PLL first!
PMC-> CKGR_PLLAR = CKGR_PLLAR_ONE | CKGR_PLLAR_MULA(0);

// Adjustment of the Multiplier and Divider
PMC-> CKGR_PLLAR = CKGR_PLLAR_ONE | CKGR_PLLAR_MULA(24) | CKGR_PLLAR_DIVA(1) |
CKGR_PLLAR_PLLACOUNT(100) | PMC_MCKR_PLLADIV2;

// Wait the PLL Lock
while (!(PMC-> PMC_SR & PMC_SR_LOCKA)){};

// Switch to PLLA Clock
PMC -> PMC_MCKR = (PMC -> PMC_MCKR & ~PMC_MCKR_CSS_Msk) | PMC_MCKR_CSS_PLLA_CLK;

// Wait Master Clock is Ready
while(!(PMC -> PMC_SR & PMC_SR_MCKRDY)){};

// --------- Enables the corresponding peripheral clock ----------------
// ------------------------ Enable PIOA --------------------------------
PMC -> PMC_PCER0 = (1 << ID_PIOA);

// ---------------------- Enable DACC clock ----------------------------
PMC -> PMC_PCER0 = (1 << ID_DACC);
PMC -> PMC_PCER0 = (1 << ID_ADC);

// --------- Enable corresponding pins ---------------------------------
PIOA -> PIO_PER = PIO_PER_P19 | PIO_PER_P20;

// ---- Enable output corresponding pins in PORTA-----------------------
PIOA -> PIO_OER = PIO_OER_P19|PIO_OER_P20;


// -- DAC SET
// --------------------- DACC Software Reset ---------------------------
DACC -> DACC_CR = DACC_CR_SWRST;

// ----------------------- DACC Mode Register --------------------------
DACC -> DACC_MR = DACC_MR_WORD_HALF | DACC_MR_USER_SEL_CHANNEL1;

// ----------------------- Channel 1 Enable ----------------------------
DACC -> DACC_CHER = DACC_CHER_CH1;

// ------------------- End of conversion interrupt ---------------------
DACC -> DACC_IER = DACC_IER_TXRDY;

// ---------------------- Start of conversion --------------------------
//DACC -> DACC_CDR = DACC_CDR_DATA(dout);

while (1)
{
if (dout == 3000)
{dout = 0;}
else
{dout = dout + 100;}
}
return 0;
}

void DACC_Handler( void )
{
volatile int IRQ_sense = 0;
IRQ_sense = DACC -> DACC_ISR;
DACC -> DACC_CDR = DACC_CDR_DATA(dout);
return;
}

while (1)
    {    
        if (n == 8)
        {n = 0;}
    }
    return 0;
}

void DACC_Handler( void )
{
    volatile int IRQ_sense = 0;
    IRQ_sense = DACC -> DACC_ISR;
    DACC -> DACC_CDR = DACC_CDR_DATA(dout[n]);
    n = n + 1;
    return;
}