Beiträge anzeigen

Diese Sektion erlaubt es ihnen alle Beiträge dieses Mitglieds zu sehen. Beachten sie, dass sie nur solche Beiträge sehen können, zu denen sie auch Zugriffsrechte haben.


Themen - Monika

Seiten: [1]
1
Timer (Allgemein) / Timer0 bei PIC18F2620 - Ungenaue Durchlaufzeit??
« am: Januar 08, 2018, 16:28:25 Nachmittag »
Hallo,

ich arbeite seit Jahren mit dem PIC18F2620 und alle "normalen" Anwendungen von Timer0, auch in Kombination mit anderen Interrupts, verhalten sich meistens so, wie ich es mir erwarte.

Heute steht allerdings ein eher zeitkritisches Projekt an, das einige Verständnisfragen aufwirft.

Kurz zum Ablauf:
Abhängig von einem Potentiometer sollen Impulse mit einer Frequenz von 100 - 15750Hz ausgegeben werden.

Da ich mir nicht sicher war, wie sich der PIC bei so hohen Ausgangsfrequenzen verhält, habe ich damit begonnen, das 15750Hz-Signal zu erzeugen:

(Insert Code funktioniert leider nicht!)
void highprio_int(void)
{
   if(INTCONbits.TMR0IF)
   {
      INTCONbits.TMR0IF = 0;
      WriteTimer0(timer_startwert);
      
      AUSGABE_PIN = 1;  //Impulsausgabe
      AUSGABE_PIN = 0;
      
      laufvariable1++;
      laufvariable2++;      
   }
}

Den Timer-Startwert habe ich mir mit 65028 berechnet, allerdings stimmt dann die Ausgangsfrequenz nicht, sondern es wird ein Wert von 65108 benötigt, damit ich mit dem Oszilloskop das richtige Ausgangssignal messe.
Das ist für mich auch noch relativ plausibel, da ja bei so einer kurzen Durchlaufzeit das Rein-/Rausspringen in die Interruptroutine ein nicht zu vernachlässigender Zeitfaktor ist.

Das Hauptprogramm ist sehr einfach gehalten: Nach jedem 270. Impuls soll mit dem ADC der Potentiometer-Wert eingelesen und dann die Frequenz gegebenenfalls angepasst werden.

void main(void)
{
   Init();                  // Funktionsaufruf für alle notwendigen Einstellungen

   while(1)      
   {   
      TESTPIN = 1;
   
      if(laufvariable1 >= 270)
      {
         laufvariable1 = 0;
         
         ConvertADC();
         while(BusyADC());

         //ADC_result = ReadADC();      
      }
      TESTPIN = 0;
   }
}

Die beiden Zeilen ConvertADC() und while(BusyADC()) ändern am Ausgangssignal nichts, aber sobald ReadADC() aufgerufen wird, ändert sich die Ausgangsfrequenz 15700Hz auf 15000Hz. Wenn dann noch die Berechnung für den Timer-Startwert aus dem ADC_result dazukommt, liegt die Frequenz überhaupt nur mehr bei 12kHz!
Mit Hilfe des Testpins kann ich nachmessen, dass das Hauptprogramm schnell genug läuft und ich noch lange nicht an der Grenze des Möglichen angelangt bin.

Ich hätte mir erwartet, dass bei jedem 270. Impuls irgendeine Verzögerung oder ähnliches auftritt, aber nicht, dass sich dadurch die gesamte Zeitbasis des Timers ändert!!! Wie kann das passieren? Ist das nicht die Definition des Timer-Interrupts, dass dieser immer zu einer voreingestellten Zeit aufgerufen wird und das restliche Programm in der verbleibenden Zeit dazwischen abgearbeitet wird?

Durch weitere Messungen habe ich noch versucht, die Ungenauigkeit genauer zu definieren und ich glaube, dass der größte Zeitfehler beim Zurückspringen von der Interruptroutine in das Hauptprogramm passiert. Ist diese Zeitspanne vielleicht davon abhängig, welche Variablen im Hintergrund gesichert werden müssen?

Hat jemand dafür eine Erklärung?

Vielen Dank,
Monika

2
Schnittstellen (Allgemein) / Initialisierung SD-Karte
« am: Juli 14, 2014, 08:12:47 Vormittag »
Hallo!

