RN-Wissen.de - Benutzerbeiträge [de]

PIC ASM Beispiele

2009-11-12T19:08:59Z

Hae:

= PIC16(F/LF)XXX =

== UART Routine ==

<pre>
RS232send
banksel TXREG ; Zur Bank von TXREG umschalten
movwf TXREG ; Move w to TXREG
banksel PIR1 ; Zur Bank von PIR1 umschalten
Waittx
btfss PIR1, TXIF ; Wenn bit in PIR1,TXIF HIGH übergehe den nästen Befehl
goto Waittx ; Gehe zu WaitTX
bcf PIR1, TXIF ; Interrupt Flag Löschen (Optionam muss nicht umbedinkt gemacht werden)
return
</pre>

== Schieberegister (z.b. CD4094) ==

<pre>
; Datenleitungen Schiberegister alles Ausgänge
#define CLK PORTB, 0
#define D PORTB, 1
#define STR PORTB, 2
#define OE PORTB, 3
</pre>

<pre>
cd4094_send
banksel PORTB
bcf OE
bcf STR
btfsc cdsend, 0
bsf D
btfss cdsend, 0
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 1
bsf D
btfss cdsend, 1
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 2
bsf D
btfss cdsend, 2
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 3
bsf D
btfss cdsend, 3
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 4
bsf D
btfss cdsend, 4
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 5
bsf D
btfss cdsend, 5
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 6
bsf D
btfss cdsend, 6
bcf D
bsf CLK
bcf CLK
btfsc cdsend, 7
bsf D
btfss cdsend, 7
bcf D
bsf CLK
bcf CLK
bsf STR
bsf OE
return
</pre>

--[[Benutzer:Theborg|Theborg]] 23:13, 15. Sep 2009 (CEST)

== MAX7456 (S/W OSD) ==

Variabeln und I/0:
<pre>
cblock 0x70 ; Variabeln ab 0x70 setzen alle Register max 16stk.
SPI_DATA_WRITE ; Zu Sendene SPI Daten
SPI_DATA_READ ; Gelesend SPI Daten
m_char ; Maxim7456 und sda5708 Zeichen
m_pos ; Maxim7456 Position
endc ; Variabeln setzen beenden

#define SPI_CS PORTC, 7; SPI Slave Select max7456
</pre>

Config:
<pre>
; PORTC
banksel TRISC ; auf Bank 1 umschalten
movlw B'10010000' ; PortC I/O setzen (1=In, 0=Out) (Reinfolge RC7,RC6...)
movwf TRISC ; PortC I/O setzen
banksel PORTC
clrf PORTC ; PortC auf 0 setzen
; SPI
banksel SSPSTAT
movlw B'11000000' ; Mitlere Geschwindigkeit Output Time
movwf SSPSTAT
banksel SSPCON
movlw B'00100001' ; MODE 1,1, SPI MASTER, 1/16 Tosc SSP ON
movwf SSPCON
banksel PORTC
bsf SPI_CS ; SPI Slave Select aus (high)
return
</pre>

SPI Sende/Enfangs Rotinen:
<pre>
SPI_Send
banksel PORTC
bcf SPI_CS ; Chip Select an (Low)
nop
nop
nop
banksel SSPBUF
movf SPI_DATA_WRITE, W
movwf SSPBUF
banksel SSPSTAT
SPI_Wait
btfss SSPSTAT, BF ; Ist das Senden Komplet ?
goto SPI_Wait ; Wen nicht gehe zu SPIWait
nop
nop
nop
banksel PORTC
bsf SPI_CS ; Chip Select aus (High)
return
SPI_Read
banksel PORTC
bcf SPI_CS
nop
nop
nop
banksel SSPBUF
movf SSPBUF, W
movwf SPI_DATA_READ
banksel PORTC
nop
nop
nop
banksel PORTC
bsf SPI_CS
return
</pre>

