Probleme bei Zeigeroperationen mit PIC16F877

[fritzle123]

Hallo und Grüße an alle PIC Programmierer,

da ich nach langen zögern doch endlich meine Programmiersprache
von Assembler auf C umgestellt habe, stehe ich vor mehreren (vermutlich für euch kleinen) Problemen.

Ich möchte mit meinem PIC16F877 über die serielle Schnittstelle einen
String einlesen, zwischenspeichern und anschließend mit einem 2. String vergleichen.
(Der Wert des 2. String wird im Funktionsaufruf als Konstante
übergeben, dies geschieht jedoch in einer anderen Funktion da ich
diese öfters mit verschiedenen Strings benötige)

Nun habe ich folgende Probleme:

1.)
Ich kann zwar einen String einlesen, bekomme aber das Problem dass
ich für einen späteren Vergleich den Zeiger (globale Variable) wieder
auf das erste Byte richten muss.
Wenn ich beim Aufruf meiner Funktion den String kopiere
(*Start_Byte = *Empfangenes_Byte) bekomme ich aber leider die
Fehlermeldung, dass der Code in C eigentlich richtig ist, aber die Funktion
bei meinem Controller nicht möglich ist, da er nur ein Zeigerregister hat.

Wie kann ich dies in C (ich verwende CC5X) anders programmieren.
Ich habe hierfür auch schon das FSR Register ausgelesen und wollte
den Wert meinem zweiten Zeiger zuweisen, jedoch ist dies in C nicht
möglich da ich einem Zeiger nur eine Zeigervariable und keinen Wert
zuweisen kann.

2.)
Wenn ich meinen String in einer zweiten Funktion vergleichen möchte,
habe ich das Problem dass ich gleichzeitig mit zwei Zeigern arbeiten
muss, um deren Inhalt (ausgelesener Wert) miteinander zu vergleichen.
Gibt es hierfür eine Möglichkeit ohne dass ich ständig mein
FSR – Register neu laden muss?

Ich hoffe ich konnte meine Probleme deutlich erklären und würde
mich über eure Lösungsmöglichkeiten und Vorschläge sehr freuen.

Grüsse von fritzle123

[gunzelg]

Hallo

ja, das ist ne blöde Sache, PIC16 und C, da sind die PIC18 besser für C geeignet. Aber versuch doch mal Deine Zeiger-Operationen (je eine) in einer Subroutine auszuführem und die entsprechenden Zeiger auch nur lokal und nicht global zu definieren. - Ist so eine Idee, vielleicht nützt gehts.

Gerhard

ja, das ist ne blöde Sache, PIC16 und C, da sind die PIC18 besser für C geeignet

Prinzipiell hast Du recht, d.h. die Architektur der PIC18 kommt C mehr entgegen (in Assembler sind sie aber auch "angenehmer").

Eine Lösung für das Problem von fritzle123 Problem habe ich im Moment auch nicht, da ich den CC5X nicht näher kenne. Es ist aber eigentlich eindeutig ein Problem des verwendeten Compilers, denn PICC von HT-Soft kann dafür Code erzeugen (warum auch nicht, ist ja schließlich in Assembler auch möglich)

*ptr1 = *ptr2
MOVF   ptr2, W
MOVWF  FSR	   ; FSR zeigt auf ptr2
MOVF   INDF, W  ; w enthält Inhalt von ptr2
MOVWF  0x70     ; Inhalt von ptr2 in 0x70 zwischenspeichern
MOVF   ptr1, W  
MOVWF  FSR      ; FSR zeigt auf ptr1
MOVF   0x70, W  ; W enthält den Inhalt von ptr2
MOVWF  INDF     ; Inhalt von ptr1 = Inhalt von ptr2

Von diesem Compiler gibt es auch eine freie Version, ist für den 16F877 aber auf 2k Words Code und 2 RAM-Bänke beschränkt.

http://www.htsoft.com/products/PICClite.php

Bernd

Hallo Bern und Gerhard,

eigentlich habt ihr Recht und ich werde bei meiner nächsten Platine
vermutlich auf einen PIC18 umsteigen, da er drei getrennte Zeiger hat.
Leider ist meine Platine schon fertig und ich möchte nicht nochmals von vorne anfangen.
Die Funktion *ptr1 = *ptr2 lässt sich leider bei CC5X nicht anwenden,
da genau dort mein Problem liegt.
Mir ist zudem noch aufgefallen dass mir die Anweisung:

Byte = *String;
einen Zugriff auf meinen Flash Speicher verursacht und
dieser natürlich sehr lange dauert.
Vermutlich werde ich mein Problem doch in Assembler lösen müssen.

Falls du (Bernd) Zeit hättest würde ich mich über den erzeugten Code freuen,
wäre zumindest eine gute Vorlage.

Also, vielen Dank für eure Bemühungen.

Grüße Fritzle123


fritzle123@web.de

Hallo Friztle 123,

der Zugriff auf den Flash-Speicher ist normal, da Konstanten immer im Flash abgelegt werden. Entweder kann man auf die Konstanten über eine Tabelle aus RETLW-Anweisungen oder über TBLRD-Befehle zugreifen. Jeder Zugriff auf den Flash-Speicher ist langsamer als ein RAM-Zugriff.