Ich versuche im Moment gerade, Daten auf einer SD-Karte abzuspeichern, allerdings hänge ich schon bei der Initialisierung. Das Forum habe ich auch schon durchsucht und ein paar Einträge gefunden mit diesem Thema, allerdings haben mir die Tipps dort nicht weitergeholfen.

Ich arbeite mit dem PIC18F2620 und mit einer SDHC 4GB Karte.
Die SPI-Schnittstelle läuft in folgendem Modus:
SSPCON1bits.CKP = 1;
SSPSTATbits.CKE = 0;

was die Geschwindigkeit betrifft:
die PLL hab ich jetzt abgedreht, weil ich im Forum gelesen hab, dass man die SD-Karte nur mit max. 400kHz initialisieren darf, Clock läuft jetzt mit 125kHz (nachgemessen mit Oszi).

dazu gleich eine erste Frage: gilt die 400kHz-Grenze nur für die Initialisierung oder generell für die Ansteuerung?

hier meine Initialisierung:
CMD0 ... Antwort 0x01, Idle State ... ok
CMD8 ... Antwort mit passendem Spannungsbereich und 'check pattern' ... ok
ACMD41 ... Antwort immer 0x01, Initialisierung nie abgeschlossen

for(i=0; i<10; i++) //80 clock pulses to SCLK
WriteSPI(0xff);

if(sd_command_byte(CMD0,0x00,0x00,0x00,0x00,0x95) != 1)
{
SD_Disable();
return 1;
}


timeout = 0;
while(sd_command_byte(CMD8,0x00,0x00,0x01,0xaa,0x87) != 0x01)
{
if(timeout++ > 400)
{
SD_Disable();
return 2;
}
}
for(i=0;i<4;i++)
data[i] = ReadSPI_SD();

if(data[2] != 0x01 || data[3] != 0xaa)
{
SD_Disable();
return 2;
}


timeout = 0;
init_ok = 1;

while(timeout++ < 1000 && init_ok != 0)
{
if(sd_command_byte(CMD55,0x00,0x00,0x00,0x00,0x01) <= 1)
init_ok = sd_command_byte(CMD41,0x00,0x40,0x00,0x00,0x01);
}

und hier ist auch mein Problem:
Die Antwort auf ACMD41 sollte irgendwann 0x00 sein, wenn die Initisalisierung abgeschlossen ist, aber egal, wie oft ich auch abfrage, es bleibt bei 0x01 (idle state).

Wo liegt mein Fehler?
Muss nicht vor jeder ACMD41-Abfrage ein CMD55 stehen?
Gehört irgendwo ein Delay eingebaut?

Vielen Dank schon im Vorhinein für eure Antworten!
Viele Grüße
Monika



3
PIC Mikrocontroller Allgemein / Logarithmus-Berechnung mit PIC
« am: Oktober 20, 2010, 11:22:06 Vormittag »
Hallo!

Ich verwende einen PIC 18F2620 und arbeite mit MPLAB IDEv7.20, C18 Compiler.
In einem meiner Projekte bin ich jetzt auf folgendes Problem gestoßen:
Ich möchte den 10er-Logarithmus einer Zahl berechnen. Hört sich an sich ja
nicht so kompliziert an, weil die Funktion ja in math.h schon ausprogrammiert
ist und eigentlich alles funktionieren sollte, wenn ich diese Bibliothek einbinde.

Allerdings bring ich das einfach nicht zum Laufen! Ich hab auch schon das
Forum durchforstet und einen Beitrag gefunden, in dem ihr einem Kollegen
erklärt habt, er soll die math.h in sein Projekt einbinden. Aber das löst leider
nicht mein Problem, weil ich das ja sowieso schon vorher gemacht hab.

Ich poste euch mal die entsprechenen Zeilen von meinem Programm, vielleicht
hat jemand von euch eine Idee dazu und sagt mir, wo mein Denkfehler liegt:

Alle eingebundenen Bibliotheken:
#include <p18f2620.h>   
#include <portb.h>
#include <delays.h>
#include <timers.h>
#include <usart.h>
#include <adc.h>
#include <math.h>
#include <pwm.h>
#include <stdio.h>
#include <stdlib.h>

Eine globale Variable:
float ADC_ber[8] = {0};
Und die zugehörige Berechnung:
ADC_ber[i] = 20 * log10(ADC_ber[i]); //in dB umrechnen