Defines ASCII to MAX7456 Charset und Config und Schreibrotienen (Achtung es kann sein das die #define nicht mit mpasm Funktioniert mit gpasm wird groß und kleinschreibung unterschiden):
<pre>
max7456_define ; Defines für den max7456 Zeichensatz
#define m_sp 0x00 ; Space
#define m_1 0x01
#define m_2 0x02
#define m_3 0x03
#define m_4 0x04
#define m_5 0x05
#define m_6 0x06
#define m_7 0x07
#define m_8 0x08
#define m_9 0x09
#define m_0 0x0A
#define m_A 0x0B
#define m_B 0x0C
#define m_C 0x0D
#define m_D 0x0E
#define m_E 0x0F
#define m_F 0x10
#define m_G 0x11
#define m_H 0x12
#define m_I 0x13
#define m_J 0x14
#define m_K 0x15
#define m_L 0x16
#define m_M 0x17
#define m_N 0x18
#define m_O 0x19
#define m_P 0x1A
#define m_Q 0x1B
#define m_R 0x1C
#define m_S 0x1D
#define m_T 0x1E
#define m_U 0x1F
#define m_V 0x20
#define m_W 0x21
#define m_X 0x22
#define m_Y 0x23
#define m_Z 0x24
#define m_a 0x25
#define m_b 0x26
#define m_c 0x27
#define m_d 0x28
#define m_e 0x29
#define m_f 0x2A
#define m_g 0x2B
#define m_h 0x2C
#define m_i 0x2D
#define m_j 0x2E
#define m_k 0x2F
#define m_l 0x30
#define m_m 0x31
#define m_n 0x32
#define m_o 0x33
#define m_p 0x34
#define m_q 0x35
#define m_r 0x36
#define m_s 0x37
#define m_t 0x38
#define m_u 0x39
#define m_v 0x3A
#define m_w 0x3B
#define m_x 0x3C
#define m_y 0x3D
#define m_z 0x3E
#define m_KLa 0x3F ; (
#define m_KLz 0x40 ; )
#define m_. 0x41
#define m_? 0x42
#define m_sem 0x43 ; ;
#define m_: 0x44
#define m_ko 0x45 ; ,
#define m_ag 0x46 ; Agostroff
#define m_bs 0x47 ; Backslasch
#define m_as 0x48 ; Anfürungsstriche
#define m_minus 0x49 ; Minus
#define m_ka 0x4A ; <
#define m_ga 0x4B ; >
#define m_at 0x4C ; @ oder at
#define m_wait 0xfb ; Wartezeichen
#define m_ls 0xf9 ; Lautsprecher
#define m_lso 0xfa ; Tonsignal
#define m_ff 0xff ; Ausgefültes feld
return

max7456_conf ; Max7456 Config
movlw 0x00 ; VM0 Video Mode Register 0 (Write)
movwf SPI_DATA_WRITE
call SPI_Send
movlw B'01001000' ; 0 , 1=PAL, 00=Auto Sync, 1=Enable OSD, 0=Enable OSD immer, 0=SW RST, 0=Enable Video Buffer
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0x01 ; VM1 Video Mode Register 1
movwf SPI_DATA_WRITE
call SPI_Send
movlw B'00000100' ; 0 = NA, 000=Background MODE Brightness 100%, 11=Blinking Time 160ms, 00=Blinking Duty Cycle BT:BT
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0x02 ; HOS Horizontal Offset Register
movwf SPI_DATA_WRITE
call SPI_Send
movlw B'00101111' ; 00 = NA, 100000 = Horitzontal Offset
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0x03 ; VOS Vertical Offset Register
movwf SPI_DATA_WRITE
call SPI_Send
movlw B'00010111' ; 000 = NA, 10000 = Vertical Offset
movwf SPI_DATA_WRITE
call SPI_Send
return

max7456_cls ; max7456 ausgabe Löschen
movlw 0x00 ; VM0 Video Mode Register 0 (Write)
movwf SPI_DATA_WRITE
call SPI_Send
movlw B'01001010' ; 0 , 1=PAL, 00=Auto Sync, 1=Enable OSD, 0=Enable OSD immer, 1=SW RST, 0=Enable Video Buffer
movwf SPI_DATA_WRITE
call SPI_Send
call max7456_conf
return

max7456_add_high ; High adressbereich
movlw 0x05 ; Ersten 256 zeichen Low = 0x00, Letzten 256 Zeichen High=0xff
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0xFF
movwf SPI_DATA_WRITE
call SPI_Send
return

max7456_add_low ; Low Adressbereich
movlw 0x05 ; Ersten 256 zeichen Low = 000, Letzten 256 Zeichen High=225
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0x00
movwf SPI_DATA_WRITE
call SPI_Send
return

max7456_send_char
movlw 0x06 ; Zeichen Position links nach rechts erste reihe 0-29, 30-......
movwf SPI_DATA_WRITE
call SPI_Send
movf m_pos, W
movwf SPI_DATA_WRITE
call SPI_Send
movlw 0x07 ; Zeichen Sonderzeichen sihe Define in max7456.inc
movwf SPI_DATA_WRITE
call SPI_Send
movf m_char, W
movwf SPI_DATA_WRITE
call SPI_Send
return
</pre>

Zeichen Senden:
<pre>
movlw D'12' ; Position
movwf m_pos
movlw m_e ; Zeichen (hier das kleine e) oder direkt den wert des Zeichens im MAX7456 REG.
movwf m_char
call max7456_send_char; Schreiben
</pre>

High/low Adressbereich (low = ersten 256 Zeichen, High die letzten 128 Zeichen);

<pre>
call max7456_add_low ; Low Adressbereich
;call max7456_add_high; Low Adressbereich
</pre>

--[[Benutzer:Theborg|Theborg]] 23:13, 15. Sep 2009 (CEST)

= PIC18(F/LF)xxxx =

Diskussion:FIFO mit avr-gcc

2009-11-12T17:17:38Z

Hae:

== Erweiterungen ==

Schön wäre es, wenn man auch einen FIFO-Überlauf oder HW-Fehler, wie Framing Error oder Overrun, melden würde.
Habe das für FIFO-Überlauf mal gemacht.

Hier meine Erweiterungen zum Code:

'''fifo.h'''

<pre>
enum {
Fifo_Overrun = 1
};

typedef struct
{
unsigned char volatile count; // # Zeichen im Puffer
unsigned char size; // Puffer-Größe
unsigned char *pread; // Lesezeiger
unsigned char *pwrite; // Schreibzeiger
unsigned char read2end, write2end; // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
unsigned char state;
} fifo_t;

static inline uint8_t
_inline_fifo_put (fifo_t *f, const uint8_t data)
{
unsigned char write2end;
unsigned char* pwrite;
unsigned char cRet;

cRet = 0;

if (f->count >= f->size)
{
f->state = Fifo_Overrun;
cRet = 1;
goto end;
}
...

end:
return cRet;
}

static inline uint8_t
_inline_fifo_get (fifo_t *f)
{
unsigned char* pread;
unsigned char data;
unsigned char read2end;

if (f->state) return -2;
if (!f->count) return -1;

...
}
</pre>

Dann noch eine Erweiterung. Ich lese nur ganze Zeilen von der seriellen Schnittstelle. Also fand ich es gut eine Funktion zu haben, die gleich im Fifo nach schaut, ob eine Zeile vorhanden ist.

'''fifo.c'''
<pre>
int fifo_gets (fifo_t *f, char *buf, int *len )
{
unsigned char* pread;
unsigned char count;
unsigned char idx;
int result;
unsigned char read2end;

if (f->state) return -2;
if (!f->count) return -1;

pread = f->pread;
count = f->count;
read2end = f->read2end;

result = 1;
idx = 0;
while (count != 0)
{
count--;

if (read2end-- == 0)
{
read2end = f->size-1;
pread -= f->size;
}

buf[idx] = *(pread++);
if (buf[idx] == '\n' || buf[idx] == '\r')
{
result = 0;
break;
}
idx++;
}

/* Wenn ein \r\n gesendet wird ist beim ersten Lesen eine ganze Zeile
* in buf. Beim zweiten Lesen nur 1 Zeichen. In der höherliegenden Logik,
* wird immer eine sinnvolle komplette Zeile erwartet.
* Deshalb wird eine "Zeile" mit nur einem Zeichen ignoriert.
*/
if ((result == 0) && (idx > 1))
{
f->pread = pread;
f->read2end = read2end;

f->count = count;
*len = idx;
buf[idx] = '\0';
}
else
{
buf[0] = '\0';
*len = 0;
}

return result;
}
</pre>

----
int fifo_get_nowait (fifo_t *b)
Liefert das nächste Byte aus der FIFO als int bzw. -1, falls die FIFO leer ist.

Was machst du, wenn FF gespeichert ist ? oder muß das nur für Text gehen ?
--PicNick 18:16, 4. Mär 2006 (CET)

----

Wenn FF gespeichert ist, wird FF zurück geliefert. Die FIFOs speichern ihre Werte als unsigned. Der return-Wert ist int, mithin ist also <tt>255 != -1</tt>.
Will man ein <tt>char</tt> lesen, dann so:
<pre>
char zeichen;
int value;
if (value = fifo_get_nowait (&fifo), value >= 0)
zeichen = (char) value;
</pre>
bzw. man schreibt <tt>value</tt> direkt nach UDR oder wohin auch immer. --[[Benutzer:SprinterSB|SprinterSB]] 19:04, 4. Mär 2006 (CET)
----
d.h. du verwendest die Bits >8 implizit als Schalter ? naja.
--PicNick 08:59, 5. Mär 2006 (CET)
----
In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB|SprinterSB]] 09:59, 5. Mär 2006 (CET)