Hier der vom HT-Compiler erzeugte Code:

1:                 #include <pic.h>
2:                 
3:                 const unsigned char string_rom[5] = "test";	// String im ROM
4:                 unsigned char byte;                          // RAM-Adresse ist 0x20
5:                 
6:                 void test_fkt (const unsigned char *string)
7:                 {
8:                 	byte = *string;  
0007F1    0183     CLRF 0x3
0007F2    0822     MOVF 0x22, W
0007F3    00A4     MOVWF 0x24
0007F4    0821     MOVF 0x21, W
0007F5    2011     CALL 0x11      // Zugriff auf den String
0007F6    00A0     MOVWF 0x20
9:                 }	
0007F7    0008     RETURN
10:                
11:                void	main(void)
12:                {
13:                	test_fkt (string_rom);
0007F8    3027     MOVLW 0x27     // Parameterübergabe
0007F9    1283     BCF 0x3, 0x5
0007FA    1303     BCF 0x3, 0x6
0007FB    00A1     MOVWF 0x21     
0007FC    3000     MOVLW 0
0007FD    00A2     MOVWF 0x22
0007FE    27F1     CALL 0x7f1	  // Funktionsaufruf
14:                	for (;;); 
0007FF    2FFF     GOTO 0x7ff

// String-Tabelle 

 Line  Address  Opcode     Label                   Disassembly              
    18   0011  1283   string_table   BCF STATUS, 0x5 // String-Tabelle, Einsprung erfolgt hier                 
    19   0012  00A3                  MOVWF 0x23                             
    20   0013  1BA4   string_indir   BTFSC 0x24, 0x7                        
    21   0014  281E                  GOTO 0x1e                              
    22   0015  1B24                  BTFSC 0x24, 0x6                        
    23   0016  2826                  GOTO 0x26                              
    24   0017  0824                  MOVF 0x24, W                           
    25   0018  008A                  MOVWF PCLATH                           
    26   0019  0823                  MOVF 0x23, W                           
    27   001A  0AA3                  INCF 0x23, F                           
    28   001B  1903                  BTFSC STATUS, 0x2                      
    29   001C  0AA4                  INCF 0x24, F                           
    30   001D  0082                  MOVWF PCL                              
    31   001E  1383                  BCF STATUS, 0x7                        
    32   001F  1824                  BTFSC 0x24, 0                          
    33   0020  1783                  BSF STATUS, 0x7                        
    34   0021  0823   ?_test_fkt     MOVF 0x23, W                           
    35   0022  0AA3                  INCF 0x23, F                           
    36   0023  0084   code_ptr       MOVWF FSR                              
    37   0024  0800                  MOVF INDF, W                           
    38   0025  0008                  RETURN                                 
    39   0026  0782                  ADDWF PCL, F                           
    40   0027  3474                  RETLW 0x74      // Ab hier steht der String                            
    41   0028  3465                  RETLW 0x65                             
    42   0029  3473                  RETLW 0x73                             
    43   002A  3474                  RETLW 0x74                             
    44   002B  3400                  RETLW 0

Wenn Du mehr Beispiele für die Codeerzeugung benötigst, solltest Du meinem obigen Link folgen und selbst mit der Lite-Version experimentieren .

Bernd

Was mir gerade noch eingefallen ist:

Die Zuweisung des Inhalts von Zeiger 2 zu Zeiger 1 kann man natürlich auch über eine temporäre Variable lösen.

temp = *ptr2;
*ptr1 = temp;

Damit müßte auch der CC5X klarkommen.

Bernd

Hallo Bernd,

danke für deine Bemühungen.

die Zuweisung: temp = *ptr2;
gibt mir aber nur den Inhalt der Zelle auf die der Zeiger gerade zeigt.

und
*ptr1 = temp;
funktioniert leider auch nicht da es sich bei *ptr1 um eine Variable
vom Typ Zeiger handelt und ich daher kein Byte zuweisen kann.

Ich versuche es jetzt mal in Assembler, dann wird es schon klappen.

Gruß fritzle123

Hallo Fritzle123,

die Zuweisung: temp = *ptr2;
gibt mir aber nur den Inhalt der Zelle auf die der Zeiger gerade zeigt.

Richtig.

*ptr1 = temp;
funktioniert leider auch nicht da es sich bei *ptr1 um eine Variable
vom Typ Zeiger handelt und ich daher kein Byte zuweisen kann.

Falsch, ptr ist eine Variable vom Typ Zeiger, *ptr ist der Inhalt der Speicherstelle, auf die ptr zeigt. Daher wird der Wert der Variablen temp in die Speicherstelle geschrieben, auf die ptr zeigt.

*ptr1 = *ptr2 bewirkt, daß der Inhalt der Speicherstelle, auf die ptr2 zeigt, in die Speicherstelle geschrieben wird, auf die ptr1 zeigt.

ptr1 = ptr2 bewirkt, daß der Zeiger ptr1 auf die selbe Speicherstelle wie ptr2 zeigt.


Viele Grüße

Bernd