Das ganze führt dann zu folgender Fehlermeldung:
Error - could not find definition of symbol '__log10:0' in file 'M:\GI735 AudiomonDby\GI735v01.o'.

Muss ich vielleicht noch irgendwelche anderen Einstellungen vornehmen, die ich
übersehen habe?

Danke schon mal im Vorhinein für eure Bemühungen!

Beste Grüße
Monika

4
Programmiersprache C / String in mehrdimensionales Feld kopieren?
« am: November 26, 2009, 09:51:43 Vormittag »
hallo!

im forum hab ich leider nichts brauchbares gefunden...aber vielleicht kann mir jemand von euch helfen

ich hab bei meinem Programm 2 Arrays und 2 Pointer:
unsigned char inputbuf[LEN];
unsigned char data_out[14][18];
unsigned char *p_in, *p_out;

Daten werden über USART eingelesen, im Eingangsbuffer (inputbuf[]) abgespeichert, bis bestimmtes Zeichen empfangen worden ist. Soweit funktioniert auch alles.

Dann füge ich ein '\0' ein, um diese Zeile dann als String behandeln zu können:
inputbuf[zeichenzaehler+1] = '\0';
ist das soweit richtig?

Die gesamte Zeile (max. 17 Zeichen) bis '\0' soll dann in jeweils eine Zeile des Feldes kopiert werden:
p_in = &inputbuf[0];
p_out = &data_out[zeilenzaehler][0];
strncpy(p_out, p_in, 17);
zeichenzaehler++;
in dem Feld steht dann aber nichts drin...
kann man das generell nicht so machen? oder hab ich nur etwas mit den Pointer falsch gemacht? Ich bekomm nämlich in der Zeile mit dem strncpy eine Warnung: "suspicious pointer conversion"

Danke an jeden, der versucht, mir etwas klarheit in dieser sache zu verschaffen!  :)

5
PIC Mikrocontroller Allgemein / Adressierungsproblem bei LCD
« am: März 20, 2009, 11:47:44 Vormittag »
Hallo!

Ich hoffe, dass mir bei diesem Problem irgendjemand helfen kann ... bin mir aber nicht ganz sicher, ob es an meinem PIC oder irgendwie am Display liegt

Folgendes Problem:
Ich arbeite mit einem PIC18F2620 und einem 2x40-Zeichen LCD-Display mit KS0066 Kontroller (denke ich zumindest ?!). Mit dem Initialisieren und so habe ich keine Probleme, auch die Ansteuerung klappt gut, Daten werden richtig ausgegeben usw.

Allerdings passiert es manchmal, dass Daten, die eigentlich in der Mitte der zweiten Zeile stehen sollten, plötzlich an der ersten Stelle links oben ausgegeben werden (die Daten an sich sind aber richtig, nur die Position stimmt nicht). und umgekehrt, wenn Daten in der ersten Zeile ausgegeben werden sollen, dann steht manchmal ein Datenpaket in der zweiten Zeile an Position 1.

Woran kann das liegen? Am Programm? Aber warum funktioniert es dann die meiste Zeit und nur manchmal passiert das?

Ich häng mal meinen Code an:
void LCD_gotoxy(unsigned char x, unsigned char y)
{
  unsigned char address;

  if((y%2) == 0) // d.h. gerade Zahl ... zweite Zeile
    address = lcd_line_two;
  else // sonst erste Zeile
    address=0;
  address += (x-1);
  LCD_sendbyte(0b10000000|address,STRG);  // Senden der Cursor-Adresse ans LCD
}  /* Ende: LCD_gotoxy() */

und hier der Aufruf:
if(disp_pos > LCD_1ZEILE) // wenn eine Position in Zeile 2 eingegeben worden ist
{
zeile = 2;
disp_pos -=LCD_1ZEILE;
LCD_gotoxy(disp_pos, zeile); // in zweiter Zeile schreiben
}
else
{
zeile = 1;
LCD_gotoxy(disp_pos, zeile);
}

die berechnete Displayposition ist immer korrekt, auch wenn es falsch angezeigt wird, das hab ich schon überprüft.

kann mir da irgendjemand einen tipp geben?
oder mir vielleicht kurz erklären, wie das mit der Adressenberechnung genau funktioniert...
ist beispielsweise die Adresse der 10. Position = 10 - 1 = 9 und die Adresse der 50. Position = 0x40 + 10 - 1 = 0x49 = 73? stimmt das so?