----
Mach nur, die Geschmäcker sind halt verschieden, absolute Wahrheiten gibt's nicht. Ich trenne immer Frage und Abholen, wobei die Frage immer non-destruktiv nach der verfügbaren Länge ist.
<pre>
while (fifo_data() >= required_length ) // anzahl im Buffer
{
Uns_16 = fifo_read_short() // oder ähnlich
}
</pre>
Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.
--PicNick 12:05, 5. Mär 2006 (CET)

Jo, das geht auch. Auf <tt>fifo.count</tt> kann man ja frei zugreifen. Beim nachfolgenden Lesen sind aber evtl. mehr Zeichen im Puffer, was bei den meisten Anwendungen nicht stört. Es sollte nur ein einfaches Grundgerüst sein, das man nach eigenem Gusto erweitern kann, etwa
static inline int fifo_contains_at_least_n_bytes_p (const fifo_t * f, const unsigned char num) { f->count >= num; }

Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB|SprinterSB]] 22:32, 5. Mär 2006 (CET)
----
*g* Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.
--PicNick 07:59, 6. Mär 2006 (CET)

== habe ich hier ein sei(); übersehen ? ==

Hallo Sprinter :-)

Ich analysiere gerade deine FIFO Puffer, klasse !

Nur eine Frage stellt sich noch, hier
<pre>
uint8_t sreg = SREG;
cli();
f->count--;
SREG = sreg;
</pre>

