// obs³u¿ przychodz¹ce dane na port telnetowy
void telnet_handle_packet(unsigned char* data, unsigned int len) {
// komenda telnetowa - IAC?
if (data[0] == TELNET_IAC) {
// typ komendy
switch(data[1]) {
// Are You There?
case TELNET_AYT:
len = 0;
// dodaj nazwê urz¹dzenia nadan¹ przez u¿ytkownika
strcpy((char*)data, config_get()->name);
len += strlen(config_get()->name);
data[len++] = ' ';
data[len++] = '|';
data[len++] = ' ';
// sygnatura urz¹dzenia
memcpy_P(data+len, RS2ETH_SIGNATURE, strlen_P(RS2ETH_SIGNATURE));
len += strlen_P(RS2ETH_SIGNATURE);
data[len++] = 0x0D; // \r
data[len++] = 0x0A; // \n
uip_send(data, len);
break;
// negocjacja podopcji
case TELNET_SB:
// podopcja dla portu COM
if (data[2] == TELNET_COM_SB) {
if (telnet_handle_com_negotiation((data+3), len-3)) {
uip_send(data, len);
}
}
break;
// przeœlij znak 0xFF
case TELNET_IAC:
rs_send(0xFF);
break;
}
}
// dane -> przeœlij na port COM
else {
if (len > 0) {
LED_ON(LED_TX);
}
for (; len > 0; len--) {
rs_send(*(data++));
}
}
}
static int send_xfer(int size)
{
struct pollfd fds;
int offset, ret;
if (verify)
format_buf(buf, size);
if (use_async) {
fds.fd = rs;
fds.events = POLLOUT;
}
for (offset = 0; offset < size; ) {
if (use_async) {
ret = do_poll(&fds, poll_timeout);
if (ret)
return ret;
}
ret = rs_send(rs, buf + offset, size - offset, flags);
if (ret > 0) {
offset += ret;
} else if (errno != EWOULDBLOCK && errno != EAGAIN) {
perror("rsend");
return ret;
}
}
return 0;
}
void daq_pooling() {
daq_interval++;
// jeszcze / ju¿ nie teraz
if ( (daq_interval < daq_task.interval) || (daq_task.samples == 0) )
return;
// dokonaj odczytu z kana³u <ch>
signed int readout = ds_temp[daq_task.ch];
// debug
rs_send('D'); rs_int(readout); rs_newline();
// zapisz do pliku
fs_write(&(daq_task.fp), (unsigned char*)&readout, sizeof(signed int));
daq_interval = 0;
daq_task.samples--;
// zakoñczono zadanie
if (daq_task.samples == 0) {
rs_text_P(PSTR("DAQ: zakonczono rejestracje do pliku '")); rs_text((char*)(daq_task.fp.name)); rs_send('\''); rs_newline();
fs_close(&(daq_task.fp));
}
}
unsigned int firmware_read_sector(unsigned char sector, unsigned char* buf)
{
unsigned int length, len;
rs_text_P(PSTR("Firmware: czytam sektor #"));
rs_hex(sector);
rs_send(' ');
// pobierz rozmiar danych w sektorze
length = firmware_get_sector_length(sector);
rs_int(length);
rs_send('B');
rs_newline();
// kontrola d³ugoœci pakietu
if (length > FIRMWARE_SECTOR_SIZE)
return 0;
// pierwsza strona w danym sektorze
unsigned int page = sector * FIRMWARE_SECTOR_SIZE;
len = length;
while (len > 0) {
// czytaj po stronie pamieci (po 256 bajtow)
eeprom_page_read(page, buf, (len > 255 ? 255 : len));
//rs_dump(buf, 255);
// przesun wskaznik docelowy dla danych
buf += 255;
len -= (len > 255 ? 255 : len);
page += 0x0100;
}
//rs_text_P(PSTR("Returned -> ")); rs_int(length); rs_send('B'); rs_newline();
return length;
}
// Empfangenes Telegramm verarbeiten
void write_value_req(void)
{
unsigned char length,n=0;
unsigned int ga;
unsigned int val=0;
eibledcount=0xff;// EIBLED lang einschalten
length=telegramm[5]&0x0F;
if (length<=15 ) {// wenn ein Telegramm reinkommt..
if(length==1)val=telegramm[7] & 0x3F;
if(length==2)val=telegramm[8] ;
if(length==3)val=256*telegramm[8]+telegramm[9];
ga=256*telegramm[3]+telegramm[4];
if(filtermode){
for(n=0;n<=61;n++) { // Wert der GA aus Flash lesen
if(ga_db[n].ga==ga) {
n=63;
}
}
}
if ((n>=63 || !filtermode)) {
if(!tel_sent){
rs_send_dec(telegramm[3]>>3); // GA senden
rs_send('/');
rs_send_dec(telegramm[3] & 0x07);
rs_send('/');
rs_send_dec(telegramm[4]);
rs_send('=');
if (length<=3) rs_send_dec(val); // Value senden
if(length==4){
n='.';
if(telegramm[8]>31){// time
rs_send((telegramm[8]>>5)+'0');
rs_send(',');
n=':';
}
rs_send_dec(telegramm[8]&0x1F);
rs_send(n);
rs_send_dec(telegramm[9]);
rs_send(n);
rs_send_dec(telegramm[10]);
}
if(length>4){
for(n=8;n <= length+6;n++){
rs_send(telegramm[n]);
}
}
rs_send_s("\n"); // CR LF
//rs_send(10);
}
unsigned int daq_start(char* name, unsigned char ch, unsigned int interval, unsigned int samples) {
// trwa ju¿ inne zadanie akwizycji - poczekaj na jego zakoñczenie
if (daq_task.samples > 0) {
return 0;
}
// dalsze sprawdzenie poprawnoœci parametrów
if ( (ch >= ds_devices_count) || (interval < 1) || (interval > 3600) || (samples < 1) || (samples > 200) || !strlen(name) ) {
return 0;
}
// utwórz plik na wyniki pomiarów
if (!fs_open(&(daq_task.fp), (unsigned char*)name, 0) || daq_task.fp.size > 0) {
return 0;
}
// kopiuj dane do struktury zadania DAQ
memcpy((void*)daq_task.name, (void*)name, strlen(name));
daq_task.ch = ch;
daq_task.interval = interval;
daq_task.samples = samples;
//
// funkcja daq_pooling() dokonuje od teraz okresowego (co <interval> sekund) pomiaru <samples> próbek
//
rs_text_P(PSTR("DAQ: rozpoczeto rejestracje do pliku ")); rs_text((char*)(daq_task.fp.name)); rs_send('\''); rs_newline();
return 1;
}
unsigned int daq_handle_packet(unsigned char* data) {
unsigned int len = 0;
rs_text_P(PSTR("Pakiet DAQ: ")); rs_send(data[0]); rs_send(data[1]); rs_newline();
// rozdzielaj zadania
switch(data[0]) {
// informacje o systemie
case DAQ_CMD_INFO:
strcpy_P((char*)data, PROGRAM_NAME); len += strlen_P(PROGRAM_NAME);
data[len++] = ' ';
strcpy_P((char*)data+len, PROGRAM_VERSION1); len += strlen_P(PROGRAM_VERSION1);
data[len++] = ' ';
strcpy_P((char*)data+len, PROGRAM_VERSION2); len += strlen_P(PROGRAM_VERSION2);
return len;
break;
// liczba czujników temperatury
case DAQ_CMD_COUNT_SENSORS:
// little endian - intel / avr
data[0] = ds_devices_count;
data[1] = 0;
return 2;
break;
// odczyt danych
case DAQ_CMD_READ:
switch(data[1]) {
// odczyt temperatury
case DAQ_CMD_READ_TEMPERATURE:
return daq_read_temperature(data);
// wype³nienia kana³ów PWM
case DAQ_CMD_READ_PWM_FILL:
for (len=0; len < PWM_CHANNELS; len++) {
data[len] = pwm_get_fill(len);
}
return PWM_CHANNELS * sizeof(unsigned char);
}
break;
// zapis danych
case DAQ_CMD_SET:
switch(data[1]) {
// ustawienie wype³nienia kana³u PWM
case DAQ_CMD_SET_PWM_FILL:
pwm_set_fill( (data[2]-'0') % PWM_CHANNELS, atoi( (char*)data+3) );
return 0;
}
break;
}
// zwróæ informacjê o b³êdzie
data[0] = 'e';
data[1] = 'r';
data[2] = 'r';
return 3;
}
unsigned int firmware_handle_packet(unsigned char* data)
{
firmware_packet *packet = (firmware_packet*) data;
rs_text_P(PSTR("Firmware: offset "));
rs_hex( packet->offset >> 16);
rs_hex( packet->offset >> 8);
rs_hex( packet->offset);
rs_send(' ');
rs_send('#');
rs_hex(packet->op);
switch (packet->op) {
// pakiet z danymi strony do wgrania do pamieci
case FIRMWARE_OP_SEND:
// na poczatku aktualizacji wyczysc cala pamiec
if (packet->offset == 0L) {
eeprom_enable_write(1);
eeprom_chip_erase();
}
// wlacz zapis do pamieci EEPROM
eeprom_enable_write(1);
// zapisz dane do pamieci
eeprom_page_write(packet->offset, packet->data, packet->len);
//rs_dump(packet->data, packet->len);
// odsylamy pakiet z potwierdzeniem wgrania danych
packet->op = FIRMWARE_OP_SEND_OK;
return 6 + packet->len;
// weryfikacja danych (odeslij zawartosci podanej strony)
case FIRMWARE_OP_VERIFY:
// pobierz cala strone
packet->len = 255;
// pobierz dane
eeprom_page_read(packet->offset, packet->data, packet->len);
//rs_dump(packet->data, packet->len+1);
// odsylamy pakiet z danymi z pamieci (skrypt aktualizujacy dokona porownania)
return 6 + packet->len + 1;
// pakiet z blednym kodem operacji
default:
packet->op = 0;
packet->offset = 0UL;
packet->len = 0;
return 6;
}
return 0;
}