DANKE!!!

Monika

6
MPLAB / Fehlermeldung
« am: Oktober 10, 2007, 08:12:20 Vormittag »
Hallo!

Ich hab derzeit ein kleines Problem:
beim Kompilieren bekomm ich folgende Fehlermeldung:

Error - Recursion not supported for functions with locals of "overlay" storage class: high_int

Bis jetzt hab ich noch nie diese Fehlermeldung gehabt und weiß daher
auch nicht, was das bedeuten soll. Kann mir da bitte jemand helfen?
Damit ich mal ungefähr weiß, nach was ich suchen soll.

Danke!
mfg
Monika

7
PIC Mikrocontroller Allgemein / Frequenzmessung mit CCP-Modul
« am: August 24, 2007, 07:14:19 Vormittag »

Hallo!

Ich muss für mein aktuelles Projekt eine Frequenzmessung realisieren und hab schon
ein paar Beiträge entdeckt, in denen anderen geraten wurde, diese Aufgabe mit
dem CCP-Modul zu lösen.

Einige Sachen hab ich schon gelesen, aber so ganz versteh ich nicht, wie das
funktioniert. Könnte mir da bitte jemand weiterhelfen?

Ich verwende die Capture-Einheit, jedes Mal, wenn ein bestimmtes Ereignis auftritt,
z.B. steigende Flanke, wird irgendein Registerwert um 1 erhöht. Stimmt das so?
Aber welcher Registerwert ist das? Und wie oft wird das erhöht? Muss man das
nicht irgendwie so auf die Art angehen, dass ich für z.B. 500ms messen möchte
und mir dann anschaue, wie oft ein HIGH-LOW-Wechsel aufgetreten ist?
Und welche Interrupts brauch ich da genau? Es gibt ja einen CCP-Interrupt und
einen zugehörigen Timer-Interrupt. Müssen da beide aktiviert werden?

Ich arbeite mit dem PIC18F2620, C18 Compiler
Die Frequenzen, die gemessen werden sollen, sind nicht besonders groß. Im Moment
ist mal interessant der Bereich von 20 - 200 Hz.

Danke für eure Hilfe!
mfg Monika


8
Programmiersprache C / Probleme mit LCD-Ansteuerung
« am: August 10, 2007, 07:31:27 Vormittag »
Hi!

Ich hab hier zwar schon sehr viele beiträge gelesen, die sich mit der Ansteuerung von LCD-Displays befassen ... aber keiner davon hat mir bis jetzt geholfen!

ich verwende ein DIPS082, mit Controller KS0066, HD 44780 kompatibel
2x8 Zeichen

das prinzip an sich, wie diese displays zu programmieren sind, ist ja eigentlich nicht so schwierig, aber ich bekomm's trotzdem nicht hin.
das einzige, was mein display macht ist, dass es leuchtet und die erste Zeile als dunkle blöcke angezeigt wird.
die verdrahtung hab ich jetzt schon ein paar mal kontrolliert, die stimmt.

vielleicht kann mir da jemand helfen und findet einen fehler in meinem code:

/******************************************************************************/
/*    Steuerleitungen                                                         */
/******************************************************************************/
#define LCD_RS LATCbits.LATC2      // RS ist an RC2 angeschlossen
#define TRIS_RS TRISCbits.TRISC2      // Tristate-Register von RC2

#define LCD_RW LATCbits.LATC7          // RW ist an RC7 angeschlossen
#define TRIS_RW TRISCbits.TRISC7     // Tristate-Register von RC7

#define LCD_EN  LATBbits.LATB1          // E ist an RB1 angeschlossen
#define TRIS_EN TRISBbits.TRISB1      // Tristate-Register von RB1
/******************************************************************************/
/******************************************************************************/

/******************************************************************************/
/*    Datenleitungen                                                          */
/******************************************************************************/
#define LCD_D4 LATCbits.LATC0          // D4 ist an RC0 angeschlossen
#define PORT_D4 PORTCbits.RC0
#define TRIS_D4 TRISCbits.TRISC0      // Tristate-Register von RC0

#define LCD_D5 LATCbits.LATC3          // D5 ist an RC3 angeschlossen
#define PORT_D5 PORTCbits.RC3
#define TRIS_D5 TRISCbits.TRISC3      // Tristate-Register von RC3