Muß da nicht noch ein sei(); hin<br/>
Oder hab ich da was übersehen ?<br/>
Gruß Sebastian
--[[Benutzer:Izaseba|izaseba]] 21:34, 23. Apr 2007 (CEST)

:Hi Sebastian. Durch die letzte Anweisung wird das SREG und insbesondere das darin befindliche I-Flag wieder so hergestellt, wie es ursprünglich war. Wenn der Code immer in einem Kontext ausgeführt wird, in dem Interrupts global aktiviert sind, dann geht es mit einer CLI/SEI-Klammer natürlich etwas simpler. --[[Benutzer:SprinterSB|SprinterSB]] 12:53, 12. Mai 2007 (CEST)

Diskussion:FIFO mit avr-gcc

2009-11-12T17:15:51Z

Hae: Erweiterungsvorschläge

Schön wäre es, wenn man auch einen FIFO-Überlauf oder HW-Fehler, wie Framing Error oder Overrun, melden würde.
Habe das für FIFO-Überlauf mal gemacht.

Hier meine Erweiterungen zum Code:

'''fifo.h'''

<pre>
enum {
Fifo_Overrun = 1
};

typedef struct
{
unsigned char volatile count; // # Zeichen im Puffer
unsigned char size; // Puffer-Größe
unsigned char *pread; // Lesezeiger
unsigned char *pwrite; // Schreibzeiger
unsigned char read2end, write2end; // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
unsigned char state;
} fifo_t;

static inline uint8_t
_inline_fifo_put (fifo_t *f, const uint8_t data)
{
unsigned char write2end;
unsigned char* pwrite;
unsigned char cRet;

cRet = 0;

if (f->count >= f->size)
{
f->state = Fifo_Overrun;
cRet = 1;
goto end;
}
...

end:
return cRet;
}

static inline uint8_t
_inline_fifo_get (fifo_t *f)
{
unsigned char* pread;
unsigned char data;
unsigned char read2end;

if (f->state) return -2;
if (!f->count) return -1;

...
}
</pre>

Dann noch eine Erweiterung. Ich lese nur ganze Zeilen von der seriellen Schnittstelle. Also fand ich es gut eine Funktion zu haben, die gleich im Fifo nach schaut, ob so eine Funktion vorhanden ist.

