Changeset 318 for trunk/Software


Ignore:
Timestamp:
06/07/09 03:21:28 (3 years ago)
Author:
dh8ghh
Message:

FEC in Trunk integriert

Location:
trunk/Software
Files:
19 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Software

  • trunk/Software/FiFiSMSer.c

    r317 r318  
    103103                | (0<<CPHA)     // Leading Edge: Sample 
    104104                | (0<<SPR1)     // SPI Clock 
    105                 | (0<<SPR0);    // SPI Clock : Clock/4 
     105                | (1<<SPR0);    // SPI Clock : Clock/4 //DEBUG 
     106 
     107                SPSR   = (1<<SPI2X);    // SPI Geschwindigkeit 1MHz // DEBUG 
     108 
     109 
    106110 
    107111        // Power-Reduction-Register: 

  • trunk/Software/FiFiSMSer.h

    r132 r318  
    1212 
    1313 
     14//void main(void) __attribute__((OS_Main)); 
    1415int main(void) __attribute__((noreturn)); 
    1516 

  • trunk/Software/Keypad.c

    r310 r318  
    189189                return Keypad_SC_None; 
    190190 
    191         Timer_SetSystemSpeed_Fast(); 
     191        Timer_SetSystemSpeed_Fast(MAIN); 
    192192 
    193193        if (SetupValues.Licht && GLOBALFLAGS.IsPowerOn) 
    … …  
    242242                Keypad_RawScancode = RawCode.w; 
    243243 
    244                 Timer_SetSystemSpeed_Slow(); 
     244                Timer_SetSystemSpeed_Slow(MAIN); 
    245245 
    246246         
    … …  
    413413                return; 
    414414 
    415         Timer_SetSystemSpeed_Fast(); 
     415        Timer_SetSystemSpeed_Fast(KEYPAD_ISR); 
    416416 
    417417        if (SetupValues.Licht && GLOBALFLAGS.IsPowerOn) 
    … …  
    466466                Keypad_RawScancode = RawCode.w; 
    467467 
    468                 Timer_SetSystemSpeed_Slow(); 
     468                Timer_SetSystemSpeed_Slow(KEYPAD_ISR); 
    469469 
    470470                return; 

  • trunk/Software/Makefile

    r255 r318  
    105105        EEPROM.c \ 
    106106        MenuErweitert.c \ 
     107        rs.c 
    107108 
    108109 
    … …  
    713714 
    714715 
     716 
     717 

  • trunk/Software/MenuMain.c

    r249 r318  
    3535{ 
    3636        Screen_ShowMH(); 
    37         return false; 
     37        return true; 
    3838} 
    3939 
    … …  
    116116 
    117117 
    118                         Timer_SetSystemSpeed_Slow(); 
     118                        Timer_SetSystemSpeed_Slow(MAIN); 
    119119                } //endof Atomic 
    120120         

  • trunk/Software/MenuSetup.c

    r317 r318  
    338338        { MS_5  ,Exec_MS_5, GetAddStr_MS_5 }, 
    339339        { MS_6  ,Exec_MS_6, GetAddStr_MS_6 }, 
    340         { MS_7  ,Exec_MS_7, GetAddStr_MS_7 }, 
     340        //{ MS_7        ,Exec_MS_7, GetAddStr_MS_7 }, 
    341341        { MS_8  ,Exec_MS_8, GetAddStr_MS_8 }, 
    342342        { MS_9  ,Exec_MS_9, GetAddStr_MS_9 }, 

  • trunk/Software/Message.h

    r255 r318  
    2828typedef enum MESSAGEFLAGSTYPE 
    2929{ 
    30         MessageFlagsTypeBake, 
    31         MessageFlagsTypeText, 
    32         MessageFlagsTypeBin, 
    33         MessageFlagsTypeAck 
     30        MessageFlagsTypeBake,   // 00 
     31        MessageFlagsTypeText,   // 01 
     32        MessageFlagsTypeBin,    // 02 
     33        MessageFlagsTypeAck     // 03 
    3434} MessageFlagsType_t; 
    3535 
    … …  
    3737typedef enum MESSAGEFLAGSSTATUS 
    3838{ 
    39         MessageFlagStatusGeloescht, 
    40         MessageFlagStatusEntwurf, 
    41         MessageFlagStatusGesendet, 
    42         MessageFlagStatusQueue, 
    43         MessageFlagStatusEmpfangenGelesen, 
    44         MessageFlagStatusEmpfangenUngelesen, 
    45         MessageFlagStatusTxMaxtry, 
     39        MessageFlagStatusGeloescht,             // 00 
     40        MessageFlagStatusEntwurf,               // 01 
     41        MessageFlagStatusGesendet,              // 02 
     42        MessageFlagStatusQueue,                 // 03 
     43        MessageFlagStatusEmpfangenGelesen,      // 04 
     44        MessageFlagStatusEmpfangenUngelesen,    // 05 
     45        MessageFlagStatusTxMaxtry,              // 06 
    4646} MessageFlagsStatus_t; 
    4747 
    … …  
    4949typedef struct  
    5050{ 
    51         uint8_t Status   : 3;           // Richtung und so 
    52         uint8_t Type     : 2;           // Mehr Möglichkeiten für Typ 
    53         uint8_t AllowRepeat   : 1; 
     51        uint8_t Status   : 3;           // Richtung und so              Bit 0-2 
     52        uint8_t Type     : 2;           // Mehr Möglichkeiten für Typ   Bit 3-4 
     53        uint8_t AllowRepeat   : 1;  //                              Bit 5-6 
    5454        uint8_t withFEC : 1;  
    5555        uint8_t OptionalFlag2 : 1;  // k.a. aber das Bit war noch über 

  • trunk/Software/RFM12_LLC.c

    r316 r318  
    11#include <util/crc16.h> 
    22#include <string.h> 
     3#include <util/crc16.h> 
    34 
    45#include "rfm12_llc.h" 
    … …  
    1213#include <eeprom.h> 
    1314#include <avr/pgmspace.h> 
     15#include "rs.h" 
     16#include "timer.h" 
    1417 
    1518volatile RFM12_LLC_buf_t _RFM12_LLC_Txbuf; 
    16 volatile RFM12_LLC_buf_t _RFM12_LLC_Rxbuf; 
    17  
     19volatile RFM12_LLC_bufc_t _RFM12_LLC_Rxbuf; 
    1820 
    1921 
    … …  
    2224        // CRC ausrechnen und lostreten 
    2325        uint16_t crc = 0xFFFF; 
    24         for (uint16_t i = 0; i < (Msg->Header.Laenge + sizeof(MessageHeader_t) +  1); i++) 
     26    char flag_status; 
     27     
     28////    dumppos=0; 
     29     
     30    //flag_status=Msg->Header.Flags.Status;   // Statusflag zwischenspeichern 
     31   // Msg->Header.Flags.Status = 7; 
     32     
     33    Timer_SetSystemSpeed_Fast(0);    // zum CRC berechnen und fürs RS Encoding die Geschwindigkeit erhöhen 
     34     
     35        for (uint16_t i = 0; i < (Msg->Header.Laenge + sizeof(MessageHeader_t)); i++) 
    2536        { 
    2637                uint8_t data = ((uint8_t*)&_RFM12_LLC_Txbuf)[i]; 
    27                 crc = _crc16_update(crc, data); 
     38                crc = crc16_update(crc, data); 
    2839        } 
    29          
     40 
     41    if (SetupValues.FEC!=0){                        // Wenn FEC aktiviert ist 
     42        rs_encode_head(&Msg->Header,g_parity);     // Parity über den Header berechnen 
     43    } 
     44         
    3045        _RFM12_LLC_Txbuf.CRC = crc; 
     46     
    3147        RFM12_MAC_startCtrlTransmission(); 
     48     
     49     
     50    if (SetupValues.FEC!=0){ // nur berechnen, wenn FEC aktiviert ist 
     51        // Message Parity berechnen, während PreFrame und Message schon übertragen werden 
     52         
     53        g_parity_len = rs_encode_msg(&Msg->Nachricht, &g_parity[HeaderParitySize], Msg->Header.Laenge); 
     54    } 
     55     
     56    Timer_SetSystemSpeed_Slow(0);  
     57    //Msg->Header.Flags.Status=flag_status;   // Statusflag wiederherstellen 
     58     
    3259        return 0; 
    3360} 
    … …  
    4471        { 
    4572                isBake = true; 
    46                 //SetupValues.Licht = true; 
     73                //SetupValues.Licht = true; //DEBUG 
     74       // LED_An(); 
    4775        } 
    4876 
    … …  
    5886        }        
    5987 
    60         // in den DoubleBuffer umkopieren 
    61         memcpy(&Message_RxDoubleBuffer, &Message_RxBuffer, sizeof(Message_RxDoubleBuffer)); 
     88        // in den DoubleBuffer umkopieren, Message Header und die zusätzliche 0 am Ende nicht vergessen 
     89        //memcpy(&Message_RxDoubleBuffer, &Message_RxBuffer, sizeof(Message_RxDoubleBuffer)); 
     90        memcpy(&Message_RxDoubleBuffer, &Message_RxBuffer, Message_RxBuffer.Header.Laenge+sizeof(MessageHeader_t)+1); 
    6291        GLOBALFLAGS.NewRawRX = true; 
    6392 

  • trunk/Software/RFM12_MAC.c

    r317 r318  
    1010#include "Message.h" 
    1111#include "LCD.h" 
    12  
    13 const uint8_t   _RFM12_MAC_preamble[] = {0xAA, 0xAA, 0x2D, 0xD4}; 
     12#include "rs.h" 
     13#include "MenuSetup.h" 
     14 
     15 
     16const uint8_t PROGMEM _RFM12_MAC_preamble[] = {0xAA, 0xAA, 0x2D, 0xD4}; 
     17 
     18const uint8_t PROGMEM _PreFrame[] = { 0xAA, 0xAA, 0xAA,    // Preamble 
     19                                      0x2D, 0xD4, 0xAA, 0x2D, 0xD4, 0xAA,   // 3x Magic Word 
     20                                      0x2D, 0xD4, 0xAA, 0x2D, 0xD4, 0xAA,  // 3x Magic Word 
     21                                      0xf0, 0xcc, 0x33, 0x5a};  // Sync Word 
    1422 
    1523volatile RFM12_MAC_State_t _RFM12_MAC_state; 
     24 
     25 
     26volatile char rx_state = 0; 
     27volatile char tx_state = 0; 
     28 
    1629 
    1730bool RFM12_MAC_mediaBusy(void) 
    … …  
    2437void RFM12_MAC_startCtrlTransmission(void) 
    2538{ 
    26 //      if (RFM12_PHY_busy()) 
    27 //      { 
    28 //              sei(); 
    29 // debug wegen cron-abstürzen 
    30         //              while(RFM12_PHY_busy());        // wait for media to become free 
    31                 //Timer_SetSystemSpeed_Fast(); 
    32 //              cli(); 
    33 //      } 
    34  
     39     
     40    if(RFM12_PHY_busy()){ 
     41        sei(); 
     42        while(RFM12_PHY_busy());// wait for media to become free 
     43                                // und zwar OHNE die Interrupts zu blockieren -> DEADLOCK ! 
     44        cli(); 
     45    }         
     46                                 
     47        //Timer_SetSystemSpeed_Fast(RFM_ISR); 
     48    tx_state = 0; 
    3549        RFM12_PHY_modeTX(); 
    3650} 
    … …  
    4155 
    4256        _RFM12_MAC_state = RFM12_MAC_TX_WAIT; 
    43         Timer_SetSystemSpeed_Slow(); 
     57        Timer_SetSystemSpeed_Slow(RFM_ISR); 
    4458        //      _RFM12_MAC_startTimer(RFM12_MAC_TX_WAIT_TIME); 
    4559} 
    … …  
    4761 
    4862 
    49 bool RFM12_MAC_receiveCallback(uint8_t data) 
     63inline bool RFM12_MAC_receiveCallback(uint8_t data) 
    5064{ 
    51         static volatile uint8_t counter = 0; 
    52         if (counter < sizeof(_RFM12_LLC_Rxbuf)) 
    53         { 
    54                 ((unsigned char*)&_RFM12_LLC_Rxbuf)[counter++] = data; 
    55                 return false; 
    56         } 
    57         else 
    58         { 
    59  
    60                 RFM12_PHY_modeRX(); // Klappe halten 
    61                 RFM12_PHY_getStatus(); 
    62                 counter = 0; 
    63  
    64                 ////// 
    65                 uint16_t crc = 0xFFFF; 
    66                 uint16_t laenge = 2 + sizeof(MessageHeader_t) + _RFM12_LLC_Rxbuf.Message.Header.Laenge + 1; // Länge + crc 
    67  
    68                 if (laenge > sizeof(_RFM12_LLC_Rxbuf)) 
    69                         laenge = sizeof(_RFM12_LLC_Rxbuf); 
    70  
    71                 for (uint16_t i = 0; i < laenge; i++) 
    72                 { 
    73                         uint8_t data = ((unsigned char*)&_RFM12_LLC_Rxbuf)[i]; 
    74                         crc = _crc16_update(crc,data); 
    75                 } 
    76  
    77                 // DEBUG 
    78                 //_RFM12_LLC_Rxbuf.CRC = crc; 
    79  
    80  
    81                 if (crc != 0) 
    82                         return true;  // CRC stimmt nicht, frame verwerfen  und raus 
    83                 else 
    84                 { 
    85                         RFM12_LLC_receiveCallback(); // Frame bearbeiten 
    86                         return true; 
    87                 } 
    88         } 
     65        static uint8_t counter_buf = 0; 
     66    static char     rxmsglen   = 0; 
     67    static uint16_t crc_buf; 
     68     
     69    bool     ret     = false; 
     70    register crc     = crc_buf; 
     71    register counter = counter_buf; 
     72    register parity_len = g_parity_len; 
     73     
     74     
     75    switch(rx_state){ 
     76        case 0:{        // Sync Phase, feststellen ob Sync oder Rufzeichen passt 
     77                        // hier ist noch nicht klar ob FEC oder keine FEC 
     78            _RFM12_LLC_Rxbuf.AsChar[counter++] = data; 
     79 
     80            //dump[dumppos++] = data; 
     81            //dump[dumppos++] = counter; // DEBUG 
     82 
     83            if((counter > 3) &&(counter <15)) 
     84            {   // Sync kann an Position 4, 6 oder 8 auftauchen, je nachdem welches 
     85                // 10, 12 oder 14 
     86                // Magic Word korrekt empfangen wurde und den Empfang gestartet hat 
     87                // 
     88                // deswegen zuerst prüfen ob Syncwort vorliegt 
     89 
     90                if (find_sync( &_RFM12_LLC_Rxbuf.AsChar[counter-4] ) == 0){ 
     91                    counter=0;      // ab hier wieder neu beginnen 
     92                    if (SetupValues.FEC!=0) 
     93                    { 
     94////                        dumppos = 0; 
     95                        parity_len=0; // Parity Länge auf 0 
     96                        rx_state=1;     // Header Parity einlesen 
     97                        CW_Position = 4; //DEBUG 
     98                    } 
     99                    else 
     100                    { 
     101                        rx_state = 255;   // Empfang ohne FEC - Parity ignorieren, also Empfänger zunächst deaktivieren 
     102                    } 
     103                } 
     104            } 
     105                
     106            // Möglicherweise wird gerade ein Frame ohne FEC empfangen 
     107            // Dann muss der Header ausgewertet werden, sobald er empfangen wurde 
     108                        if (counter==1){ 
     109                crc = 0xffff; 
     110            } 
     111            crc = crc16_update(crc,data);      // CRC updaten 
     112             
     113            // Prüfen auf Destination & Repeat 
     114            // Ausserdem Längeninformation lesen 
     115            if (counter == sizeof(MessageHeader_t)){ 
     116                CW_Position = 2; //DEBUG 
     117                rxmsglen = sizeof(MessageHeader_t)+Message_RxBuffer.Header.Laenge + 2; // +2 für CRC 
     118////                txdump[0]=rxmsglen; 
     119 
     120                parity_len = 0;     // Frame ohne FEC 
     121                rx_state = 3;       // Nachricht einlesen, Header wurde gerade empfangen 
     122                                    // Counter nicht anfassen 
     123            } 
     124            break; 
     125             
     126        } 
     127        case 1:{    // Header Parity einlesen 
     128                    // Präambel (2 Byte) und Magic Word (2 Byte) vom Data Frame 
     129                    // ebenfalls mit einlesen. Diese werden beim Verarbeiten 
     130                    // der Header Parity nicht berücksichtigt 
     131            g_parity[parity_len++] = data; 
     132 
     133            //dump[dumppos++] = parity_len; // DEBUG 
     134 
     135            if (parity_len == HeaderParitySize + sizeof(_RFM12_MAC_preamble)) 
     136            {// Header Parity (15) + Länge der Präambel 
     137////                txdump[1]=HeaderParitySize + sizeof(_RFM12_MAC_preamble); 
     138////                txdump[2]= sizeof(_RFM12_MAC_preamble); 
     139                rx_state = 2;         // Header einlesen 
     140                counter  = 0;         // Im Datenpuffer wieder vorne beginnen 
     141                rs_dpos = 0;    // Datenposition für Dekodierung auf 0 
     142                rs_ppos = 0;    // Parityposition für Dekodierung auf 0 
     143                rs_errcnt = 0;  // Fehlerzähler für Dekodierung auf 0 
     144                parity_len -= sizeof(_RFM12_MAC_preamble);   // Präambel und Magicword abziehen 
     145            } 
     146            break;         
     147        } 
     148        case 2:{    // Header nach Parity (und nur nach Parity) einlesen 
     149                    // ohne Parity/FEC wurde er bereits in state 0 eingelesen 
     150            _RFM12_LLC_Rxbuf.AsChar[counter++] = data; 
     151            //dump[dumppos++] = data; 
     152             
     153                        if (counter==1){ 
     154                crc = 0xffff; 
     155            } 
     156            
     157            crc = crc16_update(crc,data);      // CRC updaten 
     158 
     159            if(counter == sizeof(MessageHeader_t)){  
     160                                // Sobald der Header komplett eingelesen ist, schonmal 
     161                rx_state=3;     // das erste Nachrichtenbyte einlesen im nächsten Schritt 
     162                                // unabhängig davon: 
     163                                // ob das Frame einen Datenteil hat oder nicht, 
     164                                // ob der Header korrigiert werden konnte oder nicht 
     165                                // 
     166                                // Das ist wichtig, da das nächste Byte schon während der 
     167                                // Dekodierung eintreffen könnte ! 
     168                rxmsglen = sizeof(MessageHeader_t)+MESSAGE_MAXLEN+2; // Vorsorglich maximale Länge setzen 
     169            } 
     170             
     171            //Daten bereits während des Empfangs dekodieren 
     172                                     
     173            if ((counter & 0x03) == 0){  // Dekodierung alle 4 Bytes starten 
     174                char err; 
     175                 
     176                sei();     // Interrupt freigeben, um den Emfpang des nächsten Bytes zu ermöglichen 
     177                 
     178                // Dekodierung des aktuellen Blocks aus 8 Symbolen 
     179                err = rs_decode( &_RFM12_LLC_Rxbuf.AsChar[rs_dpos], &g_parity[rs_ppos], 0, 8); 
     180 
     181                if (err > 3){       // Anzahl der aufgetretenen Symbolfehler prüfen 
     182                    rx_state = 255; // Bei mehr als 3 Symbolfehlern liegt ein Dekodierfehler vor 
     183                                    // wahrscheinlich sind mehr Fehler aufgetreten als korrigiert werden können 
     184////                  rs_merrcnt = rs_errcnt; 
     185                    rs_errcnt=200;  // Header Parity Error 
     186                    ret=true; 
     187                    break;          // Deswegen den Empfang hier abbrechen 
     188                } 
     189 
     190                rs_dpos +=4;        // Daten Position für den Dekoder um 4 Byte/8Symbole erhöhen 
     191                                    // ( 9. Symbol ist im Header immer 0 und wird nicht übertragen) 
     192                rs_ppos +=3;        // Paritäts Position für den Dekoder um 3 Byte / 6 Symbole erhöhen 
     193                rs_errcnt+=err;     // Symbolfehleranzahl erhöhen 
     194                 
     195            // hier ggf. schonmal den Header auf Rufzeichen etc. auswerten 
     196            // könnte prinzipiell nach dem 8. Byte geschehen 
     197            // UUID sollte auch überprüft werden, 
     198            // Vorschlag: Frame mit bekanntem Rufzeichen und bekannter UUID nicht mehr auswerten 
     199             
     200                // Sobald der Header komplett eingelesen und dekodiert ist 
     201                // (">=" wichtig, es könnte sein, dass counter bereits auf 21 erhöht wurde!) 
     202                if (counter >= sizeof(MessageHeader_t)){  
     203                                                         
     204                    if (Message_RxBuffer.Header.Laenge != 0)    // Verfügt das Frame über einen Datenteil? 
     205                    { 
     206                        rxmsglen = sizeof(MessageHeader_t)+Message_RxBuffer.Header.Laenge + 2; // Länge der kompletten Nachricht 
     207/////                        txdump[0]=rxmsglen; 
     208                        if (Message_RxBuffer.Header.Laenge > MESSAGE_MAXLEN) 
     209                        // Die Nachricht darf nicht größer als der Puffer sein 
     210                        { 
     211                            rx_state = 255;      
     212                            rs_errcnt=240;      // MAXLEN Exceeded 
     213////                            rs_merrcnt = 0; 
     214                            ret=true; 
     215                            break;              // Empfang abbrechen 
     216                        } 
     217                        // rx_state ist bereits =3 
     218                    } 
     219                    else{       // kein Datenteil vorhanden, CRC nicht auswerten, da keine Fehler vorhanden 
     220                        rx_state=255; 
     221////                        rs_merrcnt=rs_errcnt; 
     222                        rs_errcnt=151; 
     223                        RFM12_LLC_receiveCallback(); // Frame verarbeiten             
     224                    }                   
     225                } 
     226            } 
     227            // Weiterschaltung zum nächsten State ist bereits erfolgt, hier nichts mehr ändern, 
     228            // denn vielleicht sind wir schon 1 Byte weiter 
     229            //dump[dumppos++] = counter; // DEBUG 
     230 
     231            break; 
     232        } 
     233        case 3:{    // Message inkl. CRC einlesen 
     234            _RFM12_LLC_Rxbuf.AsChar[counter++] = data; 
     235            //dump[dumppos++] = counter; // DEBUG 
     236            //dump[dumppos++] = data; // DEBUG 
     237 
     238                        crc = crc16_update(crc,data);      // CRC updaten 
     239             
     240            if (counter == rxmsglen){ // Nachricht eingelesen 
     241                if (rxmsglen > sizeof(MessageHeader_t)+2){ 
     242////                    txdump[4]=_RFM12_LLC_Rxbuf.AsChar[counter-2]; 
     243                    _RFM12_LLC_Rxbuf.AsChar[counter-2] = 0; // String 0 terminieren (wenn es einen String gibt), 
     244                                                            // 1.Byte der CRC wird überschrieben, macht aber nix 
     245                                                            // wird nicht mehr gebraucht, 
     246                                                            // auch die FEC schließt die CRC nicht ein 
     247                } 
     248                 
     249                if (parity_len == 0){       // keine FEC 
     250                    rs_errcnt=150; 
     251                    if (crc==0){            // CRC ok? Dann Nachricht übernehmen 
     252                        rx_state=5;         // während der Verarbeitung nichts tun 
     253//                        rs_errcnt= 150;         // RX ok, keine FEC 
     254////                        rs_merrcnt=0; 
     255                        sei();              // Interrupts zulassen 
     256                        RFM12_LLC_receiveCallback(); // Frame verarbeiten 
     257                    } 
     258                    else{ 
     259////                        rs_merrcnt=150; 
     260                    } 
     261                    rx_state=255; 
     262                    ret=true; 
     263                } 
     264                else{           // Frame mit FEC 
     265                    rx_state=4; // Im nächsten Schritt die Message Parity einlesen 
     266                                // 9 Symbole Daten / 6 Symbole Parity 
     267                    // Anzahl der Parity Bytes berechnen 
     268                    // (len *2) = Nachrichtensymbole 
     269                    // Parity Symbole = (floor(Nachrichtensymbole / 9) + 1) * 6  
     270                    parity_len  = (((int) Message_RxBuffer.Header.Laenge)<<1) / 9; 
     271                    parity_len += 1; // immer zum nächsten vollen Integer aufrunden 
     272                    parity_len  = (parity_len << 1) + parity_len;  // * 3  -> Parity Länge in Bytes 
     273                    rxmsglen -= sizeof(MessageHeader_t)+2;   // Länge von Header + CRC abziehen 
     274                    rs_ppos = 0;    // Parity Position für Dekoder = 0 
     275                    rs_dpos = 0;    // Daten position für Dekoder = 0 
     276                    rs_offset = 0;  // Offset für Dekoder = 0; 
     277                    counter = 0;    // Counter = 0 - wird nun als Zähler für empfangene  
     278                                    // Parity Bytes genutzt 
     279////                    txdump[3] = parity_len; 
     280                } 
     281            }             
     282            break; 
     283        }     
     284        case 4:{ 
     285            g_parity[rs_ppos++] = data; // Parity Byte (je 2 Symbole) einlesen 
     286            //dump[dumppos++] = rs_ppos; // DEBUG 
     287            //dump[dumppos++] = data; 
     288             
     289            if(++counter == 3){ // alle 3 Byte bzw. 6 Symbole ist ein Block vollständig 
     290                                // ( 9 Symbole Daten (bereits empfangen) + 9 Symbole Parität = 1 Block) 
     291                char err; 
     292                 
     293                counter = 0;    // counter zurücksetzen 
     294                 
     295                err = 9;                 
     296                if(rs_ppos == parity_len) // Alles empfangen? 
     297                { 
     298                    // dann prüfen ob die Nachricht 'aufgefüllt' wurde                                         
     299                    err= ((rxmsglen-rs_dpos)<<1) - rs_offset; // Anzahl verbliebener Symbole berechnen; 
     300                                                             // "Anzahl verbliebener Bytes" * 2 (= Symbole) + offset 
     301////                    txdump[5]=err;  
     302                } 
     303                 
     304                sei();     // Interrupt freigeben, um den Emfpang des nächsten Bytes zu ermöglichen 
     305//                err = rs_decode( (char *)(&_RFM12_LLC_Rxbuf+rs_dpos), &g_parity[rs_ppos-3], rs_offset, 9);   // Bytes 0-3 dekodieren                 
     306                // nächsten Block bestehend aus 0,5-4,5 Bytes (1-9 Symbolen) Nutzdaten und 3 Bytes Parity dekodieren 
     307                err = rs_decode( &_RFM12_LLC_Rxbuf.AsChar[rs_dpos+sizeof(MessageHeader_t)], &g_parity[rs_ppos-3], rs_offset, err);                
     308                                 
     309                if (err>3){ 
     310                    rx_state = 255; 
     311////                    rs_merrcnt = rs_errcnt; 
     312                    rs_errcnt= 201; // Message Parity Error 
     313                    ret=true; 
     314                    break;         // unkorrigierbarer Fehler - Empfang abbrechen                      
     315                } 
     316                 
     317                rs_dpos+= 4; 
     318                rs_dpos+= rs_offset; 
     319                rs_errcnt+= err; 
     320                rs_offset^=1;                 
     321            } 
     322             
     323            if (rs_ppos >= parity_len){ 
     324////                rs_merrcnt = rs_errcnt; 
     325                rs_errcnt = 160; 
     326                RFM12_LLC_receiveCallback(); // Frame bearbeiten 
     327                rx_state=255;                // raus hier 
     328                parity_len = 0; 
     329            }             
     330            break;         
     331        } 
     332        case 5:{ 
     333            __asm("nop"); 
     334            break; 
     335        } 
     336        default:{ 
     337            rx_state = 0;       // Mit Empfang (nach nächstem Magic Word) von vorne beginnen 
     338            counter = 0;        // index für RX Speicher zurücksetzen 
     339            parity_len = 0;   // und auch die globale Parity Länge zurücksetzen (= Parity Array unbenutzt) 
     340////            dump[dumppos]=0; 
     341////            dumppos = 0; 
     342            ret=true; 
     343            break;              // Empfang beenden 
     344        }         
     345    }    
     346     
     347    crc_buf = crc; 
     348    g_parity_len = parity_len; 
     349    counter_buf = counter; 
     350     
     351    return (ret);   // mit Empfang fortfahren(false) oder auch nicht(true) 
    89352} 
    90353 
    91 uint8_t RFM12_MAC_transmitCallback(void) 
     354 
     355 
     356inline uint8_t RFM12_MAC_transmitCallback(void) 
    92357{ 
    93358        static uint8_t counter = 0; 
    94         uint16_t laenge = _RFM12_LLC_Txbuf.Message.Header.Laenge +1; 
    95  
    96         if(counter < sizeof(_RFM12_MAC_preamble))       // HEADER 
    97         {        
    98                 return _RFM12_MAC_preamble[counter++]; 
    99         }  
    100         else  
    101                 if(counter < (sizeof(_RFM12_MAC_preamble) + sizeof(MessageHeader_t) + laenge) )         // DATA 
    102                 { 
    103                         uint8_t data = ((uint8_t*)&_RFM12_LLC_Txbuf)[counter - sizeof(_RFM12_MAC_preamble)]; 
    104                         counter++; 
    105                         return data; 
    106                 } 
    107                 else  
    108                         if (counter < (sizeof(_RFM12_MAC_preamble) + sizeof(MessageHeader_t) + laenge + 1)) //CRC 
    109                         { 
    110                                 counter++; 
    111                                 return ((CONVERTW*)&_RFM12_LLC_Txbuf.CRC)->b[0];         // direct Load, aber Typecast 
    112                         } 
    113                         else 
    114                                 if (counter < (sizeof(_RFM12_MAC_preamble) + sizeof(MessageHeader_t) + laenge + 2)) //CRC                                
    115                                 { 
    116                                         counter++; 
    117                                         return ((CONVERTW*)&_RFM12_LLC_Txbuf.CRC)->b[1];                // direct load, aber typecast 
    118  
    119                                 } 
    120                                 // TxTail ein Byte 
    121                                 else                                     
    122                                         if (counter < (sizeof(_RFM12_MAC_preamble) + sizeof(MessageHeader_t) + laenge + 3)) //Dummy-Byte 
    123                                         { 
    124                                                 counter++; 
    125                                                 return 0xAA; 
    126                                         } 
    127                                         else 
    128                                         { 
    129                                                 counter = 0; 
    130  
    131                                                 RFM12_MAC_endCtrlTransmission(); 
    132                                                 GLOBALFLAGS.IsTXing = false; 
    133                                                 // Sieht man eh nich 
    134                                                 //GLOBALFLAGS.DoRedraw = true; 
    135                                         } 
    136                                         return 0; 
     359    char laenge = _RFM12_LLC_Txbuf.Message.Header.Laenge; 
     360     
     361    switch (tx_state){ 
     362        case 0:     // Pre Frame             
     363        { 
     364            if (SetupValues.FEC!=0){                        // Wenn FEC aktiviert ist 
     365                if(counter < sizeof(_PreFrame)){ 
     366                    CW_Position = 4; //DEBUG 
     367                    return pgm_read_byte(_PreFrame + counter++); 
     368                } 
     369                else{ 
     370                    counter = 0; 
     371                    tx_state = 1; 
     372                } 
     373            } 
     374            else{ 
     375                tx_state = 2; 
     376                CW_Position = 2; //DEBUG 
     377                return (pgm_read_byte(_RFM12_MAC_preamble + counter++)); 
     378            } 
     379        } 
     380        case 1:{    // Header Parity 
     381            if(counter < HeaderParitySize){ 
     382                return (g_parity[counter++]); 
     383            } 
     384            else{ 
     385                counter = 0; 
     386                tx_state = 2; 
     387            } 
     388        } 
     389        case 2:{    // Message Präambel 
     390            if(counter < sizeof(_RFM12_MAC_preamble)) 
     391            { 
     392                return (pgm_read_byte(_RFM12_MAC_preamble + counter++)); 
     393            } 
     394            else 
     395            { 
     396                counter = 0; 
     397                tx_state=3; 
     398            } 
     399        } 
     400        case 3:{    // Message Header 
     401            if(counter < sizeof(MessageHeader_t)) 
     402            { 
     403                return ( ((char*)&_RFM12_LLC_Txbuf)[counter++]); 
     404            } 
     405            else{ 
     406                tx_state=4; 
     407            } 
     408        } 
     409        case 4:{    // Message Frame 
     410            if(counter < sizeof(MessageHeader_t) + laenge){ 
     411                return ( ((char*)&_RFM12_LLC_Txbuf)[counter++]); 
     412            } 
     413            else{ 
     414                tx_state=5; 
     415                counter=0; 
     416            } 
     417        } 
     418        case 5:{    // CRC 
     419            if(counter < 2){ 
     420                return ((CONVERTW*)&_RFM12_LLC_Txbuf.CRC)->b[counter++]; 
     421            } 
     422            else 
     423            { 
     424                counter = 0; 
     425                if (SetupValues.FEC==0){    // Wenn FEC deaktiviert ist 
     426                    tx_state=7;                 // TxTail senden 
     427                    return(0xaa);   // TX Tail  // und im nächsten Aufruf TX beenden 
     428                } 
     429                else{ 
     430                    tx_state= 6;            // andernfalls mit dem Post Frame weitermachen 
     431                } 
     432            } 
     433        } 
     434        case 6:{    // Post Frame 
     435            if(counter < g_parity_len){ 
     436                return (g_parity[HeaderParitySize+counter++]); 
     437            } 
     438            else 
     439            { 
     440                tx_state = 7; 
     441                g_parity_len = 0; 
     442                //CW_Position = 2;  // DEBUG 
     443                return(0xaa);   // TX Tail 
     444            } 
     445        } 
     446        default:{ 
     447            counter = 0; 
     448            tx_state = 0; 
     449            RFM12_MAC_endCtrlTransmission(); 
     450            GLOBALFLAGS.IsTXing = false; 
     451            return(0); 
     452        }     
     453    } 
    137454} 
    138455 

  • trunk/Software/RFM12_MAC.h

    r236 r318  
    9191} RFM12_LLC_buf_t; 
    9292 
     93typedef union CONVERTBUF 
     94{ 
     95        RFM12_LLC_buf_t AsBuf; 
     96        char AsChar[sizeof(RFM12_LLC_buf_t)]; 
     97} RFM12_LLC_bufc_t; 
    9398 
    9499 
     100extern volatile char     rx_state; 
     101extern volatile char     tx_state; 
     102 
    95103extern volatile RFM12_LLC_buf_t _RFM12_LLC_Txbuf; 
    96 extern volatile RFM12_LLC_buf_t _RFM12_LLC_Rxbuf; 
     104extern volatile RFM12_LLC_bufc_t _RFM12_LLC_Rxbuf; 
    97105 
    98 #define Message_RxBuffer _RFM12_LLC_Rxbuf.Message 
     106#define Message_RxBuffer _RFM12_LLC_Rxbuf.AsBuf.Message 
    99107#define Message_TxBuffer _RFM12_LLC_Txbuf.Message 
    100108 

  • trunk/Software/RFM12_PHY.c

    r311 r318  
    1010#include "Timer.h" 
    1111#include "ADC.h" 
     12#include "rs.h" 
    1213#include "MenuSetup.h" 
    1314#include "Ressources.h" 
    14  
    1515 
    1616 
    … …  
    233233                switch(_RFM12_PHY_state)  
    234234                { 
    235                 case RFM12_LISTEN: 
    236                         //                      RFM12_RX_LED_on(); 
    237                         //Timer_SetSystemSpeed_Fast(); 
    238                                  
    239                         _RFM12_PHY_state = RFM12_RX; 
    240                 case RFM12_RX:                   
    241                         data = RFM12_fifoRead(); 
    242                         Timer_SetSystemSpeed_Fast(); 
    243                         if(     //!(status & RFM12_RSSI_ATS) ||  
    244                                  
    245                                 RFM12_MAC_receiveCallback(data) )  
    246                         {               // end of frame 
    247                                 RFM12_PHY_modeRX(); 
    248                                 _RFM12_PHY_state = RFM12_LISTEN; 
    249                                 //                                      RFM12_RX_LED_off(); 
    250                         } 
    251                         Timer_SetSystemSpeed_Slow(); 
    252                          
    253                         break; 
    254                 case RFM12_TX: 
    255                         _RFM12_trans(0xB800 | RFM12_MAC_transmitCallback()); 
    256                         break; 
     235            case RFM12_LISTEN: 
     236                //                      RFM12_RX_LED_on(); 
     237                //Timer_SetSystemSpeed_Fast(); 
     238                     
     239                _RFM12_PHY_state = RFM12_RX; 
     240                //CW_Position=2; DEBUG 
     241////                dumppos = 0; 
     242////                txdumppos = 0; 
     243            case RFM12_RX:{ 
     244                Timer_SetSystemSpeed_Slow(RFM_ISR | FORCE); 
     245                data = RFM12_fifoRead(); 
     246                Timer_SetSystemSpeed_Fast(RFM_ISR); 
     247                //dump[dumppos++]=rx_state; 
     248////                dump[dumppos++]=data; 
     249                 
     250                if( RFM12_MAC_receiveCallback(data) )  
     251                {               // end of frame 
     252                    RFM12_PHY_modeRX();         // RFM12 soll wieder auf Sync warten 
     253                    _RFM12_PHY_state = RFM12_LISTEN; 
     254                    //                                  RFM12_RX_LED_off(); 
     255                } 
     256                 
     257                if ((rx_state >= 2) && g_parity_len ==0){ 
     258                    Timer_SetSystemSpeed_Slow(RFM_ISR); 
     259                    // System Speed nur drosseln, wenn gerade keine FEC Dekodierung lÀuft 
     260                } 
     261                break; 
     262            } 
     263            case RFM12_TX:{ 
     264                        _RFM12_trans(0xB800 | RFM12_MAC_transmitCallback()); 
     265//                txdump[txdumppos]= RFM12_MAC_transmitCallback();    //DEBUG 
     266  //              _RFM12_trans(0xB800 | txdump[txdumppos++]); 
     267                break; 
     268            } 
    257269                } 
    258270        } 

  • trunk/Software/SMSer.pnps

    r267 r318  
    1 <pd><ViewState><e p="FiFiSMSer\Header Files" x="true"></e><e p="FiFiSMSer\Header Files\Fonts" x="false"></e><e p="FiFiSMSer\Header Files\Menus" x="false"></e><e p="FiFiSMSer\Header Files\RFM12" x="false"></e><e p="FiFiSMSer\Source Files" x="true"></e><e p="FiFiSMSer" x="true"></e><e p="FiFiSMSer\Resources" x="false"></e><e p="FiFiSMSer\Source Files\RFM12" x="false"></e></ViewState></pd> 
     1<pd><ViewState><e p="FiFiSMSer\Header Files" x="true"></e><e p="FiFiSMSer\Header Files\Fonts" x="false"></e><e p="FiFiSMSer\Header Files\Menus" x="true"></e><e p="FiFiSMSer\Header Files\RFM12" x="false"></e><e p="FiFiSMSer\Source Files" x="true"></e><e p="FiFiSMSer" x="true"></e><e p="FiFiSMSer\Resources" x="false"></e><e p="FiFiSMSer\Source Files\RFM12" x="true"></e></ViewState></pd> 

  • trunk/Software/Screen.c

    r317 r318  
    11691169                        topIdx = cursorIdx; 
    11701170 
    1171                 for (uint8_t i = 0; i < 4; i++) 
    1172                 { 
    1173                         if (topIdx + i > menuLen) 
    1174                                 break; 
    1175  
    1176                         LCD_SetTextCursor(0, i+1); 
     1171                        for (uint8_t i = 0; i < 4; i++) 
     1172                        { 
     1173                                if (topIdx + i > menuLen) 
     1174                                        break; 
     1175 
     1176                                LCD_SetTextCursor(0, i+1); 
    11771177 
    11781178 

  • trunk/Software/Timer.c

    r317 r318  
    2020#include "GlobalDefs.h" 
    2121#include "MenuSetup.h" 
     22#include "rs.h" 
     23#include "RFM12_MAC.h" 
    2224 
    2325// 1 Mhz Takt / 128 Prescaler / 256 Overflow / 31 = 1 sek Takt 
    … …  
    4143static uint16_t Timer_BakenTimer; 
    4244 
     45 
     46static bool cron_active=false; 
     47 
     48static char speed = 0;  // Bit 0 - EXT Int ISR 
     49                        // Bit 1 - Timer ISR 
     50                        // Bit 2 - Main  
     51 
    4352// Timer0 : Scheduler 
    4453static inline void Timer0_Init(void) 
    … …  
    4655        TCNT0 = 0; 
    4756//      TCCR0B = (1<<CS02) | (1<<CS00); Wird von SetSystemSpeed erledigt 
    48         TIMSK0 = (1<<TOIE0); 
     57        TIMSK0 = (0<<TOIE0); 
     58    TCCR0B = (1<<CS01) | (1<<CS00); 
    4959} 
    5060 
    … …  
    7686        Timer1_Init(); 
    7787        Timer2_Init(); 
    78  
    79         Timer_SetSystemSpeed_Slow(); 
     88     
     89        Timer_SetSystemSpeed_Slow(MAIN); 
    8090} 
    8191 
    8292//DEBUG auskommentiert weil crc problem 
    8393// Schaltet die Speed-abhängigen Komponenten um 
    84 void Timer_SetSystemSpeed_Fast() 
    85 { 
     94void Timer_SetSystemSpeed_Fast(char caller) 
     95{ 
     96    speed |= caller; 
     97     
    8698        ATOMIC_BLOCK(ATOMIC_RESTORESTATE) 
    8799        {        
    … …  
    95107} 
    96108 //Schaltet die Speed-abhängigen Komponenten um 
    97 void Timer_SetSystemSpeed_Slow() 
    98 { 
    99         ATOMIC_BLOCK(ATOMIC_RESTORESTATE) 
    100         { 
    101                 CLKPR  = (1<<CLKPCE); // Setup 
    102                 CLKPR  = (0<<CLKPCE) | (0<<CLKPS3) | (0<<CLKPS2) | (1<<CLKPS1) | (1<<CLKPS0); // 1 Mhz 
    103                 //      TCCR0B = (0<<CS02) | (1<<CS01) | (0<<CS00); // Timer0: / 8 
    104                 //      TCCR1B = (0<<CS12) | (1<<CS11) | (0<<CS10); // Timer1: / 8 
    105                 TCCR2B = (1<<CS22) | (0<<CS21) | (1<<CS20); // Timer 2: / 128 
    106                 //SPSR   = (1<<SPI2X);  // SPI Geschwindigkeit verdoppeln 
    107         } 
     109void Timer_SetSystemSpeed_Slow(char caller) 
     110{ 
     111    return; // DEBUG 
     112 
     113    speed &= ~(caller & ~FORCE); 
     114     
     115    if(speed == 0 || ((caller & FORCE)!= 0)){     
     116        ATOMIC_BLOCK(ATOMIC_RESTORESTATE) 
     117        { 
     118            CLKPR  = (1<<CLKPCE); // Setup 
     119            CLKPR  = (0<<CLKPCE) | (0<<CLKPS3) | (0<<CLKPS2) | (1<<CLKPS1) | (1<<CLKPS0); // 1 Mhz 
     120            //  TCCR0B = (0<<CS02) | (1<<CS01) | (0<<CS00); // Timer0: / 8 
     121            //  TCCR1B = (0<<CS12) | (1<<CS11) | (0<<CS10); // Timer1: / 8 
     122            TCCR2B = (1<<CS22) | (0<<CS21) | (1<<CS20); // Timer 2: / 128 
     123            //SPSR   = (1<<SPI2X);      // SPI Geschwindigkeit verdoppeln 
     124        } 
     125    } 
    108126} 
    109127 
    … …  
    268286ISR(TIMER2_OVF_vect) 
    269287{ 
    270         Timer_SetSystemSpeed_Fast(); 
     288        Timer_SetSystemSpeed_Fast(TIMER_ISR); 
    271289 
    272290        // SMS Tastentimeout asynchron behandeln 
    … …  
    281299                if (--Timer_LightDelay == 0) 
    282300                        LED_Aus(); 
    283          
    284          
     301        } 
     302 
     303    if (cron_active || (g_parity_len !=0)){ 
     304        // CRON schon läuft, oder wenn FEC Dekodierung (möglicherweise) aktiv ist 
     305        // Interrupt hier beenden 
     306        return; 
     307    }    
     308     
     309    cron_active = true; 
     310    sei();  //DEBUG 
     311     
    285312        Message_Cron_RX(); 
    286313 
    … …  
    295322                Timer_INT2_DoBake(); 
    296323        } 
    297  
    298         if (Timer_MainTick == 25) 
    299         { 
    300                 if (GLOBALFLAGS.UserHeard) 
    301                         Message_UserHeard(); 
    302                 GLOBALFLAGS.UserHeard = false; 
    303         } 
    304 } 
    305  
     324         
    306325        // im Sekundentakt 
    307326        if (Timer_MainTick == 0) 
    … …  
    328347                Timer_MainTick--; 
    329348        } 
    330         Timer_SetSystemSpeed_Slow(); 
     349        Timer_SetSystemSpeed_Slow(TIMER_ISR); 
     350    cron_active=false; 
    331351} //endof ISR 
     352 
     353 

  • trunk/Software/Timer.h

    r256 r318  
    1616 
    1717// Schaltet die Speed-abhängigen Komponenten um 
    18 void Timer_SetSystemSpeed_Fast(void); 
    19 void Timer_SetSystemSpeed_Slow(void); 
     18void Timer_SetSystemSpeed_Fast(char caller); 
     19void Timer_SetSystemSpeed_Slow(char caller); 
    2020 
    2121// Berechnet den Timespan 
    … …  
    2727volatile uint32_t Timer_LifeTimeCounter; 
    2828 
     29#define RFM_ISR   1 
     30#define TIMER_ISR 2 
     31#define MAIN      4 
     32#define KEYPAD_ISR 8 
     33#define FORCE     128 
     34 
    2935#endif // TIMER_H  

  • trunk/Software/rfm12_stack.h

    r132 r318  
    9898 // war mal inline 
    9999extern bool RFM12_MAC_receiveCallback(uint8_t data); 
     100extern bool RFM12_MAC_receiveCallback_classic(uint8_t data); // DEBUG 
    100101 
    101102/** 
    … …  
    104105 */ 
    105106 //war mal inline 
     107extern uint8_t RFM12_MAC_transmitCallback_classic(void); // DEBUG 
    106108extern uint8_t RFM12_MAC_transmitCallback(void); 
     109 
    107110 
    108111/******************** Layer 1: Physical ***********************/ 

  • trunk/Software/rs.c

    r297 r318  
    1212#include "screen.h" 
    1313#include "keypad.h" 
     14#include <util/crc16.h> 
    1415 
    1516// Routinen für RS(15,9) 
    … …  
    5657}; 
    5758 
    58  
    59 volatile char g_parity[117];      // erstmal nur 1 globalen Parity Buffer vorsehen 
     59const char PROGMEM _PFSYNC[4] = {0xf0,0xcc,0x33,0x5a}; 
     60 
     61 
     62//DEBUG 
     63volatile char g_parity[HeaderParitySize+MESSAGE_MAXLEN*6/9+1]; 
     64                                // erstmal nur 1 globalen Parity Buffer vorsehen 
    6065                                // entweder wir senden, oder empfangen 
    6166                                // die TX Parity wird direkt vor dem senden erzeugt 
    6267volatile char g_parity_len = 0; 
    6368 
    64 volatile char rs_dpos; 
    65 volatile char rs_ppos; 
    66 volatile char rs_errcnt; 
    67 volatile char rs_offset; 
    68  
     69volatile char rs_dpos=0; 
     70volatile char rs_ppos=0; 
     71volatile int rs_errcnt=0; 
     72volatile char rs_offset=0; 
     73volatile int rs_merrcnt=0; 
     74 
     75//volatile char dump[256]; 
     76//volatile char dumppos = 0; 
     77// 
     78//volatile char txdump[256]; 
     79//volatile char txdumppos = 0; 
    6980 
    7081char gf2mult(char a, char b) 
    … …  
    372383                h = (*head_buffer++ & 0xf0) >>4; 
    373384                 
    374          
     385        // Symbol 1 
    375386        FSR[0] =        (gf2mult(A12,l) ^ gf2mult(A10,h)) | 
    376387                                        ((gf2mult(A14, l^h))<< 4); 
    … …  
    381392                FSR[2] =        (gf2mult(A12,l) ^ gf2mult( A9,h)) | 
    382393                                        ((gf2mult( A6, gf2mult(l,A10) ^ h)) << 4); 
    383              
     394        // Symbol 2-8     
    384395                for(i=1;i<=3;i++){ 
    385396            l = (*head_buffer)  & 0x0f; 
    … …  
    397408                                                (gf2mult(c,A6)<<4); 
    398409                } 
    399          
     410        // Symbol 9 
    400411                c=FSR[0] & 0x0f; // eigentlich c= (FSR[0] & 0x0f) ^ h, aber h=0 (fixer Wert) 
    401412                 
    … …  
    797808 
    798809 
    799 char rs_decode(char R[], char parity[], char offset, char valid_symbols){ 
     810int rs_decode(char R[], char parity[], char offset, char valid_symbols){ 
    800811    char S[3]={0,0,0};  // Syndrom 
    801812    char errors = 0; 
    802  
     813    int biterr=0; 
     814 
     815//DEBUG 
     816    /* dump[108] = R[0]; 
     817    dump[109] = R[1]; 
     818    dump[110] = R[2]; 
     819    dump[111] = R[3]; 
     820    dump[112] = parity[0]; 
     821    dump[113] = parity[1]; 
     822    dump[114] = parity[2]; 
     823     */ 
    803824    // wenn Syndrom != 0, dann trat mind. ein Fehler auf 
    804825    if (rs_syndrom(R, parity, offset, S, valid_symbols) != 0){ 
    … …  
    815836         
    816837        if(rs_chsearch(sigma, errors, x) >0){   // Fehlerposition(en) ermitteln 
    817             return(0xff);  // Nullstellen (Fehlerpositionen) konnten nicht ermittelt werden 
     838            return(0xfe);  // Nullstellen (Fehlerpositionen) konnten nicht ermittelt werden 
    818839                            // -> Dekodierfehler (Korrekturkapazität überschritten) 
    819840        } 
    … …  
    836857                } 
    837858            } 
    838         }         
    839     } 
    840      
    841     return(errors);     // Anzahl der korrigierten Symbolfehler (NICHT Bitfehler) zurückgeben 
    842  
     859            errpos = 8; 
     860            while(errpos!=0){ 
     861                if ((y[i] & errpos)!=0){ 
     862                    biterr++; 
     863                } 
     864                errpos >>= 1; 
     865            } 
     866        }                 
     867    } 
     868     
     869//    return(errors);     // Anzahl der korrigierten Symbolfehler (NICHT Bitfehler) zurückgeben 
     870    return(biterr); 
    843871} 
    844872 
    … …  
    916944     
    917945    for(i=0;i<4;i++){ 
    918         buf = sync[0] ^ pgm_read_byte(PFSYNC[i]); 
     946        buf = sync[i] ^ pgm_read_byte(_PFSYNC+i); 
    919947        j=1; 
    920948        while(j!=0){ 
    … …  
    934962 
    935963 
     964int crc16_update(uint16_t crc, uint8_t data){ 
     965   return(_crc16_update(crc,data)); 
     966} 

  • trunk/Software/rs.h

    r297 r318  
    3333#define PreFrameSync3 0x33 
    3434#define PreFrameSync4 0x5a 
    35 static const char PROGMEM PFSYNC[4] = {0xf0,0xcc,0x33,0x5a}; 
     35extern const char PROGMEM PFSYNC[]; 
    3636 
    3737 
    … …  
    5959extern volatile char rs_dpos; 
    6060extern volatile char rs_ppos; 
    61 extern volatile char rs_errcnt; 
     61extern volatile int rs_errcnt; 
     62extern volatile int rs_merrcnt; 
    6263extern volatile char rs_offset; 
    6364 
     65extern volatile char dump[];    // DEBUG 
     66extern volatile char dumppos; 
     67extern volatile char txdump[];    // DEBUG 
     68extern volatile char txdumppos; 
    6469 
    6570#define A0              1 
    … …  
    103108char rs_decode_head(char head_buffer[],char head_parity[]); 
    104109char rs_decode_msg(char msg_buffer[],char msg_parity[],char len); 
     110int rs_decode(char R[], char parity[], char offset, char valid_symbols); 
    105111 
    106112char gf2mult(char a, char b); 
    107113 
    108114char find_sync(char sync[]); 
    109  
     115int crc16_update(uint16_t crc, uint8_t data); 
    110116 
    111117#endif //RS_H 
Note: See TracChangeset for help on using the changeset viewer.