void motor_setdir(unsigned char axis, unsigned char dir){
switch(axis){
case(0):
if(dir)
PIO_Set(&XDIR);
else
PIO_Clear(&XDIR);
break;
case(1):
if(dir)
PIO_Set(&YDIR);
else
PIO_Clear(&YDIR);
break;
case(2):
if(dir)
PIO_Set(&ZDIR);
else
PIO_Clear(&ZDIR);
break;
case(3):
if(dir)
PIO_Set(&E0DIR);
else
PIO_Clear(&E0DIR);
break;
case(4):
if(dir)
PIO_Set(&E1DIR);
else
PIO_Clear(&E1DIR);
break;
}
}
void motor_enaxis(unsigned char axis, unsigned char en){
switch(axis){
case(0):
if(!en)
PIO_Set(&XEN);
else
PIO_Clear(&XEN);
break;
case(1):
if(!en)
PIO_Set(&YEN);
else
PIO_Clear(&YEN);
break;
case(2):
if(!en)
PIO_Set(&ZEN);
else
PIO_Clear(&ZEN);
break;
case(3):
if(!en)
PIO_Set(&E0EN);
else
PIO_Clear(&E0EN);
break;
case(4):
if(!en)
PIO_Set(&E1EN);
else
PIO_Clear(&E1EN);
break;
}
}
void vParTestSetLED( unsigned portBASE_TYPE uxLED, signed portBASE_TYPE xValue )
{
if( uxLED < partestNUM_LEDS ) {
if( xValue ) {
/* Turn the LED on. */
portENTER_CRITICAL();
{
if( xLEDPins[ uxLED ].type == PIO_OUTPUT_0 ) {
PIO_Set( &( xLEDPins[ uxLED ]) );
} else {
PIO_Clear( &( xLEDPins[ uxLED ] ) );
}
}
portEXIT_CRITICAL();
} else {
/* Turn the LED off. */
portENTER_CRITICAL();
{
if( xLEDPins[ uxLED ].type == PIO_OUTPUT_0 ) {
PIO_Clear( &( xLEDPins[ uxLED ] ) );
} else {
PIO_Set( &( xLEDPins[ uxLED ] ) );
}
}
portEXIT_CRITICAL();
}
}
}
inline void motor_unstep(){
PIO_Clear(&XSTEP);
PIO_Clear(&YSTEP);
PIO_Clear(&ZSTEP);
PIO_Clear(&E0STEP);
PIO_Clear(&E1STEP);
}
__attribute__((always_inline)) void motor_unstep(){
PIO_Clear(&XSTEP);
PIO_Clear(&YSTEP);
PIO_Clear(&ZSTEP);
PIO_Clear(&E0STEP);
PIO_Clear(&E1STEP);
}
//------------------------------------------------------------------------------
/// Set the backlight of the LCD.
/// \param level Backlight brightness level [1..32], 32 is maximum level.
//------------------------------------------------------------------------------
void LCDD_SetBacklight (unsigned int level)
{
unsigned int i;
const Pin pPins[] = {BOARD_BACKLIGHT_PIN};
// Enable pins
PIO_Configure(pPins, PIO_LISTSIZE(pPins));
// Switch off backlight
PIO_Clear(pPins);
i = 600 * (BOARD_MCK / 1000000); // wait for at least 500us
while(i--);
// Set new backlight level
for (i = 0; i < level; i++) {
PIO_Clear(pPins);
PIO_Clear(pPins);
PIO_Clear(pPins);
PIO_Set(pPins);
PIO_Set(pPins);
PIO_Set(pPins);
// PIO_Clear(pPins);
// PIO_Clear(pPins);
// PIO_Clear(pPins);
}
// PIO_Set(pPins);
}
// Initialise radio (in rx mode)
void nrf24l01plus_init(void)
{
int i;
Init_SPI(); // Enable SPI
PIO_Clear(&CE);
PIO_Set(&CSN);
for(i=0; i<32; i++)
tx_buf[i] = 0; // init buffer
PIO_Clear(&CE);
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Writes TX_Address to nRF24L01
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr
SPI_RW_Reg(WRITE_REG + EN_AA, 0x00); // Disable Auto.Ack
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0
SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
//SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retransmissions. (not needed - no auto ack)
SPI_RW_Reg(WRITE_REG + RF_CH, RF_CHANNEL); // Select RF channel
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:1Mbps
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:TX. MAX_RT & TX_DS enabled..
PIO_Set(&CE);
}
uint8_t ILI9488_EbiSendCommand(uint16_t Instr, uint16_t *pTxData,
uint32_t *pRxData, AccessIli_t ReadWrite, uint32_t size)
{
command = Instr;
if (ReadWrite == AccessInst) {
PIO_Clear(&lcd_ebi_cds_pin);
ili9488DmaCtlInEbiMode.cmdOrDataFlag = 1;
return ILI9488_EbiDmaTxTransfer(&command, 1);
} else if (ReadWrite == AccessWrite) {
PIO_Clear(&lcd_ebi_cds_pin);
ili9488DmaCtlInEbiMode.cmdOrDataFlag = 1;
ILI9488_EbiDmaTxTransfer(&command, 1);
if (size == 0) return 0;
ILI9488_EbiDmaTxTransfer(pTxData, size);
return 0;
} else {
ili9488DmaCtlInEbiMode.rxDoneFlag = 0;
ILI9488_EbiDmaRxTransfer(pRxData, size);
while (!ili9488DmaCtlInEbiMode.rxDoneFlag);
}
return 0;
}
/**
* \brief Set the backlight of the LCD.
*
* \param level Backlight brightness level [1..16], 1 means maximum brightness.
*/
void LCDD_SetBacklight (uint32_t level)
{
uint32_t i;
const Pin pPins[] = {BOARD_BACKLIGHT_PIN};
/* Ensure valid level */
level = (level < 1) ? 1 : level;
level = (level > 16) ? 16 : level;
/* Enable pins */
PIO_Configure(pPins, PIO_LISTSIZE(pPins));
/* Switch off backlight */
PIO_Clear(pPins);
i = 600 * (BOARD_MCK / 1000000); /* wait for at least 500us */
while(i--);
/* Set new backlight level */
for (i = 0; i < level; i++) {
PIO_Clear(pPins);
PIO_Clear(pPins);
PIO_Clear(pPins);
PIO_Set(pPins);
PIO_Set(pPins);
PIO_Set(pPins);
}
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
void GLCD_EnableController(unsigned char controller)
{
switch(controller)
{
case 0 : PIO_Clear(&GLcdpins[4]); break;
case 1 : PIO_Clear(&GLcdpins[3]); break;
}
}
void AD5206_sendbit(unsigned char bit){
volatile unsigned int uDummy;
for (uDummy=0; uDummy<512; ++uDummy);
PIO_Clear(&SCK);
if(bit)
PIO_Set(&MOSI);
else
PIO_Clear(&MOSI);
for (uDummy=0; uDummy<512; ++uDummy);
PIO_Set(&SCK);
}
void motor_setopts(unsigned char axis, unsigned char ustepbits, unsigned char current){
Pin MS1;
Pin MS2;
unsigned char channel;
switch(axis){
case 0:
MS1=XMS1;
MS2=XMS2;
channel=3;
break;
case 1:
MS1=YMS1;
MS2=YMS2;
channel=1;
break;
case 2:
MS1=ZMS1;
MS2=ZMS2;
channel=0;
break;
case 3:
MS1=E0MS1;
MS2=E0MS2;
channel=2;
break;
case 4:
MS1=E1MS1;
MS2=E1MS2;
channel=5;
break;
case 6:
ustepbits=4;
channel=4;
break;
default:
return;
}
if(ustepbits<4){
if(ustepbits&1)
PIO_Set(&MS1);
else
PIO_Clear(&MS1);
if(ustepbits&2)
PIO_Set(&MS2);
else
PIO_Clear(&MS2);
}
AD5206_setchan(channel,current);
//printf("Setting channel %u to current value %u and ustep value %u\r\n",channel, current, ustepbits);
}
int main(void) {
device_init();
init_display();
PIO_Set(&display_pins[0]);
PIO_Clear(&display_pins[1]);
PIO_Clear(&display_pins[2]);
PIO_Set(&display_pins[3]);
while(1){
}
}
void dc_full_brake(void) {
dc_velocity_goal = 0;
dc_velocity = 0;
// In coast mode, actively pull down input1 and 2, in brake mode this
// is done automatically if velocity is set to 0.
if(dc_mode == DC_MODE_DRIVE_COAST) {
PWM->PWM_CH_NUM[DISABLE1_CHANNEL].PWM_CDTYUPD = 0;
PIO_Clear(&pin_input1);
PIO_Clear(&pin_input2);
} else {
dc_velocity_to_pwm();
}
}
// ============================================================================
void lcd_putchar(char ch)
{
PIO_Set(&Lcdpins[0]);
setD4567(ch);
PIO_Set(&Lcdpins[1]);
clcd_minDelay();
PIO_Clear(&Lcdpins[1]);
clcd_minDelay();
setD4567(ch<<4);
PIO_Set(&Lcdpins[1]);
clcd_minDelay();
PIO_Clear(&Lcdpins[1]);
clcd_Delay();
}
// ============================================================================
void lcd_command(char cmd) //Sends Command to LCD
{
PIO_Clear(&Lcdpins[0]);
setD4567(cmd);
PIO_Set(&Lcdpins[1]);
clcd_minDelay();
PIO_Clear(&Lcdpins[1]);
clcd_minDelay();
setD4567(cmd<<4);
PIO_Set(&Lcdpins[1]);
clcd_minDelay();
PIO_Clear(&Lcdpins[1]);
clcd_Delay();
}
//-------------------------------------
void GLCD_WriteData(unsigned char dataToWrite)
{
unsigned int byte;
DELAY()
PIO_Clear(&GLcdpins[2]);
PIO_Set(&GLcdpins[0]);
byte = dataToWrite;
DATAPORT(byte);
GLCD_EnableController(screen_x / 64);
PIO_Set(&GLcdpins[1]);
DELAY();
PIO_Clear(&GLcdpins[1]);
GLCD_DisableController(screen_x / 64);
screen_x++;
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
void GLCD_WriteCommand(unsigned char commandToWrite, unsigned char controller)
{
unsigned int command;
DELAY();
PIO_Clear(&GLcdpins[0]);
PIO_Clear(&GLcdpins[2]);
GLCD_EnableController(controller);
command=commandToWrite;
DATAPORT(command);
PIO_Set(&GLcdpins[1]);
DELAY();
PIO_Clear(&GLcdpins[1]);
GLCD_DisableController(controller);
}
/**
* Turns the given LED on if it exists; otherwise does nothing.
* \param led Number of the LED to turn on.
* \return 1 if the LED has been turned on; 0 otherwise.
*/
extern uint32_t LED_Set( uint32_t dwLed )
{
#ifdef PINS_LEDS
/* Check if LED exists */
if ( dwLed >= numLeds )
{
return 0 ;
}
/* Turn LED on */
if ( pinsLeds[dwLed].type == PIO_OUTPUT_0 )
{
PIO_Set( &pinsLeds[dwLed] ) ;
}
else
{
PIO_Clear( &pinsLeds[dwLed] ) ;
}
return 1 ;
#else
return 0 ;
#endif
}
/* maybe this can be optimized */
static void i2c_init(void)
{
i2c_sda_pin_desc = &(g_APinDescription[i2c_sda_pin]);
i2c_scl_pin_desc = &(g_APinDescription[i2c_scl_pin]);
pinMode(i2c_sda_pin, OUTPUT);
digitalWrite(i2c_sda_pin, HIGH);
pinMode(i2c_scl_pin, OUTPUT);
digitalWrite(i2c_scl_pin, HIGH);
PIO_Configure( i2c_sda_pin_desc->pPort, PIO_OUTPUT_0, i2c_sda_pin_desc->ulPin, PIO_OPENDRAIN );
PIO_Configure( i2c_scl_pin_desc->pPort, PIO_OUTPUT_0, i2c_scl_pin_desc->ulPin, PIO_OPENDRAIN );
PIO_Clear( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin) ;
PIO_Clear( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin) ;
PIO_Configure( i2c_sda_pin_desc->pPort, PIO_INPUT, i2c_sda_pin_desc->ulPin, PIO_DEFAULT ) ;
PIO_Configure( i2c_scl_pin_desc->pPort, PIO_INPUT, i2c_scl_pin_desc->ulPin, PIO_DEFAULT ) ;
i2c_delay();
}
void stepper_enable(void) {
PIO_Set(&pin_reset);
PIO_Clear(&pin_enable);
PIO_Set(&pin_sleep);
stepper_state = STEPPER_STATE_STOP;
stepper_speedramp_state = STEPPER_SPEEDRAMP_STATE_STOP;
}
int main(void)
{
/// Init DBGU
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
printf("-- %s: blink-interrupt Project with at91lib v%s --\n\r", BOARD_NAME, SOFTPACK_VERSION);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/// Init PIOA & PIOB interrupt
PIO_InitializeInterrupts(0);
/// Init LED
PIO_Configure(&pinLed, 1);
TRACE_INFO("LED:\n\r");
/// Configure and enable the interrupt
PIO_ConfigureIt(&pinButton, (void (*)(const Pin *)) User_InterruptHandler);
PIO_EnableIt(&pinButton);
while (1)
{
PIO_Set(&pinLed);
delay(1000);
PIO_Clear(&pinLed);
delay(1000);
}
}
void set_pin(const Pin *pin, const uint8_t state)
{
if (state)
PIO_Set(pin);
else
PIO_Clear(pin);
}
void tick_task(uint8_t tick_type) {
if(tick_type == TICK_TASK_TYPE_CALCULATION) {
stepper_tick_calc_counter++;
stepper_current_sum += adc_channel_get_data(STEPPER_CURRENT_CHANNEL);
if(stepper_tick_calc_counter % 100 == 0) {
stepper_current = stepper_current_sum/100;
stepper_current_sum = 0;
}
// Switch Output Voltage between extern and stack
if(stepper_get_external_voltage() < STEPPER_VOLTAGE_EPSILON) {
PIO_Set(&pin_voltage_switch);
} else {
PIO_Clear(&pin_voltage_switch);
}
} else if(tick_type == TICK_TASK_TYPE_MESSAGE) {
stepper_tick_counter++;
if(stepper_position_reached) {
stepper_position_reached = false;
stepper_position_reached_signal();
}
stepper_check_error_signals();
}
}
uint16_t tactile_read_adc(uint8_t adc_chan, const uint8_t num_samples)
{
// 0x3c49
const uint16_t adc_cfg = (0x3c09 | (adc_chan << 7)) << 2;
volatile uint16_t rx;
uint32_t adc_sum = 0;
for (int i = 0; i < 3 + num_samples; i++)
{
PIO_Clear(&pin_cs_adc_tactile);
ADC_T_EN;
SPI->SPI_TDR = adc_cfg;
while ((SPI->SPI_SR & SPI_SR_TXEMPTY) == 0) { }
rx = SPI->SPI_RDR;
ADC_T_DIS;
PIO_Set(&pin_cs_adc_tactile);
ADC_T_CYC;
if (i >= 3)
{
adc_sum += rx;
for (volatile int j = 0; j < 100; j++) { }
}
}
return adc_sum / num_samples;
}
unsigned char Get_Current( unsigned char channel, unsigned char repeat_times, unsigned char *pData)
{
unsigned char status = 0;
unsigned int i, range_flag ;
unsigned int total, average;
unsigned int adc_result[MAX_REPEAT_TIMES];
if( channel > 2 ) { //channel is limited to 0 ~ 2
return 0x22;//error
}
range_flag = 0x80000000 ; //0.33 Ohm, larger current range
if( repeat_times > MAX_REPEAT_TIMES || repeat_times==0 ) {
return 0x23; //error
}
OSTimeDly(100); //delay_ms(100); ?????
status = Init_AD7799( channel );
if(status!=0) {
return status; //init failed, return ;
}
adc_result[0] = AD7799_GetConvertedData(); //first test data discard
adc_result[0] = AD7799_GetConvertedData();
if(adc_result[0] < RANGE_LIMIT ) {
range_flag = 0x00000000 ; //220 Ohm, small current range
PIO_Set( &pinsControls[6+channel] );//switch to 220 Ohm : 0.1uA ~ 100uA range
OSTimeDly(1000); //delay_ms(1000);
adc_result[0] = AD7799_GetConvertedData();
}
//printf("adc_result[0] = 0x%8X\r\n",adc_result[0] );
total = adc_result[0];
for(i=1; i<repeat_times; i++) {
adc_result[i] = AD7799_GetConvertedData();
total += adc_result[i];
//printf("adc_result[%d] = 0x%8X\r\n",i,adc_result[i] );
}
// reset R to 0.33//220 after test
// OSTimeDlyHMSM(0,0,3,0); //delay_ms(100); ?????
OSTimeDly(2000); //delay_ms(2000);
if(range_flag == 0) {
PIO_Clear( &pinsControls[6+ channel] );//switch to 0.33//220 Ohm : 0.1mA ~ 30mA range
}
average = total/repeat_times + range_flag;
*(pData++) = average>>0 & 0xFF;
*(pData++) = average>>8 & 0xFF;
*(pData++) = average>>16 & 0xFF;
*pData = average>>24 & 0xFF;
//printf("adc_data = 0x%8X\r\n",average );
return status ;
}
/*! \brief Enable or disable Power of E4K
* \param[in] e4k E4K reference
* \param[in] on Enable (1) or disable (0) Power
*/
void sam3u_e4k_power(struct e4k_state *e4k, int on)
{
if (on)
PIO_Set(&pin_pwdn);
else
PIO_Clear(&pin_pwdn);
}
/*! \brief Enable or disable standby mode of E4K
* \param[in] e4k E4K reference
* \param[in] on Enable (1) or disable (0) STBY
*/
void sam3u_e4k_stby(struct e4k_state *e4k, int on)
{
if (on)
PIO_Clear(&pin_rfstby);
else
PIO_Set(&pin_rfstby);
}
/*
Function: USBD_Disconnect
Disconnects the pull-up from the D+ line of the USB.
*/
void USBD_Disconnect()
{
TRACE_DEBUG( "Disc ");
#if defined(BOARD_USB_PULLUP_EXTERNAL)
const Pin pinPullUp = PIN_USB_PULLUP;
if (pinPullUp.attribute == PIO_OUTPUT_0) {
PIO_Clear(&pinPullUp);
}
else {
PIO_Set(&pinPullUp);
}
#elif defined(BOARD_USB_PULLUP_INTERNAL)
AT91C_BASE_UDP->UDP_TXVC &= ~AT91C_UDP_PUON;
#elif defined(BOARD_USB_PULLUP_MATRIX)
AT91C_BASE_MATRIX->MATRIX_USBPCR &= ~AT91C_MATRIX_USBPCR_PUON;
#elif !defined(BOARD_USB_PULLUP_ALWAYSON)
#error Unsupported pull-up type.
#endif
// Device returns to the Powered state
if (deviceState > USBD_STATE_POWERED) {
deviceState = USBD_STATE_POWERED;
}
}
/**
* \brief Send single command to ILI9488
* \param cmd command.
*/
static void ILI9488_SendCmd(uint8_t cmd)
{
uint32_t i;
PIO_Clear(&lcd_spi_cds_pin);
SPI_Write(ILI9488_SPI, SMC_EBI_LCD_CS, cmd);
for (i = 0; i < 0x18; i++);
}