#define LCD_D6 LATCbits.LATC4        // D6 ist an RC4 angeschlossen
#define PORT_D6 PORTCbits.RC4
#define TRIS_D6 TRISCbits.TRISC4      // Tristate-Register von RC4

#define LCD_D7 LATCbits.LATC5          // D7 ist an RC5 angeschlossen
#define PORT_D7 PORTCbits.RC5
#define TRIS_D7 TRISCbits.TRISC5      // Tristate-Register von RC7


#define DATA 1
#define STRG 0

#define lcd_line_two 0x40     // LCD RAM address for the second line
#define line_on      0x02     // Unterstriches aktivieren
#define blink_on     0x01     // Blinkenden Cursor aktivieren
#define Display_on   0x0C     // Display einschalten

#define line_off      0x00    // Unterstrich deaktivieren
#define blink_off     0x00    // Blinkenden Cursor deaktivieren
#define Display_off   0x08    // Display ausschalten


/******************************************************************************/
/******************************************************************************/

/*******************************************************************************
*           Halbbyte senden                                                        +
*******************************************************************************/
void send_nibble(unsigned char data7, unsigned char data6, unsigned char data5, unsigned char data4, unsigned char zielreg)
{
    LCD_RS = zielreg; // Datenregister oder Steuerregister auswählen
    LCD_RW = 0; // Schreibmodus einstellen
    LCD_EN = 0; // Enable-Leitung auf 0 setzen
   
    TRIS_D4 = 0;     // IO-Ports als Ausgänge einstellen
    TRIS_D5 = 0;
    TRIS_D6 = 0;
    TRIS_D7 = 0;
   
    LCD_D4 = data4; // Daten auf den Pins anlegen
    LCD_D5 = data5;
    LCD_D6 = data6;
    LCD_D7 = data7;
   
    Delay10TCYx(200);
    LCD_EN = 1; // Enable-Leitung auf 1 setzen
    Delay1KTCYx(4); // 2ms
    LCD_EN = 0; // Erzeugen der fallenden Flanke, bei der die Daten vom LCD übernommen werden

    LCD_RS=0; // LCD aufs Steuerregister einstellen
}  /* Ende: send_nibble() */


/*******************************************************************************
*           Byte senden                                                        +
*******************************************************************************/
void LCD_sendbyte(unsigned char data, unsigned char zielreg)
{
unsigned char d7 = 0, d6 = 0, d5 = 0, d4 = 0;

d7 = (data & 0b10000000) / 128;
d6 = (data & 0b01000000) / 64;
d5 = (data & 0b00100000) / 32;
d4 = (data & 0b00010000) / 16;
    // Senden des 1. Nibbles (Bit7 - Bit4)
    send_nibble(d7, d6, d5, d4, zielreg);
    Delay1KTCYx(4);
   
    d7 = (data & 0b00001000) / 8;
    d6 = (data & 0b00000100) / 4;
    d5 = (data & 0b00000010) / 2;
    d4 = (data & 0b00000001);
    // Senden des 2. Nibbles (Bit3 - Bit0)
    send_nibble(d7, d6, d5, d4, zielreg);
    Delay1KTCYx(4);
}  /* Ende: LCD_sendbyte() */

/*******************************************************************************
*           LCD initialisieren                                                 *
*******************************************************************************/
void LCD_init(void)
{
   TRIS_RS = 0;
   TRIS_RW = 0;
   TRIS_EN  = 0;
   
   //Initialisierungsdaten ans LCD senden
   send_nibble(0,0,1,1,STRG);
   Delay1KTCYx(100);
   send_nibble(0,0,1,1,STRG);
   Delay100TCYx(30);
   send_nibble(0,0,1,1,STRG);
   Delay100TCYx(20);

   // Auf 4-Bit Modus umstellen
   send_nibble(0,0,1,0,STRG);
   Delay1KTCYx(20);


   // System-Set ins Register schreiben
   send_nibble(0,0,1,0,STRG);
   Delay100TCYx(20);
   send_nibble(1,0,0,0,STRG);
   Delay100TCYx(200);

   // Display ein/aus; Cursor ein/aus; Blink ein/ aus
   send_nibble(0,0,0,0,STRG);
   Delay100TCYx(20);
   send_nibble(1,1,1,1,STRG); //(Display_on | line_on | blink_on ,0); //
   Delay100TCYx(20);

   // Entry-mode-Einstellung
   send_nibble(0,0,0,0,STRG);
   Delay100TCYx(20);
   send_nibble(0,1,1,0,STRG);
   Delay100TCYx(20);

   // Löschen der Anzeige
   send_nibble(0,0,0,0,STRG);
   Delay100TCYx(20);
   send_nibble(0,0,0,1,STRG);
   Delay100TCYx(20);

   // Cursor an die folgende Position stellen: 1. Zeile; 1. Position
   send_nibble(0,0,0,0,STRG);
   Delay100TCYx(20);
   send_nibble(0,0,0,1,STRG);
   Delay100TCYx(20);
}  /* Ende: LCD_init() */