'''fifo.c'''
<pre>
int fifo_gets (fifo_t *f, char *buf, int *len )
{
unsigned char* pread;
unsigned char count;
unsigned char idx;
int result;
unsigned char read2end;

if (f->state) return -2;
if (!f->count) return -1;

pread = f->pread;
count = f->count;
read2end = f->read2end;

result = 1;
idx = 0;
while (count != 0)
{
count--;

if (read2end-- == 0)
{
read2end = f->size-1;
pread -= f->size;
}

buf[idx] = *(pread++);
if (buf[idx] == '\n' || buf[idx] == '\r')
{
result = 0;
break;
}
idx++;
}

/* Wenn ein \r\n gesendet wird ist beim ersten Lesen eine ganze Zeile
* in buf. Beim zweiten Lesen nur 1 Zeichen. In der höherliegenden Logik,
* wird immer eine sinnvolle komplette Zeile erwartet.
* Deshalb wird eine "Zeile" mit nur einem Zeichen ignoriert.
*/
if ((result == 0) && (idx > 1))
{
f->pread = pread;
f->read2end = read2end;

f->count = count;
*len = idx;
buf[idx] = '\0';
}
else
{
buf[0] = '\0';
*len = 0;
}

return result;
}
</pre>

----
int fifo_get_nowait (fifo_t *b)
Liefert das nächste Byte aus der FIFO als int bzw. -1, falls die FIFO leer ist.

Was machst du, wenn FF gespeichert ist ? oder muß das nur für Text gehen ?
--PicNick 18:16, 4. Mär 2006 (CET)

----

Wenn FF gespeichert ist, wird FF zurück geliefert. Die FIFOs speichern ihre Werte als unsigned. Der return-Wert ist int, mithin ist also <tt>255 != -1</tt>.
Will man ein <tt>char</tt> lesen, dann so:
<pre>
char zeichen;
int value;
if (value = fifo_get_nowait (&fifo), value >= 0)
zeichen = (char) value;
</pre>
bzw. man schreibt <tt>value</tt> direkt nach UDR oder wohin auch immer. --[[Benutzer:SprinterSB|SprinterSB]] 19:04, 4. Mär 2006 (CET)
----
d.h. du verwendest die Bits >8 implizit als Schalter ? naja.
--PicNick 08:59, 5. Mär 2006 (CET)
----
In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB|SprinterSB]] 09:59, 5. Mär 2006 (CET)

----
Mach nur, die Geschmäcker sind halt verschieden, absolute Wahrheiten gibt's nicht. Ich trenne immer Frage und Abholen, wobei die Frage immer non-destruktiv nach der verfügbaren Länge ist.
<pre>
while (fifo_data() >= required_length ) // anzahl im Buffer
{
Uns_16 = fifo_read_short() // oder ähnlich
}
</pre>
Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.
--PicNick 12:05, 5. Mär 2006 (CET)

Jo, das geht auch. Auf <tt>fifo.count</tt> kann man ja frei zugreifen. Beim nachfolgenden Lesen sind aber evtl. mehr Zeichen im Puffer, was bei den meisten Anwendungen nicht stört. Es sollte nur ein einfaches Grundgerüst sein, das man nach eigenem Gusto erweitern kann, etwa
static inline int fifo_contains_at_least_n_bytes_p (const fifo_t * f, const unsigned char num) { f->count >= num; }

Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB|SprinterSB]] 22:32, 5. Mär 2006 (CET)
----
*g* Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.
--PicNick 07:59, 6. Mär 2006 (CET)

== habe ich hier ein sei(); übersehen ? ==

Hallo Sprinter :-)

Ich analysiere gerade deine FIFO Puffer, klasse !

Nur eine Frage stellt sich noch, hier
<pre>
uint8_t sreg = SREG;
cli();
f->count--;
SREG = sreg;
</pre>

Muß da nicht noch ein sei(); hin<br/>
Oder hab ich da was übersehen ?<br/>
Gruß Sebastian
--[[Benutzer:Izaseba|izaseba]] 21:34, 23. Apr 2007 (CEST)

:Hi Sebastian. Durch die letzte Anweisung wird das SREG und insbesondere das darin befindliche I-Flag wieder so hergestellt, wie es ursprünglich war. Wenn der Code immer in einem Kontext ausgeführt wird, in dem Interrupts global aktiviert sind, dann geht es mit einer CLI/SEI-Klammer natürlich etwas simpler. --[[Benutzer:SprinterSB|SprinterSB]] 12:53, 12. Mai 2007 (CEST)