void leds_tick(void)
{
leds_counter++;
if( leds_open_state == LED_ON){
PIN_SET(LED_OPEN_PIN);
}else if( leds_open_state == LED_OFF ){
PIN_CLEAR(LED_OPEN_PIN);
}else if( leds_open_state == LED_SHORT_FLASH ){
if( (leds_counter % 1024) < 50 ){
PIN_SET(LED_OPEN_PIN);
}else{
PIN_CLEAR(LED_OPEN_PIN);
}
}
}
void leds_init(void)
{
DDR_CONFIG_OUT(LED_OPEN_PIN);
PIN_SET(LED_OPEN_PIN);
leds_open_state = LED_OFF;
leds_counter = 0;
}
/*---------------------------------------------------------------------------*/
ISR(UNMI, unmi_interrupt) /* user non-maskable interrupts */
{
ENERGEST_ON(ENERGEST_TYPE_CPU);
PIN_SET(LED_ERROR); /* use PIN_SET instead of LED_ON */
switch (SYSUNIV) {
case SYSUNIV_NMIIFG: /* non-maskable interrupt */
while(1);
break;
case SYSUNIV_OFIFG: /* oscillator fault */
WAIT_FOR_OSC(); /* try to clear the fault flag */
break;
case SYSUNIV_ACCVIFG: /* Flash Memory Access Violation */
/* will be accidentially triggered after flash programming when using
* a voltage between 2.4 and 2.6V (errata SYS12) */
while(1);
break;
case SYSUNIV_SYSBERRIV:
while(1);
break;
default:
while(1);
break;
}
PIN_CLR(LED_ERROR);
ENERGEST_OFF(ENERGEST_TYPE_CPU);
}
void
dcf77_init(void)
{
DCFDEBUG("init dcf77\n");
#ifdef DCF1_USE_PON_SUPPORT
DCFDEBUG("PON\n");
/* if module needs a peak on PON to enable dcf77 receiver
* configure pin as output, set low */
PIN_SET(DCF1_PON);
#endif
#if defined(DCF77_PCINT_PIN)
DCFDEBUG("configure_pcint\n");
/* configure */
dcf77_configure_pcint();
#elif defined(DCF77_INT_PIN)
DCFDEBUG("HAVE_DCF77_INT\n");
/* Initialize "real" Interrupt */
_EIMSK |= _BV(DCF77_INT_PIN);
_EICRA = (_EICRA & ~DCF77_INT_ISCMASK) | DCF77_INT_ISC;
#else
DCFDEBUG("Analog Comparator\n");
// Analog Comparator init
ACSR |= _BV(ACIE);
#endif
#ifdef DCF1_USE_PON_SUPPORT
for (uint8_t i = 0; i < 100; i++)
{
wdt_kick();
_delay_ms(10);
}
PIN_CLEAR(DCF1_PON);
#endif
}
void rc5_send_zero(void)
{
PIN_SET(RC5_SEND);
_delay_loop_2(RC5_PULSE);
PIN_CLEAR(RC5_SEND);
_delay_loop_2(RC5_PULSE);
}
static void dht22_sun5i_write_bit(u8 bit) {
if (dht22_sun5i_gpio_direction != PIN_DIR_OUT) {
dht22_sun5i_gpio_direction = PIN_DIR_OUT;
PIN_DIR(PIN_DIR_OUT);
}
PIN_SET(bit);
}
void
usb_init(void)
{
#ifdef AUTOSET_USB_ENABLE_PIN_SUPPORT
PIN_SET(USB_ENABLE);
#endif /* AUTOSET_USB_ENABLE_PIN_SUPPORT */
#ifdef USB_NET_SUPPORT
usb_net_init();
#endif
#ifdef USB_KEYBOARD_SUPPORT
#endif
#define USB_DDR_CONFIG(pin) DDR_CHAR( pin ## _PORT) &= ~(_BV((pin ## _PIN)) | _BV(USB_INT_PIN))
#define USB_PORT_CONFIG(pin) PORT_CHAR( pin ## _PORT) &= ~(_BV((pin ## _PIN)) | _BV(USB_INT_PIN))
USB_DDR_CONFIG(USB_DMINUS);
USB_PORT_CONFIG(USB_DMINUS);
#undef USB_DDR_CONFIG
#undef USB_PORT_CONFIG
uint8_t i;
/* Reenummerate the device */
usbDeviceDisconnect();
for(i = 0; i < 20; i++){ /* 300 ms disconnect */
_delay_ms(15);
wdt_kick();
}
usbDeviceConnect();
/* USB Initialize */
usbInit();
}
static void
rfm12_txstart_hard(void)
{
rfm12_status = RFM12_TX;
#ifdef STATUSLED_RFM12_TX_SUPPORT
PIN_SET(STATUSLED_RFM12_TX);
#endif
ACTIVITY_LED_RFM12_TX;
rfm12_index = 0;
rfm12_prologue(RFM12_MODULE_IP);
rfm12_trans(RFM12_CMD_PWRMGT | RFM12_PWRMGT_ET | RFM12_PWRMGT_ES |
RFM12_PWRMGT_EX);
rfm12_epilogue();
/* Force interrupts active no matter what.
*
* If we're forwarding a packet from say Ethernet, uip_buf_unlock won't
* unlock since there's an active RFM12 transfer, but it'd leave
* the RFM12 interrupt disabled as well. */
_uip_buf_lock = 8;
rfm12_int_enable();
}
void buttons_init(void)
{
DDR_CONFIG_IN(BUTTON_0);
PIN_SET(BUTTON_0);
DDR_CONFIG_IN(BUTTON_1);
PIN_SET(BUTTON_1);
DDR_CONFIG_IN(BUTTON_2);
PIN_SET(BUTTON_2);
buttons_0_counter = 0;
buttons_1_counter = 0;
buttons_2_counter = 0;
buttons_latched_state = 0;
}
void leds_init(void)
{
DDR_CONFIG_OUT(LED1);
DDR_CONFIG_OUT(LED2);
DDR_CONFIG_OUT(LED3);
PIN_SET(LED2);
}
void noinline hd44780_hw_init(void)
{
/* init io pins */
CTRL_OUTPUT();
#ifdef HAVE_LCDON
PIN_SET(LCDON);
#endif
PIN_CLEAR(HD44780_RS);
#ifndef HD44780_MULTIENSUPPORT
PIN_CLEAR(HD44780_EN1);
#endif
#ifdef HD44780_MULTIENSUPPORT
PIN_CLEAR(HD44780_EN1);
PIN_CLEAR(HD44780_EN2);
#endif
#ifdef HAVE_HD44780_RW
PIN_CLEAR(HD44780_RW);
#endif
PIN_CLEAR(HD44780_D4);
PIN_CLEAR(HD44780_D5);
PIN_CLEAR(HD44780_D6);
PIN_CLEAR(HD44780_D7);
DATA_OUTPUT();
#ifdef HD44780_BACKLIGHT_SUPPORT
PIN_CLEAR(HD44780_BL);
#endif
}
uint8_t
modbus_rxstart(uint8_t *data, uint8_t len, int16_t *recv_len) {
#ifdef MODBUS_CLIENT_SUPPORT
if (data[0] == MODBUS_ADDRESS || data[0] == MODBUS_BROADCAST) {
modbus_client_process(data, len, recv_len);
if (data[0] == MODBUS_ADDRESS)
return 1;
}
#endif
if (modbus_data.crc_len != 0) return 0; /* There is an packet on the way */
/* enable the transmitter */
PIN_SET(MODBUS_TX);
modbus_recv_len_ptr = recv_len;
modbus_data.crc = modbus_crc_calc(data, len);
modbus_data.crc_len = 2;
modbus_data.data = data;
modbus_data.len = len;
/* Enable the tx interrupt and send the first character */
modbus_data.sent = 1;
usart(UCSR,B) |= _BV(usart(TXCIE));
usart(UDR) = data[0];
return 1;
}
void resync_led_display(void) {
//Setzt einmal Reset
cli();
PIN_SET(LED_RESET); //Reset high
gzeile = 0;
PIN_CLEAR(LED_RESET); //Reset lo
sei();
}
void init_led_display(void) {
/*Setzen der Data Direction Regiser auf Ausgang
LED_RESET_DDR |= (1<<LED_RESET_PIN);
LED_SELECT_DDR |= (1<<LED_SELECT_PIN);
LED_BRIGHT_DDR |= (1<<LED_BRIGHT_PIN);
LED_RED_DDR |= (1<<LED_RED_PIN);
LED_GREEN_DDR |= (1<<LED_GREEN_PIN);
LED_CLOCK_DDR |= (1<<LED_CLOCK_PIN);
*/
TC2_COUNTER_CURRENT = 0; //Timer 2 Resetten
_TIMSK_TIMER2 |= _BV(TOIE2); //Timer 2 Overflow Interrupt aktiv
_TCCR2_PRESCALE = _BV(CS21) | _BV(CS20); //Prescaler = 8 /32
PIN_SET(LED_RESET); //LED_RESET_PORT |= (1<<LED_RESET_PIN); //Reset high
gzeile = 0; //beginne mit Zeile 0
PIN_CLEAR(LED_RESET); //Reset low
PIN_SET(LED_SELECT); //LED_SELECT_PORT |= (1<<LED_SELECT_PIN); //Select auf high
}
static void switch_channel_multiplex(void)
{
#if FREQCOUNT_CHANNELS > 1
if (freqcount_current_channel & 0x01)
PIN_SET(FREQCOUNT_CHANNEL_MULTIPLEX_BIT1);
else
PIN_CLEAR(FREQCOUNT_CHANNEL_MULTIPLEX_BIT1);
#endif
#if FREQCOUNT_CHANNELS > 2
if (freqcount_current_channel & 0x02)
PIN_SET(FREQCOUNT_CHANNEL_MULTIPLEX_BIT2);
else
PIN_CLEAR(FREQCOUNT_CHANNEL_MULTIPLEX_BIT2);
#endif
#if FREQCOUNT_CHANNELS > 4
if (freqcount_current_channel & 0x04)
PIN_SET(FREQCOUNT_CHANNEL_MULTIPLEX_BIT3);
else
PIN_CLEAR(FREQCOUNT_CHANNEL_MULTIPLEX_BIT3);
#endif
#if FREQCOUNT_CHANNELS > 8
// we have two 74xx251 multiplexers
// they are enabled by setting the respective
// chip select line to low
// otherwise their output is in high-z
if (freqcount_current_channel & 0x08)
{
// bit 8 set: enable multiplexer ic B
PIN_SET(FREQCOUNT_CHANNEL_MULTIPLEX_CS_A);
PIN_CLEAR(FREQCOUNT_CHANNEL_MULTIPLEX_CS_B);
}
else
{
// bit 8 not set: enable multiplexer ic A
PIN_CLEAR(FREQCOUNT_CHANNEL_MULTIPLEX_CS_A);
PIN_SET(FREQCOUNT_CHANNEL_MULTIPLEX_CS_B);
}
#endif
#if FREQCOUNT_CHANNELS > 16
#error sorry, more than 16 frequency counter channels currently not supported
#endif
}
void
bulbdial_clock(uint8_t delay){
struct clock_datetime_t date;
clock_current_localtime(&date);
clear();
set(0x0001 << (date.sec/5));
PIN_SET(BULBDIAL_MINUTES);
for (uint8_t i = delay; i; i--)
_delay_ms(1);
PIN_CLEAR(BULBDIAL_MINUTES);
clear();
set(0x0001 << (date.min/5));
PIN_SET(BULBDIAL_HOURS);
for (uint8_t i = delay; i; i--)
_delay_ms(1);
PIN_CLEAR(BULBDIAL_HOURS);
}
int16_t parse_cmd_matemat_cooling(char *cmd, char *output, uint16_t len)
/* {{{ */ {
if(cmd[1] == '1')
PIN_SET(MATEMAT_COOLER);
if(cmd[1] == '0')
PIN_CLEAR(MATEMAT_COOLER);
return 0;
} /* }}} */
void fs20_send_zero(void)
{
PIN_SET(FS20_SEND);
_delay_loop_2(FS20_DELAY_ZERO);
PIN_CLEAR(FS20_SEND);
_delay_loop_2(FS20_DELAY_ZERO);
}
void Stepper::setSpeed(int16_t _speed){
speed += constrain((_speed-speed), -(int16_t)maxAccel, (int16_t)maxAccel);
if(speed == 0)
period = 0;
else
period = MAX_SPEED/abs(speed);
(speed>0) ? PIN_CLR(dirPin) : PIN_SET(dirPin);
}
void
hd44780_backlight(uint8_t state)
{
hd44780_backlight_state = state;
#ifdef HD44780_BACKLIGHT_INV
if (hd44780_backlight_state)
PIN_CLEAR(HD44780_BL);
else
PIN_SET(HD44780_BL);
#else
if (hd44780_backlight_state)
PIN_SET(HD44780_BL);
else
PIN_CLEAR(HD44780_BL);
#endif
}
void ST7626_write(uint8_t mode, uint8_t data)
{
ST7626_DATA_DDR = 0xFF;
if(mode)
PIN_SET(ST7626_A0);
else
PIN_CLEAR(ST7626_A0);
ST7626_DATA = data;
PIN_CLEAR(ST7626_CS);
PIN_CLEAR(ST7626_WR);
asm("nop");
asm("nop");
PIN_SET(ST7626_WR);
PIN_SET(ST7626_CS);
}
void fs20_send_one(void)
{
PIN_SET(FS20_SEND);
_delay_loop_2(FS20_DELAY_ONE);
PIN_CLEAR(FS20_SEND);
_delay_loop_2(FS20_DELAY_ONE);
}
void analog_clock_clr(void)
{
uint8_t ticks = 0;
PIN_SET(SR74LS164_AB);
ticks = analog_clock_get_ticks(60);
analog_clock_gen_ticks(ticks);
}
/* Hauptroutine: Wird in der Hauptschleife abgerufen (sobald alle Interrupts und Timer abgearbeitet sind) - as fast as possible */
void rainmaster_mainloop(void) {
// Druckabfall in Leitung erkennen und Pumpe bei Bedarf einschalten
if(rm_status.PumpenKontakt == true) {
setpwm('a', 255); // Pumpe einschalten
rm_status.PumpenFlag = true; // Pumpenflag setzen
} else {
setpwm('a', 0); // Pumpe ausschalten
rm_status.PumpenFlag = false; // PumpenFlag setzen
rm_offcounter = 0; // Pumpe läuft nicht, also counter auf 0
}
uip_ipaddr_t ip_addr;
if(my_tanklevel < TANK_MIN) {
// TODO:
uip_ipaddr(ip_addr, 192, 168, 1, 101);
// Kugelhahn umstellen auf Trinkwasserbetrieb
PIN_CLEAR(RM_KUGELHAHN);
rm_status.Kugelhahn = 0;
// Eigenes Magnetventil schließen
setpwm('c', 0);
rm_status.Magnetventil = 0;
// TODO:
if(rm_001.request_state == 0) {
// Fremdgerät kann Magnetventil öffnen u Pumpe starten, falls kein Eigenbedarf u genügend Wasser bei sich
//ecmd_sender_send_command_P(&ip_addr, NULL, PSTR("rainmaster_request 1\n"));
rm_001.request_state = 1;
//rm_001.busy = 1;
}
}
if(my_tanklevel > TANK_MAX) {
if(rm_001.request_state == 1) {
// Fremdgerät kann Magnetventil öffnen u Pumpe starten, falls kein Eigenbedarf u genügend Wasser bei sich
//ecmd_sender_send_command_P(&ip_addr, NULL, PSTR("rainmaster_request 1\n"));
rm_001.request_state = 0;
}
// Kugelhahn umstellen auf Regenwasserbetrieb
PIN_SET(RM_KUGELHAHN);
rm_status.Kugelhahn = 1;
}
} /* End rainmaster_mainloop */
uint8_t noinline
hd44780_clock_rw(uint8_t read, uint8_t en)
{
uint8_t data = 0;
/* set EN high, wait for more than 450 ns */
#ifdef HD44780_MULTIEN_SUPPORT
if (en == 1)
PIN_SET(HD44780_EN1);
else if (en == 2)
PIN_SET(HD44780_EN2);
#else
PIN_SET(HD44780_EN1);
#endif
/* make sure that we really wait for more than 450 ns... */
_delay_us(1);
/* read data, if requested. data pins must be configured as input! */
if (read)
{
if (PIN_HIGH(HD44780_D4))
data |= _BV(0);
if (PIN_HIGH(HD44780_D5))
data |= _BV(1);
if (PIN_HIGH(HD44780_D6))
data |= _BV(2);
if (PIN_HIGH(HD44780_D7))
data |= _BV(3);
}
/* set EN low */
#ifdef HD44780_MULTIEN_SUPPORT
if (en == 1)
PIN_CLEAR(HD44780_EN1);
else if (en == 2)
PIN_CLEAR(HD44780_EN2);
#else
PIN_CLEAR(HD44780_EN1);
#endif
return data;
}
void analog_clock_set_inv(uint8_t val)
{
analog_clock_set(59);
PIN_SET(SR74LS164_AB);
analog_clock_gen_ticks(analog_clock_get_ticks(val));
analog_clock_val=0;
}
static void
psb2186_write(uint8_t addr, uint8_t value)
{
PIN_CLEAR(PSB2186_CS);
DDRA = 0xFF;
PORTA = addr;
PIN_SET(PSB2186_ALE);
nop();
PIN_CLEAR(PSB2186_ALE);
PORTA = value;
PIN_CLEAR(PSB2186_WR);
nop();
PIN_SET(PSB2186_WR);
PIN_SET(PSB2186_CS);
}
void hd44780_backlight(uint8_t state)
{
back_light = state;
#ifdef HD44780_BACKLIGHT_SUPPORT
if (back_light)
PIN_SET(HD44780_BL);
else
PIN_CLEAR(HD44780_BL);
#endif
}
/* Инициализация портов */
void sys_init()
{
port_attr_t port_attr;
#if defined(BLINK_ON)
PIN_SET( port_attr.dir, LED1|LED2|LED3, PIN_HI ); /* Направление на вывод */
PIN_CLEAR( port_attr.sel, LED1|LED2|LED3 ); /* Функция ввода/вывода */
PIN_CLEAR( port_attr.ie, LED1|LED2|LED3 ); /* Запрет прерываний */
port_set_attr( LED_PORT, LED1|LED2|LED3, &port_attr );
port_write( LED_PORT, LED1|LED2|LED3, PIN_LO );
#endif
#if defined(PLATFORM_FIRE_BUTTON)
PIN_SET( port_attr.dir, CONTROL_PINS, PIN_HI ); /* Направление на вывод */
PIN_CLEAR( port_attr.sel, CONTROL_PINS ); /* Функция ввода/вывода */
PIN_CLEAR( port_attr.ie, CONTROL_PINS ); /* Запрет прерываний */
port_set_attr( CONTROL_PORT, CONTROL_PINS, &port_attr );
port_write( CONTROL_PORT, CONTROL_PINS, PINT1 );
#endif
/* Настройка входа от геркона */
{ port_t iport = 0x00;
event_type_t event_type = 0;
result_t res = ENOSYS;
port_reset_iflag( IPORT, IPINS );
PIN_CLEAR( port_attr.dir, IPINS ); /* Направление на ввод */
PIN_CLEAR( port_attr.sel, IPINS ); /* Функция ввода/вывода */
PIN_SET( port_attr.ie, IPINS, PIN_HI ); /* Разрешаем прерывания от кнопки */
PIN_SET( port_attr.ies, IPINS, PIN_LO ); /* Ловим изменение с низкого на высокий уровень */
port_set_attr( IPORT, IPINS, &port_attr );
/* Определение текущего состояния входов */
port_read( IPORT, IPINS, &iport );
/* У тех входов, которые уже в 1 настраиваем прерывания на спад */
PIN_SET( port_attr.ies, iport, PIN_HI ); /* Ловим изменение с высокого на низкий уровень */
port_set_attr( IPORT, iport, &port_attr );
res = event_emit( PRIORITY, GIOP_INTERRUPT, (unidata_t)iport );
if( IS_ERROR(res) ) {
port_write( LED_PORT, LED1, PIN_HI );
}
}
return;
}
void
spi_init(void)
{
/* Input and Output configuration is done in the beginning of main(), so it
* doesn't have to be done here
*/
/* Set the chip-selects as high */
#ifdef ENC28J60_SUPPORT
PIN_SET(SPI_CS_NET);
#endif
#ifdef SER_RAM_23K256_SUPPORT
PIN_SET(SPI_CS_23K256);
#endif
#ifdef RFM12_SUPPORT
for (int8_t modul = 0; modul < RFM12_MODULE_COUNT; modul++)
{
*rfm12_moduls[modul].rfm12_port |= rfm12_moduls[modul].rfm12_mask;
}
#endif
#ifdef DATAFLASH_SUPPORT
PIN_SET(SPI_CS_DF);
#endif
#ifdef USTREAM_SUPPORT
PIN_SET(VS1053_CS);
#endif
#if defined(SPI_CS_SD_READER_PIN) && defined(SD_NETIO_ADDON_WORKAROUND)
PIN_SET(SPI_CS_SD_READER);
#endif
#ifndef SOFT_SPI_SUPPORT
/* enable spi, set master and clock modes (f/2) */
_SPCR0 = _BV(_SPE0) | _BV(_MSTR0);
_SPSR0 = _BV(_SPI2X0);
#endif
}
