char loop(struct rtimer* t, void *ptr){
PT_BEGIN(&pt);
uint8_t packet[TIMESTAMP_BIT];
int packet_len = 0;
sclock_init(&sclk, TYPE_CLOCK);
ntp_init(&ntp, &sclk);
static struct timestamp second;
timestamp_init(&second);
second.sec = 1;
while(1) {
sclock_etimer_set(&sclk, &et, &second);
PT_YIELD_UNTIL(&pt,etimer_expired(&et));
leds_invert(LEDS_RED);
#if REQUEST
packet_len = ntp_make_request(&ntp, packet);
packetbuf_copyfrom(packet, packet_len);
abc_send(&abc);
#endif
}
PT_END(&pt);
}
static void
ip_initialized(void)
{
network_set_led(0x476);// LED A: Link Status LED B: TX/RX
tcplink_init();
ntp_init();
#ifdef HAS_MDNS
mdns_init();
#endif
}
void
ntp_send_packet(void)
{
#ifdef DNS_SUPPORT
if (++ntp_tries >= 5) {
#ifdef DEBUG_NTP
debug_printf("NTP ntp_send_packet: re-init after %d unsuccessful tries\n", ntp_tries);
#endif
ntp_init();
return;
}
#endif
if (ntp_conn == NULL || ntp_conn->ripaddr == NULL) {
#ifdef DEBUG_NTP
debug_printf("NTP ntp_send_packet: skip send, ntp not initialized\n");
#endif
return;
}
/* LLH len defined in UIP depending on stacks (i.e. 14 for ethernet frame),
may be already suitable for tunneling! */
struct ntp_packet *pkt = (void *) &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
uip_slen = sizeof(struct ntp_packet);
memset(pkt, 0, uip_slen);
pkt->li_vn_mode = 0xe3; /* Clock not synchronized, Version 4, Client Mode */
pkt->ppoll = 12; /* About an hour */
pkt->precision = 0xfa; /* 0.015625 seconds */
pkt->rootdelay = HTONL(0x10000); /* 1 second */
pkt->rootdispersion = HTONL(0x10000); /* 1 second */
/* push the packet out ... */
uip_udp_conn = ntp_conn;
uip_process(UIP_UDP_SEND_CONN);
#ifdef DEBUG_NTP
debug_printf("NTP: send packet\n");
#endif
router_output();
uip_slen = 0;
}
int main(int argc, char *argv[])
{
if (parse_options(argc, argv) == -1)
{
fprintf(stderr, "Failed parse options\n");
return 1;
}
if (gpio == -1)
{
fprintf(stderr, "Invalid GPIO number %d\n", gpio);
return 1;
}
void *ntp_data = ntp_init(ntp_unit);
recv_timecode(gpio, ntp_data);
return 0;
}
int luaopen_ntp(lua_State *L)
{
ntp_init();
luaL_register(L, "ntp", mylib);
return 1;
}
static int l_clear()
{
ntp_init();
return 0;
}
int main(void)
{
//Konfiguration der Ausgänge bzw. Eingänge
//definition erfolgt in der config.h
DDRA = OUTA;
#if USE_SER_LCD
DDRC = OUTC;
#else
DDRC = OUTC;
#if PORTD_SCHALT
DDRD = OUTD;
#endif
#endif
// RoBue:
// Pullups einschalten
PORTA = (1 << PORTA0) | (1 << PORTA1) | (1 << PORTA2) | (1 << PORTA3) | (1 << PORTA4) | (1 << PORTA5) | (1 << PORTA6);
unsigned long a;
#if USE_SERVO
servo_init ();
#endif //USE_SERVO
usart_init(BAUDRATE); // setup the UART
#if USE_ADC
ADC_Init();
#endif
usart_write("\n\rSystem Ready\n\r");
usart_write("Compiliert am "__DATE__" um "__TIME__"\r\n");
usart_write("Compiliert mit GCC Version "__VERSION__"\r\n");
for(a=0;a<1000000;a++){asm("nop");};
//Applikationen starten
stack_init();
httpd_init();
telnetd_init();
//Spielerrei mit einem LCD
#if USE_SER_LCD
udp_lcd_init();
lcd_init();
// RoBue:
// LCD-Ausgaben:
lcd_clear();
lcd_print(0,0,"*AVR-NET-IO "Version"*");
lcd_print(2,0,"Counter: ");
lcd_print(3,0,"Zeit:");
#endif
//Ethernetcard Interrupt enable
ETH_INT_ENABLE;
#if USE_SER_LCD
// RoBue:
// IP auf LCD
lcd_print(1,0,"%1i.%1i.%1i.%1i",myip[0],myip[1],myip[2],myip[3]);
#endif
//Globale Interrupts einschalten
sei();
#if USE_CAM
#if USE_SER_LCD
lcd_print(1,0,"CAMERA INIT");
#endif //USE_SER_LCD
for(a=0;a<2000000;a++){asm("nop");};
cam_init();
max_bytes = cam_picture_store(CAM_RESELUTION);
#if USE_SER_LCD
back_light = 0;
lcd_print(1,0,"CAMERA READY");
#endif //USE_SER_LCD
#endif // -> USE_CAM
#if USE_NTP
ntp_init();
ntp_request();
#endif //USE_NTP
#if USE_WOL
wol_init();
#endif //USE_WOL
#if USE_MAIL
mail_client_init();
#endif //USE_MAIL
// Startwerte für ow_array setzen
#if USE_OW
uint8_t i = 0;
for (i=0;i<MAXSENSORS;i++){
ow_array[i]=OW_START;
}
for (i=MAXSENSORS;i<MAXSENSORS*3;i++){
ow_array[i]=OW_MINMAX;
}
DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL );
for(a=0;a<1000000;a++){asm("nop");};
auslesen = 0;
minmax = 1;
#endif
//Hauptschlfeife
// *************
while(1)
{
#if USE_ADC
ANALOG_ON;
#endif
eth_get_data();
//Terminalcommandos auswerten
if (usart_status.usart_ready){
usart_write("\r\n");
if(extract_cmd(&usart_rx_buffer[0]))
{
usart_write("Ready\r\n\r\n");
}
else
{
usart_write("ERROR\r\n\r\n");
}
usart_status.usart_ready =0;
}
// RoBue:
// Counter ausgeben
#if USE_SER_LCD
lcd_print(2,9,"%4i",var_array[MAX_VAR_ARRAY-1]);
#endif
// RoBue:
// Uhrzeit bestimmen und auf LCD ausgeben
hh = (time/3600)%24;
mm = (time/60)%60;
ss = time%60;
#if USE_SER_LCD
lcd_print(3,7,"%2i:%2i:%2i",hh,mm,ss);
#endif
#if USE_HIH4000
var_array[VA_OUT_HIH4000] = ((var_array[VA_IN_HIH4000]-160)/6);
#endif
#if USE_OW
// RoBue:
// Zurücksetzen der Min/Max-Werte um 00:00 Uhr einschalten
if (( hh == 00 )&&( mm == 00 )) {
minmax = 1;
}
#endif
// ******************************************************************
// RoBue:
// 1-Wire-Temperatursensoren (DS18B20) abfragen
// ******************************************************************
#if USE_OW
uint8_t i = 0;
uint8_t subzero, cel, cel_frac_bits;
uint8_t tempID[OW_ROMCODE_SIZE];
// Messen bei ss=5,15,25,35,45,55
if ( ss%10 == 5 ) {
// Messen?
if ( messen == 1 ) {
// RoBue Anmerkung:
// Hiermit werden ALLE Sensoren zum Messen aufgefordert.
// Aufforderung nur bestimmter Sensoren:
// "NULL" durch "tempID" ersetzen
// RoBue Testausgabe UART:
// usart_write("Starte Messvorgang ...\r\n");
DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL );
// Kein Messen mehr bis ss=5,15,25,35,45,55
messen = 0;
// Jetzt kann ausgelesen werden
auslesen = 1;
} // -> if messen
} // -> if ss
// Auslesen bei ss=8,18,28,38,48,58
if ( ss%10 == 8 ) {
// Auslesen?
if ( auslesen == 1 ) {
// (erste) ID ins RAM holen
memcpy_P(tempID,DS18B20IDs[0],OW_ROMCODE_SIZE);
while ( tempID[0] != 0 ) {
//while ( tempID[0] == 0x10 ) {
// RoBue Anmerkung:
// Hiermit wird jeweils ein einzelner Sensor ausgelesen
// und die Temperatur in ow_array abgelegt.
// Achtung:
// Pro Sekunde können max. ca. 10 Sensoren ausgelesen werden!
if ( DS18X20_read_meas( tempID, &subzero,&cel, &cel_frac_bits) == DS18X20_OK ) {
ow_array[i] = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
// Minuswerte:
if ( subzero )
ow_array[i] *= (-1);
// min/max:
if ( minmax == 1 ) {
// Zurücksetzen der Min/Max_Werte 1x/Tag
// auf die gerade aktuellen Temperaturen
ow_array[i+MAXSENSORS] = ow_array[i];
ow_array[i+MAXSENSORS*2] = ow_array[i];
}
else {
// Abgleich der Temp. mit den gespeicherten Min/Max-Werten
if (ow_array[i] < ow_array[i+MAXSENSORS])
ow_array[i+MAXSENSORS] = ow_array[i];
if (ow_array[i] > ow_array[i+MAXSENSORS*2])
ow_array[i+MAXSENSORS*2] = ow_array[i];
}
//TWert = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
//ow_array[i] = TWert;
// RoBue:
// Testausgabe UART:
// usart_write("%2i:%2i:%2i: Temperatur: %3i Grad\r\n",hh,mm,ss,ow_array[i]/10);
} // -> if
else {
usart_write("\r\nCRC Error (lost connection?) ");
DS18X20_show_id_uart( tempID, OW_ROMCODE_SIZE );
} // -> else
// nächste ID ins RAM holen
memcpy_P(tempID,DS18B20IDs[++i],OW_ROMCODE_SIZE);
} // -> while
// RoBue:
// Temperatur auf LCD ausgeben (IP von Startausgabe (s.o.) wird Überschrieben)
#if USE_SER_LCD
lcd_print(1,0,"Tmp: ");
lcd_print(1,5,"%i C",ow_array[0]/10);
lcd_print(1,11,"%i C",ow_array[1]/10);
#endif
} // -> if auslesen
auslesen = 0; // Auslesen vorläufig abschalten
messen = 1; // Messen wieder ermöglichen
minmax = 0; // Min/Max-Werte vergleichen
} // -> if ss
#endif
// **********************************************************
// RoBue:
// Schalten der Ports (PORTC) durch bestimmte Bedingungen
// - Temperatur (1-Wire -> PORTA7) mit/ohne Lüftungsautomatik
// - digital, analog (-> PORTA0-6)
// - Zeit
// **********************************************************
// Automatik eingeschaltet?
if ( var_array[9] == 1 ) {
if ( ss%10 == 1 ) {
schalten = 1;
}
// Abfrage bei ss =0,10,20,30,40,50
if ( ss%10 == 0 ) {
if ( schalten == 1 ) {
// RoBue Testausgabe UART:
// usart_write("%2i:%2i: Schaltfunktionen testen ...\r\n",hh,mm);
// PORTC0:
// Über Temperatur: var_array[10] - Sensor0
if (( ow_array[0]/10 < var_array[10] ) || ( ow_array[0] < 0 )) {
PORTC |= (1 << PC0); // ein
//
// Über Temperatur: var_array[10] - Sensor0 - PORTA0
// if ((PINA&0b00000001) == 0 ) { // PORTA0: Fenster geschlossen?
// if (( ow_array[0]/10 < var_array[10] ) || ( ow_array[0] < 0 )) {
// PORTC |= (1 << PC0); // ein
// }
// else {
// PORTC &= ~(1 << PC0); // aus
// }
}
else {
PORTC &= ~(1 << PC0); // aus
}
// PORTC1:
// Über Temperatur: var_array[11] - Sensor1
// if (( ow_array[1]/10 < var_array[11] ) || ( ow_array[1] < 0 )) {
// PORTC |= (1 << PC1); // ein
//
// Über Temperatur: var_array[11] - Sensor1 - PORTA1
if ((PINA&0b00000010) == 0 ) { // PORTA1: Fenster geschlossen?
if (( ow_array[1]/10 < var_array[11] ) || ( ow_array[1] < 0 )) {
PORTC |= (1 << PC1); // ein
}
else {
PORTC &= ~(1 << PC1); // aus
}
}
else {
PORTC &= ~(1 << PC1); // aus
}
// PORTC2:
// Über Temperatur: var_array[12] - Sensor2
// if (( ow_array[2]/10 < var_array[12] ) || ( ow_array[2] < 0 )) {
// PORTC |= (1 << PC2); // ein
// Über Temperatur: var_array[12] - Sensor2 - PORTA2
// if ((PINA&0b00000100) == 0 ) { // PORTA2: Fenster geschlossen?
// if (( ow_array[2]/10 < var_array[12] ) || ( ow_array[2] < 0 )) {
// PORTC |= (1 << PC2); // ein
// }
// else {
// PORTC &= ~(1 << PC2); // aus
// }
//}
//else {
// PORTC &= ~(1 << PC2); // aus
//}
// PORTC4:
// Über 2 Temperaturen (Differenz)
// var_array[13] - Sensor3 Vorlauf, Sensor4 Ruecklauf
//
// z.B. Zirkulationspumpe für Warmwasser
// Achtung: Temp. von Sensor3 MUSS höher/gleich sein als Temp. von Sensor4
// Ansonsten laeuft die Pumpe immer
//
if ( (ow_array[3]/10 - ow_array[4]/10) >= var_array[14] ) {
PORTC |= (1 << PC4); // ein
}
else {
PORTC &= ~(1 << PC4); // aus
}
// PORTC6:
// Über Analogwert:
if ( var_array[6] > var_array[18] ) {
PORTC |= (1 << PC6); // ein
}
else {
PORTC &= ~(1 << PC6); // aus
}
// PORTC7:
// Über Zeit: ein/aus
if ( hh == var_array[20] ) {
if ( mm == var_array[21] ) {
PORTC |= (1 << PC7); // ein
}
}
if ( hh == var_array[22] ) {
if ( mm == var_array[23] ) {
PORTC &= ~(1 << PC7); // aus
}
}
schalten = 0; // Vorerst nicht mehr schalten
} // -> schalten == 1
} // -> if ss == ...
} // -> if var_array == 1
//Wetterdaten empfangen (Testphase)
#if GET_WEATHER
http_request ();
#endif
//Empfang von Zeitinformationen
#if USE_NTP
if(!ntp_timer){
ntp_timer = NTP_REFRESH;
ntp_request();
}
#endif //USE_NTP
//Versand von E-Mails
#if USE_MAIL
if (mail_enable == 1)
{
mail_enable = 0;
mail_send();
}
#endif //USE_MAIL
//Rechner im Netzwerk aufwecken
#if USE_WOL
if (wol_enable == 1)
{
wol_enable = 0;
wol_request();
}
#endif //USE_WOL
//USART Daten für Telnetanwendung?
telnetd_send_data();
}
return(0);
}
