static int TestTelegram(TBusTelegram *pTxMsg, uint8_t msgSize) { TBusTelegram *pRxMsg = BusMsgBufGet(); int timeout; uint8_t zerobuf[sizeof(TBusTelegram)]; memset(zerobuf, 0, sizeof(zerobuf)); memset(pRxMsg, 0, sizeof(*pRxMsg)); if (BusSend(pTxMsg) != BUS_SEND_OK) { return -1; } for (timeout = 0; (timeout < RX_TIMEOUT) && (BusCheck() != BUS_MSG_OK); timeout++) { usleep(1000); } if (timeout < RX_TIMEOUT) { if (memcmp(pTxMsg, pRxMsg, msgSize) != 0) { return -1; } if (memcmp((uint8_t *)pRxMsg + msgSize, zerobuf, sizeof(TBusTelegram) - msgSize) != 0) { return -1; } } else { return -1; } return 0; }
/*----------------------------------------------------------------------------- * main */ int main(void) { uint8_t ret; int sioHdl; /* set clock prescaler to 2 (set clock to 7.3928 MHz) */ CLKPR = 1 << CLKPCE; CLKPR = 1; /* get module address from EEPROM */ sMyAddr = eeprom_read_byte((const uint8_t *)MODUL_ADDRESS); GetClientListFromEeprom(); PortInit(); TimerInit(); ButtonInit(); PwmInit(); ApplicationInit(); SioInit(); SioRandSeed(sMyAddr); /* sio for bus interface */ sioHdl = SioOpen("USART1", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sioHdl, IdleSio1); SioSetTransceiverPowerDownFunc(sioHdl, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sioHdl); spBusMsg = BusMsgBufGet(); /* warten for full operation voltage */ while (!POWER_GOOD); /* enable ints before RestorePwm() */ ENABLE_INT; TimerStart(); RestorePwm(); /* ext int for power fail: INT0 low level sensitive */ EICRA &= ~((1 << ISC01) | (1 << ISC00)); EIMSK |= (1 << INT0); ApplicationStart(); /* Hauptschleife */ while (1) { Idle(); ret = BusCheck(); ProcessBus(ret); CheckButton(); PwmCheck(); ApplicationCheck(); CheckEvent(); } return 0; }
/*----------------------------------------------------------------------------- * program start */ int main(void) { int sioHandle; uint8_t windThreshold1; uint8_t windThreshold2; MCUSR = 0; wdt_disable(); /* get module address from EEPROM */ sMyAddr = eeprom_read_byte((const uint8_t *)MODUL_ADDRESS); windThreshold1 = eeprom_read_byte((const uint8_t *)WIND_THRESHOLD1); windThreshold2 = eeprom_read_byte((const uint8_t *)WIND_THRESHOLD2); GetClientListFromEeprom(); PortInit(); TimerInit(); SioInit(); sioHandle = SioOpen("USART0", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sioHandle, IdleSio); SioSetTransceiverPowerDownFunc(sioHandle, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sioHandle); spRxBusMsg = BusMsgBufGet(); /* enable global interrupts */ ENABLE_INT; SendStartupMsg(); /* wait for controller startup delay for sending first state telegram */ DELAY_S(STARTUP_DELAY); while (1) { Idle(); ProcessSwitch(); ProcessBus(); if (sWind >= windThreshold1) { sWindSwitch |= 0x01; } else { sWindSwitch &= ~0x01; } if (sWind >= windThreshold2) { sWindSwitch |= 0x02; } else { sWindSwitch &= ~0x02; } } return 0; /* never reached */ }
/*----------------------------------------------------------------------------- * init bus communication */ static void InitComm(void) { SioInit(); SioRandSeed(sMyAddr); sSioHandle = SioOpen("USART0", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sSioHandle, IdleSio); SioSetTransceiverPowerDownFunc(sSioHandle, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sSioHandle); spRxBusMsg = BusMsgBufGet(); }
/*----------------------------------------------------------------------------- * program start */ int main(int argc, char *argv[]) { int i; int j; char comPort[SIZE_COMPORT] = ""; uint8_t myAddr; bool myAddrValid = false; TBusTelegram txBusMsg; uint8_t busRet; TBusTelegram *pRxBusMsg; uint8_t mask; int flags; int sioHandle; int sioFd; fd_set rfds; int ret; uint8_t val8; char buffer[SIZE_CMD_BUF]; char *p; signal(SIGPIPE, sighandler); flags = fcntl(fileno(stdout), F_GETFL); fcntl(fileno(stdout), F_SETFL, flags | O_NONBLOCK); /* get com interface */ for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-c") == 0) { if (argc > i) { strncpy(comPort, argv[i + 1], sizeof(comPort) - 1); comPort[sizeof(comPort) - 1] = '\0'; } break; } } /* our bus address */ for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-a") == 0) { if (argc > i) { myAddr = atoi(argv[i + 1]); myAddrValid = true; } break; } } if ((strlen(comPort) == 0) || !myAddrValid) { PrintUsage(); return 0; } sioHandle = InitBus(comPort); if (sioHandle == -1) { printf("cannot open %s\r\n", comPort); return -1; } sioFd = SioGetFd(sioHandle); for (;;) { FD_ZERO(&rfds); FD_SET(sioFd, &rfds); FD_SET(STDIN_FILENO, &rfds); ret = select(sioFd + 1, &rfds, 0, 0, 0); if ((ret > 0) && FD_ISSET(sioFd, &rfds)) { busRet = BusCheck(); if (busRet == BUS_MSG_OK) { pRxBusMsg = BusMsgBufGet(); if ((pRxBusMsg->type == eBusDevReqActualValueEvent) && ((pRxBusMsg->msg.devBus.receiverAddr == myAddr))) { Print("event address %d device type ", pRxBusMsg->senderAddr); switch (pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.devType) { case eBusDevTypeDo31: Print("DO31\n"); for (i = 0; i < BUS_DO31_DIGOUT_SIZE_ACTUAL_VALUE; i++) { for (j = 0, mask = 1; j < 8; j++, mask <<= 1) { if ((i == 3) && (j == 7)) { // DO31 has 31 outputs, dont display the last bit break; } if (pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.actualValue.do31.digOut[i] & mask) { Print("1"); } else { Print("0"); } } } Print("\n"); for (i = 0; i < BUS_DO31_SHADER_SIZE_ACTUAL_VALUE; i++) { Print("%02x", pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.actualValue.do31.shader[i]); if (i < (BUS_DO31_SHADER_SIZE_ACTUAL_VALUE - 1)) { Print(" "); } } memcpy(txBusMsg.msg.devBus.x.devResp.actualValueEvent.actualValue.do31.digOut, pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.actualValue.do31.digOut, BUS_DO31_DIGOUT_SIZE_ACTUAL_VALUE); memcpy(txBusMsg.msg.devBus.x.devResp.actualValueEvent.actualValue.do31.shader, pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.actualValue.do31.shader, BUS_DO31_SHADER_SIZE_ACTUAL_VALUE); txBusMsg.msg.devBus.x.devResp.actualValueEvent.devType = eBusDevTypeDo31; break; case eBusDevTypeSw8: Print("SW8\n"); val8 = pRxBusMsg->msg.devBus.x.devReq.actualValueEvent.actualValue.sw8.state; for (i = 0, mask = 1; i < 8; i++, mask <<= 1) { if (val8 & mask) { Print("1"); } else { Print("0"); } } txBusMsg.msg.devBus.x.devResp.actualValueEvent.actualValue.sw8.state = val8; txBusMsg.msg.devBus.x.devResp.actualValueEvent.devType = eBusDevTypeSw8; break; default: break; } Print("\n"); fflush(stdout); txBusMsg.type = eBusDevRespActualValueEvent; txBusMsg.senderAddr = pRxBusMsg->msg.devBus.receiverAddr; txBusMsg.msg.devBus.receiverAddr = pRxBusMsg->senderAddr; BusSend(&txBusMsg); } } else if (busRet == BUS_IF_ERROR) { Print("bus interface access error - exiting\n"); break; } } if ((ret > 0) && FD_ISSET(STDIN_FILENO, &rfds)) { p = fgets(buffer, sizeof(buffer), stdin); if (p == 0) { printf("error/EOF on reading from stdin. exiting\n"); ret = -1; break; } if (strcmp("-exit\n", p) == 0) { Print("OK\n"); break; } } } SioClose(sioHandle); return ret; }
/*----------------------------------------------------------------------------- * program start */ int main(void) { int sioHandle; uint8_t i; uint8_t u8; MCUSR = 0; wdt_disable(); /* get module address from EEPROM */ sMyAddr = eeprom_read_byte((const uint8_t *)MODUL_ADDRESS); for (i = 0; i < NUM_BUTTON_EVENT_ADDRESSES; i++) { sMySwitchAddr[i] = eeprom_read_byte((const uint8_t *)(BUTTON_EVENT_ADRESS_BASE + i)); } PortInit(); TimerInit(); SioInit(); SioRandSeed(MY_ADDR); sioHandle = SioOpen("USART0", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sioHandle, IdleSio); SioSetTransceiverPowerDownFunc(sioHandle, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sioHandle); spRxBusMsg = BusMsgBufGet(); /* enable global interrupts */ ENABLE_INT; i2c_slave(SLAVE_ADRESSE); button_register = 0; init_BJ(SLAVE_ADRESSE); for (i = 0; i < NR_OF_LEDS; i++) { u8 = eeprom_read_byte((const uint8_t *)(COLOR_LED_BASE + i)); set_LED(i, u8); sNewLedData[i / 2] |= (u8 & 0x0f) << ((i % 2) ? 4 : 0); } i2c_slave(SLAVE_ADRESSE); SendStartupMsg(); while (1) { Idle(); if (send_startup == 1) { init_BJ(SLAVE_ADRESSE); for (i = 0; i < NR_OF_LEDS; i++) { set_LED(i, eeprom_read_byte((const uint8_t *)(COLOR_LED_BASE + i))); } } sInputState = button_register; ProcessButton(sInputState); ProcessBus(); for (i = 0; i < BUS_SW16_LED_SIZE_SET_VALUE; i++) { if ((sNewLedData[i] & 0x0f) != (sLedData[i] & 0x0f) ) { // linke LED set_LED(i * 2, sNewLedData[i] & 0x0f); i2c_slave(SLAVE_ADRESSE); } if ((sNewLedData[i] & 0xf0) != (sLedData[i] & 0xf0) ) { // rechte LED set_LED(i * 2 + 1, (sNewLedData[i] & 0xf0) >> 4); i2c_slave(SLAVE_ADRESSE); } sLedData[i] = sNewLedData[i]; } }
/*----------------------------------------------------------------------------- * program start */ int main(void) { UINT8 ret; UINT16 flashWordAddr; UINT16 sum; cli(); MCUSR = 0; wdt_disable(); /* get oscillator correction value from EEPROM */ EEAR = OSCCAL_CORR; /* Start eeprom read by writing EERE */ EECR |= (1 << EERE); /* read data */ OSCCAL += EEDR; /* get modul adress from EEPROM */ EEAR = MODUL_ADDRESS; /* Start eeprom read by writing EERE */ EECR |= (1 << EERE); /* read data */ sMyAddr = EEDR; /* configure pins to input with pull up */ PORTB = 0b11111111; DDRB = 0b00000000; PORTC = 0b11111111; DDRC = 0b00000000; PORTD = 0b11111111; DDRD = 0b00100010; /* configure Timer 0 */ /* prescaler clk/64 -> Interrupt period 256/1000000 * 64 = 16.384 ms */ TCCR0B = 3 << CS00; TIMSK0 = 1 << TOIE0; SioInit(); spRxBusMsg = BusMsgBufGet(); /* Enable change of Interrupt Vectors */ MCUCR = (1 << IVCE); /* Move interrupts to Boot Flash section */ MCUCR = (1 << IVSEL); /* Prüfsumme der Applikation berechnen */ sum = 0; for (flashWordAddr = 0; flashWordAddr < (MAX_FIRMWARE_SIZE / 2); flashWordAddr += CHECKSUM_BLOCK_SIZE) { sum += FlashSum(flashWordAddr, (UINT8)CHECKSUM_BLOCK_SIZE); } if (sum != FLASH_CHECKSUM) { /* Fehler */ sFwuState = WAIT_FOR_UPD_ENTER; } sei(); /* Startup-Msg senden */ sTxBusMsg.type = eBusDevStartup; sTxBusMsg.senderAddr = MY_ADDR; BusSend(&sTxBusMsg); SioReadFlush(); /* Hauptschleife */ while (1) { ret = BusCheck(); ProcessBus(ret); /* Mit timeout auf Request zum Firmwareupdate warten */ if (sFwuState == WAIT_FOR_UPD_ENTER_TIMEOUT) { if (gTimeS8 >= 4) { /* Application starten */ break; } } } cli(); /* Enable change of Interrupt Vectors */ MCUCR = (1 << IVCE); /* Move interrupts to application section */ MCUCR = (0 << IVSEL); /* jump to application */ ApplicationEntry(); /* never reach this */ return 0; }
/*----------------------------------------------------------------------------- * program start */ int main(void) { int sioHandle; uint8_t inputState; MCUSR = 0; wdt_disable(); /* get module address from EEPROM */ sMyAddr = eeprom_read_byte((const uint8_t *)MODUL_ADDRESS); sInputType = eeprom_read_byte((const uint8_t *)INPUT_TYPE); if (sInputType > INPUT_TYPE_MOTION_DETECTOR) { sInputType = INPUT_TYPE_DUAL_BUTTON; } PortInit(); TimerInit(); SioInit(); SioRandSeed(sMyAddr); sioHandle = SioOpen("USART0", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sioHandle, IdleSio); SioSetTransceiverPowerDownFunc(sioHandle, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sioHandle); spRxBusMsg = BusMsgBufGet(); /* enable global interrupts */ ENABLE_INT; SendStartupMsg(); if ((sInputType == INPUT_TYPE_DUAL_SWITCH) || (sInputType == INPUT_TYPE_MOTION_DETECTOR)) { /* wait for controller startup delay for sending first state telegram */ DELAY_S(STARTUP_DELAY); } if ((sInputType == INPUT_TYPE_DUAL_SWITCH) || (sInputType == INPUT_TYPE_MOTION_DETECTOR)) { inputState = GetInputState(); sSwitchStateOld = ~inputState; ProcessSwitch(inputState); } while (1) { Idle(); inputState = GetInputState(); if ((sInputType == INPUT_TYPE_DUAL_SWITCH) || (sInputType == INPUT_TYPE_MOTION_DETECTOR)) { ProcessSwitch(inputState); } else if (sInputType == INPUT_TYPE_DUAL_BUTTON) { ProcessButton(inputState); } ProcessBus(); } return 0; /* never reached */ }
/*----------------------------------------------------------------------------- * Programstart */ int main(void) { UINT8 ret; UINT16 flashWordAddr; UINT16 sum; /* get oscillator correction value from EEPROM */ EEAR = OSCCAL_CORR; /* Start eeprom read by writing EERE */ EECR |= (1 << EERE); /* read data */ OSCCAL += EEDR; /* get modul adress from EEPROM */ EEAR = MODUL_ADDRESS; /* Start eeprom read by writing EERE */ EECR |= (1 << EERE); /* read data */ sMyAddr = EEDR; /* Portpins für Schaltereingänge mit Pullup konfigurieren */ /* nicht benutzte Pin aus Ausgang Low*/ PORTC = 0x03; DDRC = 0x3C; PORTB = 0x38; DDRB = 0xC7; PORTD = 0x01; DDRD = 0xFE; /* configure Timer 0 */ /* prescaler clk/64 -> Interrupt period 256/1000000 * 64 = 16.384 ms */ TCCR0 = 3 << CS00; TIMSK = 1 << TOIE0; SioInit(); spRxBusMsg = BusMsgBufGet(); /* Umschaltung der Interruptvektor-Tabelle */ GICR = (1 << IVCE); /* In Bootbereich verschieben */ GICR = (1 << IVSEL); /* Prüfsumme der Applikation berechnen */ sum = 0; for (flashWordAddr = 0; flashWordAddr < (MAX_FIRMWARE_SIZE / 2); flashWordAddr += CHECKSUM_BLOCK_SIZE) { sum += FlashSum(flashWordAddr, (UINT8)CHECKSUM_BLOCK_SIZE); } if (sum != FLASH_CHECKSUM) { /* Fehler */ sFwuState = WAIT_FOR_UPD_ENTER; } sei(); /* Startup-Msg senden */ sTxBusMsg.type = eBusDevStartup; sTxBusMsg.senderAddr = MY_ADDR; BusSend(&sTxBusMsg); SioReadFlush(); /* Hauptschleife */ while (1) { ret = BusCheck(); ProcessBus(ret); /* Mit timeout auf Request zum Firmwareupdate warten */ if (sFwuState == WAIT_FOR_UPD_ENTER_TIMEOUT) { if (gTimeS8 >= 4) { /* Application starten */ break; } } } cli(); /* Umschaltung der Interruptvektor-Tabelle */ GICR = (1 << IVCE); /* In Applikationsbereich verschieben */ GICR = (0 << IVSEL); /* zur Applikation springen */ ApplicationEntry(); /* hier kommen wir nicht her!!*/ return 0; }
/*----------------------------------------------------------------------------- * main */ int main(int argc, char *argv[]) { int handle; int i; char comPort[SIZE_COMPORT] = ""; uint8_t len; uint8_t val8; /* get tty device */ for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-c") == 0) { if (argc > i) { strncpy(comPort, argv[i + 1], sizeof(comPort) - 1); comPort[sizeof(comPort) - 1] = 0; } break; } } if (strlen(comPort) == 0) { PrintUsage(); return 0; } SioInit(); handle = SioOpen(comPort, eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); if (handle == -1) { printf("can't open %s\r\n", comPort); return 0; } // wait for sio input to settle and the flush usleep(100000); while ((len = SioGetNumRxChar(handle)) != 0) { SioRead(handle, &val8, sizeof(val8)); } BusInit(handle); #if 1 BusVarInit(67, BusVarNv); { uint8_t var1 = 1; uint16_t var2 = 0x1234; bool rc; uint8_t len; TBusVarHdl hdl1; TBusVarHdl hdl2; TBusTelegram *msg; TBusVarResult result; TBusVarState state; BusVarAdd(0, sizeof(var1), true); BusVarAdd(1, sizeof(var2), false); rc = BusVarWrite(1, &var2, sizeof(var2), &result); rc = BusVarWrite(0, &var1, sizeof(var1), &result); var1 = 0; var2 = 0; len = BusVarRead(1, &var2, sizeof(var2), &result); printf("len %d var2 %x\n", len, var2); len = BusVarRead(0, &var1, sizeof(var1), &result); printf("len %d var1 %x\n", len, var1); hdl2 = BusVarTransactionOpen(242, 1, &var2, sizeof(var2), eBusVarRead); hdl1 = BusVarTransactionOpen(242, 0, &var1, sizeof(var1), eBusVarRead); for (i = 0; i < 1000; i++) { BusVarProcess(); usleep(10000); if (BusCheck() == BUS_MSG_OK) { msg = BusMsgBufGet(); if ((msg->type == eBusDevRespGetVar) && (msg->msg.devBus.receiverAddr == 67)) { BusVarRespGet(msg->senderAddr, &msg->msg.devBus.x.devResp.getVar); } } if (hdl1 != BUSVAR_HDL_INVALID) { state = BusVarTransactionState(hdl1); if (state & BUSVAR_STATE_FINAL) { if (state == eBusVarState_Ready) { printf("var1 %02x\n", var1); } BusVarTransactionClose(hdl1); hdl1 = BUSVAR_HDL_INVALID; } } if (hdl2 != BUSVAR_HDL_INVALID) { state = BusVarTransactionState(hdl2); if (state & BUSVAR_STATE_FINAL) { if (state == eBusVarState_Ready) { printf("var2 %04x\n", var2); } BusVarTransactionClose(hdl2); hdl2 = BUSVAR_HDL_INVALID; } } } } return 0; #endif if (Test() == 0) { printf("OK\n"); } else { printf("ERROR\n"); } if (handle != -1) { SioClose(handle); } return 0; }