/*******************************************************************************
*      Cursor positionieren                                                    *
*******************************************************************************/
void LCD_gotoxy(unsigned char x, unsigned char y)
{
   unsigned char address;

   if(y!=1)
     address=lcd_line_two;
   else
     address=0;
   address+=x-1;
   LCD_sendbyte(0x80|address,0);  // Senden der Cursor-Adresse ans LCD
}  /* Ende: LCD_gotoxy() */


/*******************************************************************************
*      Zeichen oder Zeichenkette senden                                        *
*******************************************************************************/
void LCD_putc( char c)
{
   switch (c) {
     case '\f'   : LCD_sendbyte(1,0);              // Anzeige löschen
                   Delay100TCYx(40);
                                          break;
     case '\n'   : LCD_gotoxy(1,2);       break;   // Cursor an den Beginn der 2.Zeile setzen
     case '\b'   : LCD_sendbyte(0x10,0);  break;   // Cursor um eine Stelle nach links schieben
     default     : LCD_sendbyte(c,1);     break;   // Zeichen ans LCD senden
   }
}  /* Ende: LCD_putc() */

am anfang des programms warte ich 100ms, dann rufe ich die LCD_init() auf
so wie ich das verstanden habe, müsste dann das display leuchten und der cursor an der ersten stelle blinken. es tut sich aber gar nichts.

bitte um hilfe!
Danke!

lg Monika

9
Programmiersprache C / for-Schleife
« am: Februar 13, 2007, 10:57:24 Vormittag »
Hallo!

Ich habe hier ein Problem, das ich mir nicht im geringsten erklären kann.
Eine for-Schleife mit folgenden Bedingungen:

static unsigned char i = 0;

tast_anzahl = 0;

for(i = 0; i < 24; i++)
{
if(i==24)
SchreibeInPuffer('x');

if(tastenneu[0][i] == 1)
tast_anzahl++;
}

sie fängt bei 0 an zu zählen und erhöht i bis 23. dann wird abgebrochen.
manchmal tritt aber der Fall auf, dass i = 24 wird (durch ausgeben von
'x' wurde das überprüft).

wie kann das möglich sein? kennt jemand eine erklärung dazu?
ich arbeite mit einem PIC 18F2620, mit MPLAB und ICD2, Compiler C18.

mfG
Monika

10
Compiler / Compiler-Update
« am: Februar 08, 2007, 13:50:26 Nachmittag »
Hallo!

Ich arbeite derzeit mit MPLAB v7.20 und dem C18-Compiler v2.40.

Hat jemand von euch Erfahrung, ob das Schwierigkeiten macht, wenn
ich auf neuere Versionen updaten möchte? Es sind jede Menge alter
Programme vorhanden, die dann auf jeden Fall funktionieren
müssen. Ist da viel zum Umschreiben, oder funktioniert das gleich
auf Anhieb?

Mit freundlichen Grüßen
Monika

11
PIC Mikrocontroller Allgemein / Probleme bei Berechnung
« am: Februar 08, 2007, 08:53:21 Vormittag »
Ich arbeite mit dem PIC18F2620, MPLAB und ICD2.

Jetzt ist bei einer einfachen Berechnung ein Problem aufgetreten.

Lampe = (((inpbuf[5+2*i]-0x30)*10) + (inpbuf[6+2*i]-0x30));

Diese Zeile soll aus 2 aufeinander folgenden Array-Inhalten einen Wert berechnen.
Meistens funktioniert das auch, aber dann passiert es, dass der Wert von
Lampe irgendeine sinnlose Zahl ist, obwohl im Feld sicher die richtigen
Daten stehen (durch Testausgaben überprüft).

