/* check HW revision and HW type */
static shtmp_result_t shtmp_check_HW_type_revision(void)
{
int is_db;
SHTMP_TRACE("[S] %s \n",__FUNCTION__);
is_db = GPIO_GET(DBGB_SW_BIT);
SHTMP_TRACE("[P] %s is_db=%d \n",__FUNCTION__, is_db);
if(is_db == 0)
{
/* Debug Board */
shtmp_ic_use_flg = 0;
shtmp_ic_disable_flg = 0;
}
else
{
/* Product */
shtmp_ic_use_flg = 1;
shtmp_ic_disable_flg = 0;
}
SHTMP_TRACE("[E] %s \n",__FUNCTION__);
return SHTMP_RESULT_SUCCESS;
}
/**
* Tests GPIO Input and Output by reading from the input pin
* and echoing to the output pin
*/
void BLINK()
{
GPIO_FSEL(0, INPUT);
GPIO_FSEL(25, OUTPUT);
while(1)
{
if(GPIO_GET(0) == HIGH)
GPIO_SET(25, HIGH);
else
GPIO_SET(25, LOW);
}
}
int Procesar(void)
{
static int contador = 0;
static int barrido;
contador++;
if ( GPIO_GET(estado_teclas, TECLA_2) )
GPIO_SET(estado_leds, LED_1);
else
GPIO_CLEAR(estado_leds, LED_1);
if ( GPIO_GET(estado_teclas, TECLA_3) )
GPIO_SET(estado_leds, LED_2);
else
GPIO_CLEAR(estado_leds, LED_2);
if ( GPIO_GET(estado_teclas, TECLA_4) )
GPIO_SET(estado_leds, LED_3);
else
GPIO_CLEAR(estado_leds, LED_3);
if ( GPIO_GET(estado_teclas, TECLA_1) )
{
barrido++;
barrido &= 0x07;
GPIO_CLEAR(estado_leds, RGB_R | RGB_G | RGB_B);
GPIO_SET(estado_leds, barrido);
/*
* Se visualiza el cambio?
* Problemas?
* Implementación de una máquina de estados
*/
}
return 1;
}
/*---------------------------------------------------------------------------*/
uint8_t
enc28j60_arch_spi_write(uint8_t output)
{
int i;
uint8_t input;
input = 0;
for(i = 0; i < 8; i++) {
/* Write data on MOSI pin */
if(output & 0x80) {
GPIO_SET(SPI_MOSI_PORT, SPI_MOSI_BIT);
} else {
GPIO_RESET(SPI_MOSI_PORT, SPI_MOSI_BIT);
}
output <<= 1;
/* Set clock high */
GPIO_SET(SPI_CLK_PORT, SPI_CLK_BIT);
/* SPI delay */
delay();
/* Read data from MISO pin */
input <<= 1;
if(GPIO_GET(SPI_MISO_PORT, SPI_MISO_BIT) != 0) {
input |= 0x1;
}
/* Set clock low */
GPIO_RESET(SPI_CLK_PORT, SPI_CLK_BIT);
/* SPI delay */
delay();
}
return input;
}
uint8_t hd44780_read(struct dev_hd44780_ctx *a_disp, uint8_t a_rs) {
uint8_t x = HD44780_DATALINES;
uint8_t data = 0x00;
#if HD44780_8BIT_MODE != 1
uint8_t nibbles = 3;
#endif
if (a_rs) {
GPIO_SET_HIGH(&a_disp->rs);
}
else {
GPIO_SET_LOW(&a_disp->rs);
}
// raise R/W line
GPIO_SET_HIGH(&a_disp->rw);
#if HD44780_8BIT_MODE == 1
// raise the enable line high now, since in 8 bit mode everything
// will be done in one loop
GPIO_SET_HIGH(&a_disp->e);
#endif
// switch data lines to inputs
while (x--) {
GPIO_CONFIGURE_AS_INPUT(&a_disp->data[x]);
#if HD44780_8BIT_MODE == 1
// in 8 bit mode I try to do everything in one loop
data |= (GPIO_GET(&a_disp->data[x]) << x);
#endif
}
#if HD44780_8BIT_MODE == 0
// in 4 bit mode a second loop is inevitable
while (--nibbles) {
GPIO_SET_HIGH(&a_disp->e);
x = HD44780_DATALINES;
while (x--) {
data |= (GPIO_GET(&a_disp->data[x]) <<
(x + ((nibbles - 1) << 2)) );
}
GPIO_SET_LOW(&a_disp->e);
}
#else
GPIO_SET_LOW(&a_disp->e);
#endif
// lower R/W line - write mode by default
GPIO_SET_LOW(&a_disp->rw);
// switch data lines to outputs back again
x = HD44780_DATALINES;
while (x--) {
GPIO_CONFIGURE_AS_OUTPUT(&a_disp->data[x]);
}
return data;
}
// Returns the number of non-cleared alarms
unsigned int checkAlarmInputs() {
if (alarmsActive) {
return alarmsActive;
}
unsigned int sw = 0;
if (!GPIO_GET(IO_X_MIN)) sw |= 1<<ALARM_SW_X_MIN;
if (!GPIO_GET(IO_X_MAX)) sw |= 1<<ALARM_SW_X_MAX;
if (!GPIO_GET(IO_Y_MIN)) sw |= 1<<ALARM_SW_Y_MIN;
if (!GPIO_GET(IO_Y_MAX)) sw |= 1<<ALARM_SW_Y_MAX;
if (!GPIO_GET(IO_Z_MIN)) sw |= 1<<ALARM_SW_Z_MIN;
if (!GPIO_GET(IO_Z_MAX)) sw |= 1<<ALARM_SW_Z_MAX;
if (!GPIO_GET(IO_A_MIN)) sw |= 1<<ALARM_SW_A_MIN;
if (!GPIO_GET(IO_A_MAX)) sw |= 1<<ALARM_SW_A_MAX;
if (GPIO_GET(IO_ESTOP)) sw |= 1<<ALARM_SW_ESTOP;
if (!GPIO_GET(IO_WD_READY)) sw |= 1<<ALARM_WD;
if (!GPIO_GET(IO_LASER_READY)) sw |= 1<<ALARM_LASER;
unsigned int csw = getCoolantAlarm();
if (alarmsIgnored) {
csw &=~ alarmsIgnored;
sw &=~ alarmsIgnored;
}
if (sw || csw) {
if (sw && csw) {
alarmSet(sw|csw, "Switches triggered and cooling failure");
return 2;
}
if (sw) {
alarmSet(sw|csw, "Switches triggered");
return 1;
}
alarmSet(sw|csw, "Cooling failure");
return 1;
}
return 0;
}
/**************************************************************************************************
* @fn MT_SysGpio
*
* @brief ZAccel RPC interface for controlling the available GPIO pins.
*
* @param uint8 pData - Pointer to the data.
*
* @return None
*************************************************************************************************/
void MT_SysGpio(uint8 *pBuf)
{
uint8 cmd, val;
GPIO_Op_t op;
cmd = pBuf[MT_RPC_POS_CMD1];
pBuf += MT_RPC_FRAME_HDR_SZ;
op = (GPIO_Op_t)(*pBuf++);
val = *pBuf;
switch (op)
{
case GPIO_DIR:
if (val & BV(0)) {GPIO_DIR_OUT(0);} else {GPIO_DIR_IN(0);}
if (val & BV(1)) {GPIO_DIR_OUT(1);} else {GPIO_DIR_IN(1);}
if (val & BV(2)) {GPIO_DIR_OUT(2);} else {GPIO_DIR_IN(2);}
if (val & BV(3)) {GPIO_DIR_OUT(3);} else {GPIO_DIR_IN(3);}
break;
case GPIO_TRI:
if(val & BV(0)) {GPIO_TRI(0);} else if(val & BV(4)) {GPIO_PULL_DN(0);} else {GPIO_PULL_UP(0);}
if(val & BV(1)) {GPIO_TRI(1);} else if(val & BV(5)) {GPIO_PULL_DN(1);} else {GPIO_PULL_UP(1);}
if(val & BV(2)) {GPIO_TRI(2);} else if(val & BV(6)) {GPIO_PULL_DN(2);} else {GPIO_PULL_UP(2);}
if(val & BV(3)) {GPIO_TRI(3);} else if(val & BV(7)) {GPIO_PULL_DN(3);} else {GPIO_PULL_UP(3);}
break;
case GPIO_SET:
if (val & BV(0)) {GPIO_SET(0);}
if (val & BV(1)) {GPIO_SET(1);}
if (val & BV(2)) {GPIO_SET(2);}
if (val & BV(3)) {GPIO_SET(3);}
break;
case GPIO_CLR:
if (val & BV(0)) {GPIO_CLR(0);}
if (val & BV(1)) {GPIO_CLR(1);}
if (val & BV(2)) {GPIO_CLR(2);}
if (val & BV(3)) {GPIO_CLR(3);}
break;
case GPIO_TOG:
if (val & BV(0)) {GPIO_TOG(0);}
if (val & BV(1)) {GPIO_TOG(1);}
if (val & BV(2)) {GPIO_TOG(2);}
if (val & BV(3)) {GPIO_TOG(3);}
break;
case GPIO_GET:
break;
case GPIO_HiD:
(val) ? GPIO_HiD_SET() : GPIO_HiD_CLR();
break;
default:
break;
}
val = (GPIO_GET(0)) ? BV(0) : 0;
val |= (GPIO_GET(1)) ? BV(1) : 0;
val |= (GPIO_GET(2)) ? BV(2) : 0;
val |= (GPIO_GET(3)) ? BV(3) : 0;
/* Build and send back the response */
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_SYS), cmd, 1, &val);
}
int gpioGet(int pin){
// Ottieni il numero BCM dal numero fornito
pin = libgpio_gpio_map[pin];
return (GPIO_GET(pin) & (1 << (pin & 0x1f)))?1:0;
}
static INLINE int JTAG0_TDO_IS_ON(void) { return GPIO_GET(JTAG0_TDO_PIO_BIT); }