Changeset 380


Ignore:
Timestamp:
09/10/09 14:34:14 (3 years ago)
Author:
dg1yfe
Message:

Immernoch Fehler bei RX: Sporadische Deadlocks (alle Tasks im Suspended State oder Deadlock bei SPI Zugriff. Vermutung: Ungültiger Schreibzugriff im Speicher überschreibt Task Context (Tast state o.ä.))

Start nun mit LCD Test (schwarzer Bildschirm für ca 0,5 s)

Location:
branches/yfe_rtos
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • branches/yfe_rtos/FiFiSMSer.c

    r379 r380  
    122122        SPCR = (0<<SPIE)        // SPI Interrupt disable 
    123123                | (1<<SPE)              // SPI Enable  
    124                 | (0<<DORD)     // Data Order: MSB First 
    125                 | (1<<MSTR)     // Master Mode 
    126                 | (0<<CPOL)     // Leading Edge: rising 
    127                 | (0<<CPHA)     // Leading Edge: Sample 
    128                 | (0<<SPR1)     // SPI Clock 
     124                | (0<<DORD)         // Data Order: MSB First 
     125                | (1<<MSTR)         // Master Mode 
     126                | (0<<CPOL)    // Leading Edge: rising 
     127                | (0<<CPHA)         // Leading Edge: Sample 
     128                | (0<<SPR1)         // SPI Clock 
    129129                | (1<<SPR0);    // SPI Clock : Clock/4 //DEBUG 
    130130 
    … …  
    210210    } 
    211211     
    212       
    213     if (xTaskCreate( vTaskMain, (signed portCHAR*) MainStr, 224, NULL, 0, NULL) != pdPASS){ 
     212    // Main Task (UI Task) erzeugen und starten 
     213    // Stackgröße = 224 Bytes 
     214    // Priorität = 1 (normal) 
     215  
     216    if (xTaskCreate( vTaskMain, (signed portCHAR*) MainStr, 224, NULL, 1, NULL) != pdPASS){ 
    214217        for(;;); 
    215218    } 
    … …  
    250253        GLOBALFLAGS.IsPowerOn = true; 
    251254 
    252  
    253     if (xTaskCreate( vCronTask, (signed portCHAR*) CronStr, 128, NULL, 0, NULL) != pdPASS){ 
     255    // Cron Task erzeugen und starten 
     256    // Stackgröße = 128 Bytes 
     257    // Priorität = 1 (normal) 
     258    if (xTaskCreate( vCronTask, (signed portCHAR*) CronStr, 128, NULL, 1, NULL) != pdPASS){ 
    254259        for(;;); 
    255260    } 
    256261     
    257262 
    258  
    259     if (xTaskCreate( vRxTask, (signed portCHAR*) L2RXStr, 128, NULL, 1, NULL) != pdPASS){ 
     263    // L2RX Task erzeugen und starten 
     264    // Stackgröße = 128 Bytes 
     265    // Priorität = 2 (hoch) 
     266    if (xTaskCreate( vRxTask, (signed portCHAR*) L2RXStr, 128, NULL, 2, NULL) != pdPASS){ 
    260267        for(;;); 
    261268    } 
    … …  
    263270 
    264271        Screen_DrawStandby();         
     272 
    265273    for(;;) 
    266274        { 
    … …  
    301309                if (Keypad_lastScanCode == Keypad_SC_2) 
    302310                { 
     311                uint8_t status=TakeSpiMutex(portMAX_DELAY); 
    303312                        RFM12_PHY_modeRX(); 
     313                GiveSpiMutex(status); 
    304314                } 
    305315         
    … …  
    338348          
    339349                Keypad_WaitForKeyStroke(); 
     350         
    340351        } 
     352         
     353/*         
     354    uint8_t MenuStack[4]; 
     355 
     356    MenuStack[0]=0; 
     357 
     358    for(;;) 
     359    { 
     360        uint8_t ShowNext=0; 
     361        uint8_t MenuIndex=0; 
     362 
     363                Screen_DrawStandby(); 
     364                 
     365                Keypad_WaitForKeyStroke(); 
     366         
     367        switch(Keypad_lastScanCode) 
     368        { 
     369            case Keypad_SC_MRechts: 
     370            { 
     371                if (GLOBALFLAGS.NewRX) 
     372                { 
     373                    //Screen_ShowNachrichten(); 
     374                    ShowNext = SHOW_MESSAGE;  
     375                } 
     376                else 
     377                { 
     378                    ShowNext = SHOW_MHEARD; 
     379                } 
     380                break; 
     381            } 
     382            case Keypad_SC_MLinks: 
     383            { 
     384                ShowNext = MAIN_MENU; 
     385                break; 
     386            } 
     387            case Keypad_SC_5: 
     388            { 
     389                SmpBuf.addr = 0x2000; 
     390                CVSD_active = 1; 
     391                vTaskDelay(100);        // Sicherstellen, dass SmpBuf gefüllt ist 
     392                TIMSK1 |= _BV(TOIE1); 
     393                break; 
     394            } 
     395            case Keypad_SC_6: 
     396            { 
     397                CVSD_active = 0; 
     398                TIMSK1 &= ~_BV(TOIE1); 
     399                break; 
     400            }              
     401        } 
     402         
     403         
     404        // Dialoge anzeigen 
     405        // Ziel dieser Implementation ist es, Speicher zu sparen indem das verschachtelte 
     406        // Aufrufen von Menüs vermieden wird. 
     407        do 
     408        { 
     409            if (ShowNext!=0) 
     410            { 
     411                if (MenuIndex==3) 
     412                { 
     413                    strncpy(&MenuStack[1], &MenuStack[2], 3); 
     414                    MenuIndex--; 
     415                } 
     416                MenuStack[++MenuIndex]=ShowNext; 
     417            } 
     418 
     419            switch(MenuStack[MenuIndex--]) 
     420            { 
     421                case MAIN_MENU: 
     422                { 
     423                    ShowNext=MainMenu(); 
     424                    break; 
     425                } 
     426                case SHOW_MESSAGE: 
     427                { 
     428                    break; 
     429                } 
     430                case EDIT_MESSAGE: 
     431                { 
     432                    break; 
     433                } 
     434                case MHEARD: 
     435                { 
     436                    break; 
     437                } 
     438                case ERWEITERT: 
     439                { 
     440                    break; 
     441                } 
     442                case SETUP: 
     443                { 
     444                    break; 
     445                } 
     446                case AUSSCHALTEN: 
     447                { 
     448                    break; 
     449                } 
     450                default: 
     451                { 
     452                    break; 
     453                } 
     454            }        
     455        }while(MenuIndex!=0) 
     456    } 
     457         
     458*/         
    341459} 
    342460 
    … …  
    357475void vApplicationIdleHook( void ){ 
    358476    //idleCtr++;     
     477     
     478    // TODO: 
     479    // Sleep Mode aktivieren (Takt auf 1 MHz runtersetzen) 
    359480}; 
    360481 

  • branches/yfe_rtos/FreeRTOSConfig.h

    r379 r380  
    7272#define configCPU_CLOCK_HZ              ( ( unsigned portLONG ) 8000000 ) 
    7373#define configTICK_RATE_HZ              ( ( portTickType ) 1000 ) 
    74 #define configMAX_PRIORITIES            ( ( unsigned portBASE_TYPE ) 2 ) 
     74#define configMAX_PRIORITIES            ( ( unsigned portBASE_TYPE ) 3 ) 
    7575#define configMINIMAL_STACK_SIZE        ( ( unsigned portSHORT ) 72 ) 
    7676#define configTOTAL_HEAP_SIZE           ( (size_t ) ( 1300 ) ) 

  • branches/yfe_rtos/LCD.c

    r379 r380  
    1818#include "FontJumptable.h" 
    1919#include "MenuSetup.h" 
     20 
    2021#include "FreeRTOS.h" 
     22#include "portable.h" 
     23#include "task.h" 
     24 
    2125#include "EEPROM.h" 
    2226 
    … …  
    2529 
    2630// Merker für XorMaske 
    27 static uint8_t _LCD_XorMaske; 
     31uint8_t LCD_XorMaske; 
     32uint8_t LCD_Cursor=0; 
    2833 
    2934static inline void LCD_Reset(void); 
     35 
    3036 
    3137 
    … …  
    4652{ 
    4753        PORTC &= ~(1 << PORTC4);         
    48         _delay_ms(1); 
     54        vTaskDelay( 1 / portTICK_RATE_MS);                 // 1 ms warten 
     55//      _delay_ms(1); 
    4956         
    5057        PORTC |= (1 << PORTC4); 
    51         _delay_ms(1); 
     58        vTaskDelay( 1 / portTICK_RATE_MS);                 // 1 ms warten 
     59//      _delay_ms(1); 
    5260} 
    5361 
    … …  
    6068inline void LCD_Init(void) 
    6169{ 
    62         _LCD_XorMaske = 0x00; 
     70        LCD_XorMaske = 0x00; 
    6371        _LCD_FontTyp = 1; 
    6472 
    6573        LCD_Reset(); 
    66         _delay_ms(10); 
     74//      _delay_ms(10); 
     75        vTaskDelay( 10 / portTICK_RATE_MS);                 // 10 ms warten 
    6776 
    6877        //Initialisierung 
    6978        LCD_WriteCmd(LCD_FunctionSet | LCD_FSExtended);         // Erweiterter Kommando-Mode 
    70         LCD_WriteCmd(LCD_SetVop | (40 + SetupValues.Kontrast)   );                                      //&HC8  Mittlerer Kontrast (nur im erweiterten Mode) 
     79        LCD_WriteCmd(LCD_SetVop | (40 + SetupValues.Kontrast)   );      //&HC8  Mittlerer Kontrast (nur im erweiterten Mode) 
    7180        //LCD_WriteCmd(LCD_SetVop | 70); 
    7281        LCD_WriteCmd(LCD_TempControl | 2);                                      // Temperatur-Ausgleich (nur im erweiterten Mode) 
    7382        LCD_WriteCmd(LCD_BiasSystem | 3);                                       // Bias 1:48 (optimum) (nur im erweiterten Mode) 
    7483        LCD_WriteCmd(LCD_FunctionSet);                                          // Normaler Kommando-Mode 
     84        LCD_WriteCmd(LCD_DisplayControl | LCD_DCDisplayAllOn); // invertierte Ausgabe (nur im normalen Mode) 
     85 
     86        vTaskDelay( 600 / portTICK_RATE_MS);                 // 600 ms warten 
     87 
    7588        LCD_WriteCmd(LCD_DisplayControl | LCD_DCDisplayNorm); //Normale, nicht invertierte Ausgabe (nur im normalen Mode) 
    7689 
    … …  
    8497{ 
    8598        _LCD_FontTyp = FontTyp; 
    86         _LCD_XorMaske = XorMaske; 
     99        LCD_XorMaske = XorMaske; 
    87100} 
    88101 
    … …  
    110123                loop_until_bit_is_set(SPSR,SPIF); // Warten bis alle Bits raus 
    111124                 
    112         //uint8_t dummy = SPDR; // Pseudolesen zum löschen des Flags -> TODO: Ist das Löschen des Flags wirklich nötig? 
    113  
    114125                // LCD als Empfänger für den SPI abwählen (low-aktiv) 
    115126                PORTD |= (1 << CS_LCD); 
    … …  
    152163 
    153164// Schreibt den an gegebenen Flash-String aufs Display 
    154 void LCD_PutString_P(const char *progstr) 
     165uint8_t LCD_PutString_P(const char *progstr) 
    155166{        
    156         char c; 
     167        uint8_t i=0; 
     168    char c;     
    157169        while ( (c = pgm_read_byte(progstr++)) ) 
    158170        { 
    159171                LCD_PutChar(c); 
    160         } 
     172        i++; 
     173        } 
     174    return i; 
    161175} 
    162176 
    … …  
    208222                        Bitmuster = pgm_read_byte(CharPointer++);  
    209223                        ende = (Bitmuster & 0x01) == 1; 
    210                         Bitmuster = (Bitmuster & 0xFE) ^ _LCD_XorMaske; 
     224                        Bitmuster = (Bitmuster & 0xFE) ^ LCD_XorMaske; 
    211225                        LCD_WriteData(Bitmuster); 
    212226                } while (!ende); 
    213227        } 
    214         LCD_WriteData(_LCD_XorMaske);  // Die Leerspalte hinter dem Buchstaben ausgeben 
     228        LCD_WriteData(LCD_Cursor^ LCD_XorMaske);  // Die Leerspalte hinter dem Buchstaben ausgeben 
    215229 
    216230} //endof Proc 

  • branches/yfe_rtos/LCD.h

    r379 r380  
    4545#define LCD_SetVop              0b10000000 
    4646 
     47#define FontStyle_Underline 0x80 
     48#define FontStyle_Invert    0x7E 
    4749 
     50extern uint8_t LCD_XorMaske; 
    4851 
    4952// Initialisisert das Display 
    … …  
    6366void LCD_WriteCmd(const uint8_t Cmd); 
    6467 
     68 
    6569// Löscht den LCD Bildschirm 
    6670void LCD_ClearScreen(void); 
    … …  
    7377 
    7478// Schreibt den angegebenen Flash-String auf den Bildschirm 
    75 void LCD_PutString_P(const char  *progstr); 
     79uint8_t LCD_PutString_P(const char  *progstr); 
    7680 
    7781// Schreibt die angegebene Grafik auf den Bildschirm 

  • branches/yfe_rtos/MHeard.c

    r373 r380  
    1919        for (uint8_t i = 0; i < MHEARD_MAX; i++) 
    2020        { 
    21                 MHListe[i].HeardTime = 0; 
     21                MHListe[i].HeardTime = MHEARD_MAX-i; 
    2222                strcpy_P(MHListe[i].Name, STR_TempCall); 
    2323        }        
    … …  
    2828{ 
    2929        uint8_t OldPos = MHEARD_MAX; // "Hinter der Liste" 
    30         uint32_t LastHeard = 0; 
     30        uint16_t LastHeard = 0; 
    3131         
    3232        for (uint8_t i = 0; i < MHEARD_MAX; i++) 
    … …  
    5656        } 
    5757 
     58 
    5859        while(OldPos > 0) 
    5960        { 
    … …  
    6566        } 
    6667 
    67         // Erste Eintrag erstellen 
    68         strncpy(MHListe[0].Name, Name, ADDRESS_MAXCHAR); 
    69         MHListe[0].HeardTime = (Timer_LifeTimeCounter >> 4)+1; 
    7068} 
    7169 

  • branches/yfe_rtos/MenuMain.c

    r373 r380  
    3434const char PROGMEM MM_6[] = "Ausschalten"; 
    3535 
    36  
     36/* 
     37void MainMenu() 
     38{ 
     39    Screen_DrawMenu(MM_Titel); 
     40     
     41} 
     42*/ 
    3743 
    3844// Menü-Funktion MHeard Liste 

  • branches/yfe_rtos/MenuNachrichten.c

    r372 r380  
    3636         
    3737        // Message Buffer leeren 
    38         memset(Message_EditBuffer->Nachricht, 0, sizeof(Message_EditBuffer->Nachricht)); 
    39          
     38        //memset(Message_EditBuffer->Nachricht, 0, sizeof(Message_EditBuffer->Nachricht)); 
     39        Message_EditBuffer->Nachricht[0]=0; 
    4040         
    4141        Screen_DoMsgEdit(Message_EditBuffer->Nachricht, sizeof(Message_EditBuffer->Nachricht), MN_1, true);   

  • branches/yfe_rtos/MenuSetup.c

    r379 r380  
    141141static char* GetAddStr_MS_7(char* Buffer) 
    142142{ 
    143         // TODO: Frequenzwert mit itoa umwandeln! (Speicher sparen) 
    144         if (SetupValues.Frequenz == 0) 
     143    // TODO: Frequenzwert mit itoa umwandeln! (Speicher sparen) 
     144     
     145    /* 
     146    if (SetupValues.Frequenz == 0) 
    145147                return strcat_P(Buffer, STR_QRG0); 
    146148         
    147149        if (SetupValues.Frequenz == 1) 
    148150                return strcat_P(Buffer, STR_QRG1); 
    149          
     151    */     
    150152         
    151         return strcat_P(Buffer, STR_QRG2); 
     153        return strcat_P(Buffer, &STR_QRG[SetupValues.Frequenz][0]); 
    152154} 
    153155 
    … …  
    205207static uint8_t Exec_MS_1(void) 
    206208{ 
    207         memset(buf, 0, sizeof(buf)); 
     209        //memset(buf, 0, sizeof(buf)); 
    208210        // Eigentlich sollte immer die größe von Empfangsbuffer angegeben werden,  
    209211        // Da aber der SrcBuf kleiner ist, und evtl auch mal ganz voll ist, ist maxLen = sizeof(srcbuf) 
    210212        strncpy(buf, (const char*)SetupValues.UserID, sizeof(SetupValues.UserID)); 
     213    buf[8]=0; 
    211214        if (Screen_DoMsgEdit(buf, 8, MS_1, false) == true) 
    212215        { 

  • branches/yfe_rtos/MenuVerfassen.c

    r373 r380  
    8282static uint8_t Exec_MV_2(void) 
    8383{ 
    84         memset(buf, 0, sizeof(buf));                                            // Buffer leeren 
    85         strcpy(buf, Message_EditBuffer->Header.Empfaenger);     // Evtl vorhandenen Empfänger übernehmen 
    86  
     84        //memset(buf, 0, sizeof(buf));                                          // Buffer leeren 
     85        strncpy(buf, Message_EditBuffer->Header.Empfaenger, ADDRESS_MAXCHAR);   // Evtl vorhandenen Empfänger übernehmen 
     86    buf[8] = 0; 
    8787        if (Screen_DoMsgEdit(buf, ADDRESS_MAXCHAR, MV_2, false) == true) // Editieren 
    8888        { 
    89                 strcpy(Message_EditBuffer->Header.Empfaenger, buf); // Wenn OK, dann übernehmen 
     89                //strcpy(Message_EditBuffer->Header.Empfaenger, buf); // Wenn OK, dann übernehmen 
     90                strncpy(Message_EditBuffer->Header.Empfaenger, buf, sizeof(Message_EditBuffer->Header.Empfaenger));      
    9091        } 
    9192         

  • branches/yfe_rtos/Message.c

    r379 r380  
    9999                        Flags.AsByte = spieeprom_read_byte((uint32_t) ((uint16_t)&(PtrToMsg->Flags))); 
    100100 
    101                         // Wir haben eine Nachricht gefunden  
    102                         //if (Flags.AsFlags.Status == MessageFlagStatusQueue) 
    103101                        if ((Flags.AsFlags.Status == MessageStatus) || 
    104102                (Flags.AsFlags.Status == MessageStatus2)) 
    105103            { 
    106                 // Nachricht in Sendewarteschlange hängen (als EEPROM Nachricht mit Buffer=NULL) 
    107                 // TxMessageToQueue(NULL,1,0,SetupValues.Sendeversuche,MessageBlockNr); 
     104                       // Nachricht mit gesuchtem Status gefunden 
    108105                break; // raus hier 
    109106            } 
    … …  
    173170            if (MsgPtr == NULL){                      // nur bei nachrichten aus ext. EEPROM: 
    174171                uint8_t j; 
    175                 for(j=Priority;j<TxQueueLength;j++){    // prüfen ob EEPROM Nachricht bereits in der Liste ist 
    176                     if (TxMessageQueue[i].EepBlock == EepBlock) 
     172                for(j=0;j<TxQueueLength;j++){    // prüfen ob EEPROM Nachricht bereits in der Liste ist 
     173                    if (TxMessageQueue[j].EepBlock == EepBlock) 
    177174                    { 
    178175                        return true;                    // Falls das der Fall ist, Erfolg melden, aber nicht erneut einhängen 
    … …  
    199196            (TxMessageQueue[i].EepBlock!=0))       
    200197        { 
    201             if (TxMessageQueue[i].TimeToWait == 0){        // und die Wartezeit (in s) abgelaufen ist 
     198            if (TxMessageQueue[i].TimeToWait == 0)         // und die Wartezeit (in s) abgelaufen ist 
     199            { 
    202200                 
    203201                if (TxMessageQueue[i].Ptr == NULL)         // Nachricht aus EEPROM ? 
    … …  
    205203                    TxMessageQueue[i].Ptr = pvPortMalloc(TRXBufSize); // dann erstmal ins RAM kopieren 
    206204                     
    207                     if (TxMessageQueue[i].Ptr != NULL){      // Nur aus EEPROM lesen, wenn Pufferspeicher frei ist 
     205                    if (TxMessageQueue[i].Ptr != NULL)      // Nur aus EEPROM lesen, wenn Pufferspeicher verfügbar ist 
     206                    { 
    208207                                                             // Nachricht in TxBuffer laden                      
    209208                        uint16_t PtrToMsg = EE_BlockSize * TxMessageQueue[i].EepBlock; 
    … …  
    251250            else 
    252251            { 
    253                 TxMessageQueue[i].TimeToWait--; 
     252                TxMessageQueue[i].TimeToWait--;     // Wartezeit um 1s vermindern 
    254253            } 
    255254        } 
    … …  
    264263    if (TxFrameBuf == NULL) // Sendepuffer verfügbar? 
    265264    { 
    266     // ACK zu senden? - Ack wird von RX Behandlung erzeugt und in TX Schlange eingereiht 
    267     // Nachricht aus EEPROM zu senden? - dies wird nur noch jede Sekunden geprüft, viel schneller 
    268     // kann keine neue Nachricht dazu kommen         
    269         WalkTxQueue(); 
     265        WalkTxQueue();      // Prüfen ob eine Nachricht sendebereit ist 
    270266    } 
    271267} 
    … …  
    339335                                                                                                // ('Pass by Reference' für MessageBuffer (den Zeiger) und 
    340336                                                                                                // nicht nur 'Pass by Reference' für den Nachrichtenpuufer) 
     337     
     338    //   MsgbufptrPtr = Adresse von Zeiger auf Nachrichtenspeicher 
     339    //  *MsgbufptrPtr =             Zeiger auf Nachrichtenspeicher  
     340    // **MsgbufptrPtr =                        Nachrichtenspeicher 
     341     
    341342        uint8_t  i = 0; 
    342343    uint8_t  MessageBlockNr; 
    … …  
    408409        { 
    409410                // Ack Message rausschicken 
    410         // TODO: Empfangene Nachricht wurde soeben gespeichert -> Buffer für ACK ist verfügbar! 
     411        // Empfangene Nachricht wurde soeben gespeichert -> Buffer für ACK ist verfügbar! 
    411412         
    412413                // Antwort vorbereiten 
    … …  
    441442            RxMessageQueue[i].Ptr = NULL;                     // Nachricht aus Empfangsliste streichen 
    442443             
    443             MHeard_NewHeard(MessageBuffer->Header.Absender);  // Absender in MH Liste eintragen (nicht nur bei Baken!) 
     444          //  MHeard_NewHeard(MessageBuffer->Header.Absender);  // Absender in MH Liste eintragen (nicht nur bei Baken!) 
    444445             
    445446            switch (MessageBuffer->Header.Flags.Type)         // Typ der Nachricht prüfen 
    446447            { 
    447             case MessageFlagsTypeAck:               // Es wurde ein ACK empfangen 
    448                 Message_Cron_RxAck(MessageBuffer);  // nach passender Nachricht suchen und ggf. markieren 
    449                 break; 
    450             case MessageFlagsTypeBake:               // Es wurde eine Bake empfangen 
    451                 Message_UserHeard(MessageBuffer);    // Nach nicht zugestellten Nachrichten suchen 
    452                 break;                                 
    453             case  MessageFlagsTypeText : 
    454                 Message_Cron_RxText(&MessageBuffer);    // Zeiger auf MsgPtr übergeben 
    455                 break;                                                                  // Falls Buffer für Ack verwendet wird, wird der Ptr = NULL 
    456             } 
    457              
    458             if (MessageBuffer != NULL)  // nachricht wurde verarbeitet, Speicher freigeben 
    459             { 
    460                 vPortFree(MessageBuffer); 
    461             } 
     448                case MessageFlagsTypeAck: 
     449                {                                          // Es wurde ein ACK empfangen 
     450                    Message_Cron_RxAck(MessageBuffer);     // nach passender Nachricht suchen und ggf. markieren 
     451                    break; 
     452                } 
     453                case MessageFlagsTypeBake: 
     454                {                                          // Es wurde eine Bake empfangen 
     455                    Message_UserHeard(MessageBuffer);      // Nach nicht zugestellten Nachrichten suchen 
     456                    break;                                 
     457                } 
     458                case  MessageFlagsTypeText : 
     459                {             
     460                    Message_Cron_RxText(&MessageBuffer);        // Zeiger auf MsgPtr übergeben 
     461                    break;                                                                      // Falls Buffer für Ack verwendet wird, wird der Ptr = NULL 
     462                } 
     463            } 
     464             
     465//            if (MessageBuffer != NULL)  // nachricht wurde verarbeitet, Speicher freigeben 
     466//            { 
     467            vPortFree(MessageBuffer); 
     468//            } 
    462469        } 
    463470    } 
    464471} 
     472 
    465473 
    466474 

  • branches/yfe_rtos/Message.h

    r379 r380  
    105105// Buffer für zu lesende/schreibende Nachrichten 
    106106extern Message_t *Message_EditBuffer; 
    107 extern Message_t Message_RxDoubleBuffer; 
    108107 
    109108extern TxMessageQueue_t TxMessageQueue[]; 

  • branches/yfe_rtos/RFM12_MAC.c

    r379 r380  
    138138        } 
    139139        case 7: 
    140                 default:{ 
     140                default: 
     141        { 
    141142            counter = 0; 
    142143            tx_state = 0; 
    143144            RFM12_MAC_endCtrlTransmission(); 
    144145            GLOBALFLAGS.IsTXing = false; 
    145             if ( TxFrameBuf!=NULL ){ 
    146                 vPortFree( (void *) TxFrameBuf ); 
    147                 TxFrameBuf = NULL; 
    148             } 
     146            vPortFree( (void *) TxFrameBuf ); 
     147            TxFrameBuf = NULL; 
    149148             
    150             if ( TxParityBuf!=NULL ){ 
    151                 vPortFree( (void *) TxParityBuf ); 
    152                 TxParityBuf = NULL; 
    153             } 
     149            vPortFree( (void *) TxParityBuf ); 
     150            TxParityBuf = NULL; 
     151 
    154152            return(0); 
    155153        }     

  • branches/yfe_rtos/RFM12_PHY.c

    r379 r380  
    267267            case RFM12_RX:{ 
    268268                //Timer_SetSystemSpeed_Slow(RFM_ISR | FORCE); 
     269                if( RFM12_EndRx ) 
     270                { 
     271                        RFM12_PHY_modeRX();  // RX beenden 
     272                } 
    269273                uint8_t data; 
    270274                data = RFM12_fifoRead();   // Daten von RFM12 lesen 
    271                                 // Daten an L2RxTask weiterleiten, Task damit ggf. aufwecken 
    272                                 if( RFM12_EndRx || 
    273                    (xQueueSendToBackFromISR(RxDataInHandle, &data, (int8_t *) &xHigherPriorityTaskWoken)==errQUEUE_FULL)) 
     275                                           // Daten an L2RxTask weiterleiten, Task damit ggf. aufwecken 
     276                                if(xQueueSendToBackFromISR(RxDataInHandle, &data, (int8_t *) &xHigherPriorityTaskWoken)==errQUEUE_FULL) 
    274277                                {                             
    275278                        RFM12_PHY_modeRX();  // Queue voll -> Abbruch, RFM12 soll wieder auf Sync warten 

  • branches/yfe_rtos/Ressources.c

    r369 r380  
    4747////////////// Strings 
    4848const char STR_DeviceName[]     PROGMEM = "FiFiSMSer"; 
    49 const char STR_Ausschalten[]    PROGMEM = "Ausschalten ?"; 
     49const char STR_Ausschalten[]    PROGMEM = "Ausschalten?"; 
    5050const char STR_TempCall[]               PROGMEM = "NOCALL"; 
    5151const char STR_NoTime[]             PROGMEM = "xx:xx"; 
    … …  
    5353const char STR_EintragLoeschen[] PROGMEM = "Eintrag löschen?"; 
    5454const char STR_min[]            PROGMEM = "min"; 
    55 const char STR_ERROR[]          PROGMEM = "Not see me"; 
    5655const char STR_MHListe[]        PROGMEM = "MH Liste"; 
    5756const char ST_Details[]         PROGMEM = "Details"; 
    … …  
    5958const char STR_Empf[]           PROGMEM = "Empf: "; 
    6059const char STR_Zeit[]           PROGMEM = "Zeit:"; 
    61 const char STR_KeinEmpf[]       PROGMEM = "Kein Empfänger gesetzt. An alle senden ?"; 
     60const char STR_KeinEmpf[]       PROGMEM = "Kein Empfänger gesetzt. An alle senden?"; 
    6261const char STR_Alle[]           PROGMEM = "CQ"; 
    6362const char STR_Ansehen[]        PROGMEM = "Ansehen"; 
    … …  
    6564const char STR_EIN[]            PROGMEM = "ein"; // ProgString "ein" 
    6665const char STR_MsgQueued[]      PROGMEM = "Msg in Postaus- gang eingereiht"; 
    67 const char STR_MsgEntwurf[] PROGMEM = "Messageentwurf abgespeichert"; 
     66const char STR_MsgEntwurf[] PROGMEM = "Entwurf gespeichert"; 
    6867const char STR_Entwurf[]        PROGMEM = "ENTWURF"; 
    6968const char STR_SaveFailed[]     PROGMEM = "Speicher voll! Nicht gespeichert"; 
    … …  
    9392 
    9493// Entsprechend Ticket #12 
     94/* 
    9595const char STR_QRG0[]   PROGMEM = "434.500"; 
    9696const char STR_QRG1[]   PROGMEM = "439.700"; 
    9797const char STR_QRG2[]   PROGMEM = "434.900"; 
     98*/ 
     99const char STR_QRG[3][8]        PROGMEM = {"434.500", "439.700", "434.900"}; 
    98100 
    99101 

  • branches/yfe_rtos/Ressources.h

    r369 r380  
    5050extern const char PROGMEM STR_EintragLoeschen[]; 
    5151extern const char PROGMEM STR_min[]; 
    52 extern const char PROGMEM STR_ERROR[]; 
    5352extern const char PROGMEM STR_MHListe[]; 
    5453extern const char PROGMEM ST_Details[]; 
    … …  
    9190extern const char PROGMEM STR_RXed[]; 
    9291 
    93 extern const char STR_QRG0[]; 
     92extern const char STR_QRG[][8]; 
    9493#define QRG0    434.500 
    9594 

  • branches/yfe_rtos/Screen.c

    r379 r380  
    102102        LCD_SetFontAttribs(FontTyp_Small,0); 
    103103 
    104         uint16_t ADRechnung = ADC_Messwert * 100; 
    105         uint16_t Ergebnis = ADRechnung / 112; 
    106  
     104        //uint16_t ADRechnung = ADC_Messwert * 100; 
     105        //uint16_t Ergebnis = ADRechnung / 112; 
     106 
     107    uint16_t Ergebnis = ADC_Messwert >> 3;      // *25/28 ist ungefähr 7/8 (Abweichung 2%) 
     108                                                // Diese Genauigkeit ist ausreichend für den Zweck der 
     109                                                // Batteriespannungsanzeige (6 mV Abweichung bei 3 Volt) 
     110    Ergebnis = ADC_Messwert - Ergebnis;         // Die Berechnung erfordert allerdings nur Shift und Subtraktion 
     111                                                // Anstelle einer Multiplikation und einer Division 
    107112        itoa(Ergebnis, buf, 10); 
    108113 
    109         if (strlen(buf) == 2) 
     114        //if (strlen(buf) == 2) 
     115        if (buf[2] == 0) 
    110116        { 
    111117                LCD_PutChar('0'); 
    … …  
    159165    
    160166        //Es folgt die Ausgabe des Rufzeichens: 
    161         memset(buf, 0, sizeof(buf)); 
     167        //memset(buf, 0, sizeof(buf)); 
     168 
    162169        strncpy(buf, (const char*)SetupValues.UserID, ADDRESS_MAXCHAR); 
    163         unsigned char xpos = 42 - LCD_MeasureString(buf) / 2; 
     170        buf[8]=0;   // 0-terminieren 
     171     
     172    unsigned char xpos = 42 - LCD_MeasureString(buf) / 2; 
    164173        LCD_SetTextCursor(xpos, 2); 
    165174        LCD_PutString(buf); 
    166175 
    167176        //Es folgt die Ausgabe der eingestellten Frequenz: 
    168         memset(buf, 0, sizeof(buf)); 
    169         if (SetupValues.Frequenz == 0) 
    170                 strcat_P(buf, STR_QRG0); 
    171         if (SetupValues.Frequenz == 1) 
    172                 strcat_P(buf, STR_QRG1); 
    173         if (SetupValues.Frequenz == 2) 
    174                 strcat_P(buf, STR_QRG2); 
     177        strncpy_P(buf, &STR_QRG[SetupValues.Frequenz][0], 7); 
     178   
     179    buf[7]=0; 
     180     
    175181        LCD_SetTextCursor(28, 3); 
    176182        LCD_SetFontAttribs(FontTyp_Small,0); 
    … …  
    840846                                { 
    841847                                        cursor--; 
    842                                         strcpy(&Buffer[cursor],&Buffer[cursor+1]); 
     848                                        //strcpy(&Buffer[cursor],&Buffer[cursor+1]); 
     849                    // strcpy rausgeworfen -> wird sonst nirgendwo gebraucht 
     850                    // daher spart die "zu Fuß" Implementation hier Flash 
     851                    uint8_t i = cursor; 
     852                    do 
     853                    { 
     854                        Buffer[i] = Buffer[i+1]; 
     855                    } while(Buffer[i]!=0); 
    843856                                } 
    844857                                else{ 
    … …  
    9991012                        if (!GLOBALFLAGS.IsKeyAgain) // Lücke schaffen 
    10001013                        { 
    1001                                 for (uint8_t i = Len; i > cursor; i--) 
    1002                                         Buffer[i] = Buffer[i-1]; 
    1003  
    1004                                 Buffer[actualStrLen+1] = 0; 
     1014                                for (uint8_t i = Len+1; i > cursor; i--) 
     1015                                        Buffer[i] = Buffer[i-1];                 
     1016                //Buffer[actualStrLen+1] = 0; 
    10051017                        } 
    10061018                        Buffer[cursor] = key;   // Zeichen setzen                        
    1007                         cursor++;       // weiter 
     1019                        cursor++;                   // weiter 
    10081020                } 
    10091021        } 
    10101022} 
     1023 
    10111024 
    10121025 
    … …  
    10181031        uint8_t cursorIdx = 1; 
    10191032        uint8_t menuLen = MHEARD_MAX;    
     1033        Message_t *Screen_ShowMhBuf = NULL; 
    10201034 
    10211035        while(1) 
    … …  
    10621076                                LCD_PutChar(' ');*/ 
    10631077                                //Zeitspanne bestimmen und in Stunden und Minuten aufspalten 
    1064                                 div_t HoursMins = div(Timer_GetTimeSpanMins(MHListe[topIdx-1+i].HeardTime<<4), 60); 
     1078                                div_t HoursMins = div(Timer_GetTimeSpanMins(((uint32_t)MHListe[topIdx-1+i].HeardTime-1)<<4), 60); 
    10651079                                if (HoursMins.quot > 99){ 
    10661080                                  //mehr als 99:59 Stunden her - nur noch xx:xx anzeigen statt Zeit 
    … …  
    10721086                                        itoa(HoursMins.quot, buf, 10); 
    10731087                                        if (HoursMins.quot < 10){ 
    1074                                                 LCD_PutString_P(&STR_QRG0[6]);//Falls nötig führende Null einfügen 
     1088                                                LCD_PutChar('0');  
    10751089                                        } 
    1076                                                 //LCD_PutChar('0');  
    10771090                                        LCD_PutString(buf); 
    10781091                                        //Zwischendurch Doppelpunkt 
    … …  
    10811094                                        itoa(HoursMins.rem, buf, 10); 
    10821095                                        if (HoursMins.rem<10){  
    1083                                                 LCD_PutString_P(&STR_QRG0[6]);//Falls nötig führende Null einfügen 
    1084                                                 //LCD_PutChar('0'); //Falls nötig führende Null einfügen 
     1096                                                LCD_PutChar('0'); //Falls nötig führende Null einfügen 
    10851097                                        } 
    10861098                                        LCD_PutString(buf); 
    … …  
    10951107                                        LCD_SetFontAttribs(FontTyp_Norm,0x00); 
    10961108                                // Namen aus der MH Liste kopieren 
    1097                                 memset(buf, 0, sizeof(buf)); 
     1109                                //memset(buf, 0, sizeof(buf)); 
    10981110                                strncpy(buf, MHListe[topIdx-1+i].Name, ADDRESS_MAXCHAR); 
    1099                                 LCD_PutString(buf); 
     1111                                buf[ADDRESS_MAXCHAR]=0; 
     1112                LCD_PutString(buf); 
    11001113                        } 
    11011114                } 
    … …  
    11331146                        if (retval == 2) 
    11341147                        { 
    1135                                 Message_EditBuffer = pvPortMalloc(TRXBufSize); 
    1136                                 if (Message_EditBuffer!= NULL){ 
     1148                                Screen_ShowMhBuf = pvPortMalloc(TRXBufSize); 
     1149                                if (Screen_ShowMhBuf!= NULL){ 
    11371150                                        // Absender als Empfänger setzen 
    1138                                         strncpy(Message_EditBuffer->Header.Empfaenger, MHListe[cursorIdx-1].Name,        ADDRESS_MAXCHAR); 
     1151                                        strncpy(Screen_ShowMhBuf->Header.Empfaenger, MHListe[cursorIdx-1].Name,  ADDRESS_MAXCHAR); 
    11391152                                        // Message Buffer leeren 
    1140                                         memset(&Message_EditBuffer->Nachricht, 0, TRXBufSize); 
    1141  
    1142                                         Screen_DoMsgEdit(Message_EditBuffer->Nachricht, sizeof(Message_EditBuffer->Nachricht), MH_1, true); 
     1153                                        //memset(&Screen_ShowMhBuf->Nachricht, 0, TRXBufSize); 
     1154                    Screen_ShowMhBuf->Nachricht[0]=0; 
     1155                                        Screen_DoMsgEdit(Screen_ShowMhBuf->Nachricht, sizeof(Screen_ShowMhBuf->Nachricht), MH_1, true); 
    11431156                                } 
    11441157                        } 
    … …  
    11461159        } 
    11471160} 
     1161 
    11481162 
    11491163 
    … …  
    11521166        uint8_t topIdx = 1; 
    11531167        uint8_t cursorIdx = 1; 
    1154  
     1168        Message_t *Screen_MsgBuffer = NULL; 
    11551169        // Länge ermitteln 
    11561170        while(1) 
    … …  
    12161230                        } 
    12171231                        void* MsgPtr = (void*)(EE_BlockSize * MessageBlockNr); 
    1218             Message_EditBuffer = (void *) buf;       // Message_EditBuffer auf "buf" (20 Zeichen) zeigen lassen             
    1219                         spieeprom_read_block((uint32_t) ((uint16_t) MsgPtr), Message_EditBuffer, sizeof(MessageHeader_t)); 
     1232            Screen_MsgBuffer = (void *) buf;       // Message_EditBuffer auf "buf" (20 Zeichen) zeigen lassen             
     1233                        spieeprom_read_block((uint32_t) ((uint16_t) MsgPtr), Screen_MsgBuffer, sizeof(MessageHeader_t)); 
    12201234 
    12211235                        // Nachricht Eintrag Zeichnen 
    … …  
    12261240             
    12271241                        bool IsCQ = false; 
    1228                         if (strcasecmp_P(Message_EditBuffer->Header.Empfaenger, STR_Alle) == 0){ 
     1242                        if (strcasecmp_P(Screen_MsgBuffer->Header.Empfaenger, STR_Alle) == 0){ 
    12291243                                IsCQ = true; 
    12301244            } 
    12311245 
    1232                         switch (Message_EditBuffer->Header.Flags.Status) 
     1246                        switch (Screen_MsgBuffer->Header.Flags.Status) 
    12331247                        { 
    12341248                                //case MessageFlagStatusGeloescht : 
    12351249                                //      GlyphPtr = Glyph_Deleted; 
    1236                                 //      NamePtr = &Message_EditBuffer.Header.Empfaenger; 
     1250                                //      NamePtr = &Screen_MsgBuffer.Header.Empfaenger; 
    12371251                                //      break; 
    12381252                        case MessageFlagStatusEntwurf : 
    12391253                                GlyphPtr = Glyph_Entwurf; 
    1240                                 NamePtr = Message_EditBuffer->Nachricht; 
     1254                                NamePtr = Screen_MsgBuffer->Nachricht; 
    12411255                                break; 
    12421256                        case MessageFlagStatusGesendet : 
    12431257                                GlyphPtr = Glyph_OutSend; 
    1244                                 NamePtr = Message_EditBuffer->Header.Empfaenger; 
     1258                                NamePtr = Screen_MsgBuffer->Header.Empfaenger; 
    12451259                                break; 
    12461260                        case MessageFlagStatusQueue : 
    12471261                                GlyphPtr = Glyph_OutQueue; 
    1248                                 NamePtr = Message_EditBuffer->Header.Empfaenger; 
     1262                                NamePtr = Screen_MsgBuffer->Header.Empfaenger; 
    12491263                                break; 
    12501264                        case MessageFlagStatusEmpfangenGelesen : 
    12511265                                GlyphPtr = Glyph_InRead; 
    1252                                 NamePtr = Message_EditBuffer->Header.Absender; 
     1266                                NamePtr = Screen_MsgBuffer->Header.Absender; 
    12531267                                break; 
    12541268                        case MessageFlagStatusEmpfangenUngelesen : 
    12551269                                GlyphPtr = Glyph_InUnread; 
    1256                                 NamePtr = Message_EditBuffer->Header.Absender; 
     1270                                NamePtr = Screen_MsgBuffer->Header.Absender; 
    12571271                                break; 
    12581272                        case MessageFlagStatusTxMaxtry : 
    12591273                                GlyphPtr = Glyph_Maxtry;  
    1260                                 NamePtr = Message_EditBuffer->Header.Empfaenger; 
     1274                                NamePtr = Screen_MsgBuffer->Header.Empfaenger; 
    12611275                                break; 
    12621276                        } 
    … …  
    12871301                        LCD_PutString(NamePtr);     // String gleich von "NamePtr" ausgeben lassen 
    12881302                } 
    1289                 Message_EditBuffer = NULL;      // Message_EditBuffer wieder "NULL"-en 
     1303                Screen_MsgBuffer = NULL;      // Message_EditBuffer wieder "NULL"-en 
    12901304        Keypad_WaitForKeyStroke(); 
    12911305 
    … …  
    13011315                } 
    13021316 
    1303                 if (Keypad_lastScanCode  == Keypad_SC_MRechts) 
    1304                 { 
    1305             return 0; 
     1317                if (Keypad_lastScanCode  == Keypad_SC_MRechts)  // BACK 
     1318                { 
     1319            return 0;                                                                   // Menü verlassen 
    13061320                } 
    13071321 
    … …  
    13111325                        if (highlightMessageBlockNr > 0) 
    13121326                        { 
    1313                 Message_EditBuffer = pvPortMalloc( TRXBufSize); // Speicher zuweisen lassen 
    1314                 if (Message_EditBuffer != NULL)                 // und nur wenn Speicher verfügbar ist 
     1327                Screen_MsgBuffer = pvPortMalloc( TRXBufSize); // Speicher zuweisen lassen 
     1328                if (Screen_MsgBuffer != NULL)                 // und nur wenn Speicher verfügbar ist 
    13151329                { 
    13161330                    spieeprom_read_block((uint32_t) ((uint16_t)EECurrPtr), 
    1317                                          Message_EditBuffer, sizeof(MessageHeader_t)); // Header einlesen (wg. Längenangabe) 
     1331                                         Screen_MsgBuffer, sizeof(MessageHeader_t)); // Header einlesen (wg. Längenangabe) 
    13181332                     
    1319                                         if (Message_EditBuffer->Header.Laenge > MESSAGE_MAXLEN) 
     1333                                        if (Screen_MsgBuffer->Header.Laenge > MESSAGE_MAXLEN) 
    13201334                                        {       // Niemals mehr Zeichen einlesen als zulässig (z.B. bei EEPROM/Flash Fehler) 
    1321                                                 Message_EditBuffer->Header.Laenge = MESSAGE_MAXLEN; 
     1335                                                Screen_MsgBuffer->Header.Laenge = MESSAGE_MAXLEN; 
    13221336                                        } 
    13231337                    // Nachricht einlesen                                                                                                
    13241338                                        spieeprom_read_block((uint32_t) ((uint16_t)EECurrPtr), 
    1325                                          Message_EditBuffer, sizeof(MessageHeader_t)+Message_EditBuffer->Header.Laenge ); 
    1326                     Message_EditBuffer->Nachricht[sizeof(MessageHeader_t)+ Message_EditBuffer->Header.Laenge] = 0; // Mit 0 terminieren 
     1339                                         Screen_MsgBuffer, sizeof(MessageHeader_t)+Screen_MsgBuffer->Header.Laenge ); 
     1340                    Screen_MsgBuffer->Nachricht[sizeof(MessageHeader_t)+ Screen_MsgBuffer->Header.Laenge] = 0; // Mit 0 terminieren 
    13271341                    Keypad_PadMode = PAD_Steuer; 
    1328                     Screen_ShowMsg(Message_EditBuffer, highlightMessageBlockNr); 
    1329                     vPortFree(Message_EditBuffer);  // Speicher wieder freigeben 
     1342                    Message_EditBuffer = Screen_MsgBuffer; // TODO: Pointer als Argument übergeben 
     1343                    Screen_ShowMsg(Screen_MsgBuffer, highlightMessageBlockNr); 
     1344                    vPortFree(Screen_MsgBuffer);  // Speicher wieder freigeben 
    13301345                } 
    13311346                //TODO: Fehlermeldung ausgeben, wenn zu wenig Speicher frei 
    … …  
    13521367        LCD_SetTextCursor(0,1); 
    13531368        LCD_PutString_P(STR_Absend); 
    1354         memset(buf, 0, sizeof(buf)); 
    13551369        strncpy(buf, Message_EditBuffer->Header.Absender, ADDRESS_MAXCHAR); 
     1370    buf[8]=0; 
    13561371        LCD_PutString(buf); 
    13571372 
    13581373        LCD_SetTextCursor(0,2); 
    13591374        LCD_PutString_P(STR_Empf); 
    1360         memset(buf, 0, sizeof(buf)); 
    13611375        strncpy(buf, Message_EditBuffer->Header.Empfaenger, ADDRESS_MAXCHAR); 
    13621376        LCD_PutString(buf); 
    … …  
    13651379        LCD_SetTextCursor(0,3); 
    13661380        LCD_PutString_P(STR_Zeit); 
    1367         memset(buf, 0, sizeof(buf)); 
     1381        //memset(buf, 0, sizeof(buf)); 
     1382    // -> itoa liefer 0-terminierten String! 
    13681383        LCD_PutString(itoa(Message_EditBuffer->Header.UniqueID, buf, 10)); 
    13691384 

  • branches/yfe_rtos/heap_2.c

    r331 r380  
    240240xBlockLink *pxLink; 
    241241 
    242         if( pv ) 
     242        if( pv!=NULL ) 
    243243        { 
    244244                /* The memory being freed will have an xBlockLink structure immediately 
    … …  
    254254                        prvInsertBlockIntoFreeList( ( ( xBlockLink * ) pxLink ) ); 
    255255                } 
    256                 xTaskResumeAll(); 
     256                xTaskResumeAll();        
    257257        } 
    258258} 

  • branches/yfe_rtos/l2rx.c

    r379 r380  
    366366        while( xQueueReceive(RxDataInHandle, &data, 0)==pdPASS );       // Queue leeren 
    367367                 
    368                 if (RxBuffer!=NULL)         // Speicher freigeben, falls welcher angefordert wurde 
    369         { 
    370             vPortFree(RxBuffer); 
    371         } 
    372         if (ParBuffer!=NULL) 
    373         { 
    374             vPortFree(ParBuffer); 
    375         } 
     368        // Speicher freigeben, falls welcher angefordert wurde 
     369        vPortFree(RxBuffer); 
     370        vPortFree(ParBuffer); 
    376371        rx_state = IDLE;         
    377372    }     
Note: See TracChangeset for help on using the changeset viewer.