Wenn ich diese Rechnung aufteile in:

zehner = inpbuf[5+2*i]-0x30;
einer = inpbuf[6+2*i]-0x30;   
zehner *= 10;      
Lampe = zehner + einer;

dann stimmt das ergebnis jedes Mal.
Das kann doch nicht sein, dass sich der PIC "verrechnet".
Kann es da Probleme mit dem Stack geben, wo die internen
Zwischenergebnisse abgespeichert werden?
Wo passiert das genau? Kann der zu klein sein?

Während die Berechnungen gemacht werden, läuft im Hintergrund
auch immer der Timer, der einen Interrupt generiert. Weiß
nicht, ob das wichtig ist.

lg Monika

12
PIC Mikrocontroller Allgemein / Probleme mit mehreren Interrupts
« am: September 15, 2006, 11:52:24 Vormittag »
Ich arbeite mit einem PIC18F2620, C18 Compiler, MPLAB ICD2.

kurze Zusammenfassung:
es gibt 3 Interrupts ...
USART-Empfang (low priority),
Timer-Interrupt(high priority),
externer Interrupt an RB1 (high priority)

USART und Timer alleine arbeiten super zusammen;
wenn ein externer Int auftritt, ohne einen anderen zu stören,
funktioniert auch noch alles;
wenn jetzt allerdings ein externer Interrupt auftritt, während
auf der seriellen Schnittstelle die Daten hereinkommen, bricht
er ab und kann einfach nichts mehr empfangen bzw. ich weiß,
dass er nicht mehr den USART-Interrupt aufruft.
der rest vom programm läuft normal weiter.
erst nach einem reset funktioniert wieder alles wie gewünscht.

wo liegt das problem? werden einzelne Interrupts, die gleichzeitig
auftreten, nicht nacheinander abgearbeitet?
braucht man da irgendwelche besonderen einstellungen?

lg Monika

13
Compiler / Variablen im RAM abspeichern
« am: Juli 21, 2006, 07:22:09 Vormittag »

Hallo!

Kann mir jemand helfen, wie ich Variable auch im RAM abspeichern kann,
wenn im normalen Speicher kein Platz mehr ist? Soweit ich das verstanden
hab, liegen die globalen Variablen im Access RAM, der aber nur 128 Byte
groß ist. Ich kann aber diese Daten nicht lokal anlegen, weil ich einige
große Felder global definieren muss.
Ich bekomme folgende Fehlermeldung:

Error - section '.idata_GE73xv01_Funktionen.o' can not fit the section. Section '.idata_GE73xv01_Funktionen.o' length=0x0000012e
gibt es da irgendwelche C-Programmzeilen, mit denen man das macht?
ich hab's schon probiert mit

#pragma udata bank1 = 0x100
Variablentyp Name;

Funktioniert aber irgendwie nicht wirklich.
Bitte um Hilfe und schon mal Danke im Vorraus!

mfg Monika

14
PIC Mikrocontroller Allgemein / PLL einschalten
« am: Juli 19, 2006, 06:52:31 Vormittag »
Hallo!

Ich arbeite mit dem PIC 18F2620, MPLAB, ICD2 und verwende
den internen Oszillator mit 8MHz.
Jetzt möchte ich die PLL einschalten, es funktioniert aber nicht.
Ich hab auch schon probiert, den PIC zuerst komplett zu löschen,
dann zu programmieren, vom Netz und ICD trennen und wieder anstecken,
hat aber nichts genutzt.

Hier mein Code mit den Einstellungen:

#pragma config OSC = INTIO67
#pragma config PWRT = ON
#pragma config BOREN = ON
#pragma config BORV = 43
#pragma config WDT = OFF // disable watchdog timer
#pragma config MCLRE = ON // Reset zulassen
#pragma config LVP = OFF
#pragma config DEBUG = OFF

OSCCONbits.IRCF2 = 1; // 111 ... 8MHz
OSCCONbits.IRCF1 = 1;
OSCCONbits.IRCF0 = 1;

OSCCONbits.SCS1 = 1; // 1x ... Interner Oszillator
OSCCONbits.SCS0 = 1; // 00 ... primary Oszillator

OSCTUNEbits.PLLEN = 1; // PLL wird enabled

ist daran etwas falsch? bitte um Hilfe

mfg Monika

Edit: Bitte Code-Tags verwenden.
Bernd

Seiten: [1]