ATNEL tech-forum

Re: SPI 9 bit na AtMega

2018-04-10T22:45:35+01:00

Witajcie,

Poniższa koncepcja działa dla wyświetlacza.

Jeżeli mam wysłać 9 bitów a mam sprzętowo 8 bitów, to wysyłając kolejno 9 bajtów mam wysłane 8 tych 9-cio bitowych.
Nie trzeba się martwić o to, że jedno 9cio bitowe słowo jest zawsze w dwóch kolejnych transmisjach.

Jedyne co jest ważne, to
- trzymać cały czas linię CS aktywną
- zakończyć transmisję po przesłaniu wielokrotności paczek po 9 bajtów.

Jak brakuje danych do wysłania żeby zakończyć na wielokrotności 9 bajtów to podpowiadam, że mamy instrukcję NOP i można ich wstawić dowolnie dużo.

Poniżej obrazek jak to wygląda w praktyce. Dekodowane jest 9 bitowe SPI.

Andrzej

Statystyki: Napisane przez jedrunia — 10 kwi 2018, o 22:45

Re: SPI 9 bit na AtMega

2017-10-25T20:45:08+01:00

Eh... Niestety. Po transferze 8 bitów na linii MOSI jest dodatkowe zbocze po zboczu zatrzaskującym na SCK, czyli występuje pierwszy warunek transferu do sterownika. Klapnięcie linią CS nic już wtedy nie wnosi - czyli zostaje mix SW i HW.

Statystyki: Napisane przez eventus — 25 paź 2017, o 20:45

Re: SPI 9 bit na AtMega

2017-10-25T08:08:12+01:00

Wałkuję ten sam temat w kontekście sterownika do LCD od Nokii 1202. Sposób z AVR Freaks działa (mix HW SPI i bit-banging), ale zastanawiam się czy próbowaliście przesłać np. 2 bajty przez SPI w taki sposób:

[syntax=c]#include
#include
#include "spi.h"

unsigned char spi_init(void)
{
DDRB = (1< SPCR = (1<}

char spi_send(unsigned char hi_byte, unsigned char lo_byte)
{
PORTB &= ~ (1< SPDR = hi_byte;
while (!(SPSR & (1< SPDR = lo_byte;
while (!(SPSR & (1< PORTB |= (1< return SPDR;
}[/syntax]

Najstarsze bity hi_byte zostaną przepchnięte i "wylecą" - zostanie tylko jeden bit określający DATA/COMMAND. Sterownik zinterpretuje tylko ten jeden bit i cały lo_byte. Machnięcie linią CS powinno zatrzasnąć te 9-bitów w rejestrze sterownika. Dobrze kombinuję?

Poniżej fragment noty do STE2007, który sugerowałby taki mechanizm:

Statystyki: Napisane przez eventus — 25 paź 2017, o 08:08

Re: SPI 9 bit na AtMega

2017-03-05T21:52:26+01:00

Po walce z asemblerem udało mi się stworzyć działający kod ale wyszło jakoś wolno. Za cienki w uszach widać jeszcze jestem.
Zmontowałem więc kod w c++ i nawet udało mi się osiągnąć coś koło 2Mhz zegara.
Może komuś się przyda
[syntax=cpp]#define LCD_DDR DDRC
#define LCD_PORT PORTC
#define _CS PC0
#define _SDA PC1
#define _SCK PC2
#define LCD_CS (1<<_CS)
#define LCD_SDA (1<<_SDA)
#define LCD_SCK (1<<_SCK)

#define cbi(sfr,bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr,bit) (_SFR_BYTE(sfr) |= _BV(bit))

void Send_SPI9(uint8_t _isCmd, uint8_t _data) {
LCD_PORT &= ~(LCD_CS | LCD_SCK);
//
cbi(LCD_PORT, _SCK);
if (_isCmd) cbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 128) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 64) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 32) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 16) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 8) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 4) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 2) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
//
LCD_PORT &= ~(LCD_SCK | LCD_SDA);
if (_data & 1) sbi(LCD_PORT, _SDA);
sbi(LCD_PORT, _SCK);
}[/syntax]
Tak to wygląda w analizatorze który niedawno mi dostarczono (zajefajna rzecz, polecam)

Spróbuję w wolnej chwili powalczyć z kodem od Zealota.
Dzięki wszystkim za pomoc i zainteresowanie.
Pozdrawiam

Statystyki: Napisane przez radek3035 — 5 mar 2017, o 21:52

Re: SPI 9 bit na AtMega

2017-02-28T10:08:15+01:00

Zabrałem się za napisanie tego w asm. Za przykład
Biorę wstawkę z poradnika o magic ledach.
Ale tam jest błąd chyba i zamiast jednego pinu
Zmienia sie cały port. Brak operacji or i and przed sts.
Aczkolwiek mogę się mylić bo dopiero raczkuje.
Jak ktoś się zna to niech mnie poprawi będę miał dodatkową wiedzę.
Zamówiłem dziś analizator stanów to będę mógł
sprawdzić tą wstawkę i dopracować kod czasowo.

Wypociłem dziś taki kod:
[syntax=cpp]LCD_asm_send_data( uint8_t cmd, uint16_t *data, uint16_t datlen) {
uint8_t cnt = 0, sdaLO = ~LCD_SDA, sckLO = ~LCD_CLK;
uint8_t port = 0;
port = (LCD_SDA | LCD_CLK | LCD_CS);
LCD_PORT &= ~(LCD_CLK | LCD_CS); //wyzerowanie CLK i CS
asm volatile(
" cpi %[cmd],1 \n\t" // sprawdzenie czy komenda
" brne nocom%= \n\t" // jesli nie to skok
" and %[port], %[sdaLO] \n\t" // wyzerowanie bitu data
" nocom%= :or %[port], %[sdaHI] \n\t" // ustaw bit data na hi
" out %[lcd_port], %[port] \n\t" // zaladuj do portu lcd
" or %[port], %[sckHI] \n\t" // ustaw sck na hi
" out %[lcd_port], %[port] \n\t" // zaladuj do portu lcd
"mPTL%=:subi %A5,1 \n\t" // odejmij stala od zawartosci rejestru
" sbci %B5,0 \n\t" // Odejmij stała z przeniesieniem od zawartosci rejestru
" brcs exit%= \n\t" // Skok względny jeśli flaga przeniesienia
// jest ustawiona (gdy C=1)
" ld %[databyte], X+ \n\t" // Ładuj rejestr Rd pośrednio daną
// z pamięci SRAM znajdującą się pod
// adresem wskazanym przez rejestr
// indeksowy X z postinkrementacją
// rejestru X
" ldi %[cnt], 8 \n\t" // Ładuj rejestr Rd bezpośrednio
// wartością stałej z zakresu 0...255
"oPTL%=:and %[port], %[sckLO] \n\t" // wyzerowanie sck
" out %[lcd_port], %[port] \n\t" // zaladuj do portu lcd
" or %[port], %[sdaHI] \n\t" // ustaw bit data na hi
" lsl %[databyte] \n\t" // rotacja bitow w lewo
" brcs nxtbit%= \n\t" // Skok względny jeśli flaga przeniesienia
// jest ustawiona (gdy C=1)
" and %[port], %[sdaLO] \n\t" // wyzerowanie bitu data
" out %[lcd_port], %[port] \n\t" // zaladuj do portu lcd
"nxtbit%=:nop \n\t"
" or %[port], %[sckHI] \n\t" // ustaw sck na hi
" out %[lcd_port], %[port] \n\t" // zaladuj do portu lcd
" dec %[cnt] \n\t" // odejmij 1 od licznika
" breq mPTL%= \n\t" // Skok względny jeśli równe (gdy Z=1)
" rjmp oPTL%= \n\t" // Skok do petli
" exit%=: \n\t" // koniec
: [cnt]"=&d" (cnt),[port]"=&d" (port), [cmd]"=&d" (cmd)
: [databyte]"e" (data), [lcd_port]"I" (_SFR_IO_ADDR(LCD_PORT)), [datlen]"d" (datlen),
[sdaHI]"d" (LCD_SDA), [sdaLO]"d" (sdaLO), [sckHI]"d" (LCD_CLK), [sckLO]"d" (sckLO)
);
}[/syntax]
kompiluje się ,mikroprocesor pracuje ale na wyświetlaczu nic się nie dzieje.
Jakie błędy popełniłem?
Ps wyciąłem wszystkie "nopy" z kodu żeby był czytelniejszy.

Statystyki: Napisane przez radek3035 — 28 lut 2017, o 10:08

Re: SPI 9 bit na AtMega

2017-02-25T09:36:22+01:00

Jeśli chodzi o komendy i ostatni fragment z dokumentacji wydaje mi się że to nic nie zmienia w implementacji pomysłu.
Jest tylko jedna różnica, najpierw należy "wrzucić" nadmiarowy, dziewiąty bit (C/D) oczywiście w zależności czy 0 czy 1 ustawić wyjście MOSI, pamiętając o wyłączeniu sprzętowego SPI na ten czas. Następnie włączyć SPI i podać 8 kolejnych bitów.

[syntax=c]void send_9bit_command(uint8_t CD, uint8_t command) {
CS_LO;

SPCR &= ~(1<if (CD)
MOSI_HI;
else
MOSI_LO;
CLK_HI;// Software'owe "tyknięcie" zegara
CLK_LO;// Inaczej "zatrzaśnięcie" 9 bitu w sterowniku wyświetlacza

SPCR |= (1<sw_hardware_SPI_write( command );//Wysyłamy resztę, 8 pozostałych bitów komendy

CS_HI;
}[/syntax]

Patrząc pobieżnie na ten sterownik i jego dokumentację wydaje się, ze sposób jego sterowania jest bardzo podobny do innych sterowników, nawet tych prostszych, jak popularne oledowe SSD1306.

Zajrzyj może na mirkowe poradniki o SSD1306. Przydałby Ci się również greenbook, bo tam był sposób programowania wyświetlaczy graficznych.

Statystyki: Napisane przez Zealota — 25 lut 2017, o 09:36

Re: SPI 9 bit na AtMega

2017-02-24T21:26:30+01:00

O tym samym myślałem,ale komendy wykorzystują całe 9 bitów a i data tylko w przypadku kolorów wykorzystuje 3 x 6 (18 bit color) a inne też całe 9 bitów.
Więc samym zegarem tego nie przeskoczę. Myślę że może wstawka assemblerowa by lepiej zadziałała ale jeszcze jestem zbyt "zielony" w te klocki.

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 21:26

Re: SPI 9 bit na AtMega

2017-02-24T20:43:33+01:00

radek3035 napisał(a):

Zealota napisał(a):

Pomiędzy każdy bajt, wysłany sprzętowo, "wrzucasz" jedno "tyknięcie" zegara, po to by sterownik będący cały czas w CS = low, tylko "odhaczył, ten 9 nic nie znaczący bit.

bity idą od Msb czyli od D8 do D0, Pierwszy ustawiony na 'H' sygnalizuje że nadaję dane a na' L' że nadaję komendę. Nie da się go pominąć. Ustawiam CS na 'L'
Nadaję komendę a potem może być od zera do kilkudziesięciu danych nawet. Czyli pierwszy bit przesyłany na' L' i 8 bitów komendy potem bit danych 'H' i 8 bitów danych, bit 'H' i następne 8 bitów danych i następne... itd.. ewentualnie następny stan 'L' i 8 bitów nowej komendy i 'H' i 8 bit danych...

Hmm chyba nie zrozumieliśmy się . Mi chodziło, że tę "drugą stronę" pomijamy Najpierw idzie MSB, czyli znacznik komendy albo danych i to oczywiście zostawiamy i po kolei następne bity, aż dochodzi do dwóch ostatnich, które nie mają znaczenia, a ostatni z nich, czyli LSB "nadajemy" poprzez to dodatkowe, softwarowe "tyknięcie".
Tutaj nie ma znaczenia czy L czy H bo sterownik to pomija.
Należy pamiętać, ze w HW SPI mozemy sobie ustawi czy LSB czy MSB ma iść pierwszy, oczywiście w tym wypadku MSB (nie ustawiamy bitu DORD)
Zrobiłem dodatkowe testy, zmodyfikowałem kod:
[syntax=c]void send_colors(uint8_t r, uint8_t g, uint8_t b) {
CS_LO;

sw_hardware_SPI_write( r<<1 );//8 bitów

SPCR &= ~(1<SCK_HI;// 9 bit
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
SCK_LO;

SPCR |= (1<sw_hardware_SPI_write( g<<1 );//8 bitów

SPCR &= ~(1<SCK_HI;// 9 bit
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
SCK_LO;

SPCR |= (1<sw_hardware_SPI_write( b<<1 );//8 bitow

SPCR &= ~(1<SCK_HI;// 9 bit
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
SCK_LO;

SPCR |= (1<

CS_HI;
}[/syntax]
Okazuje się, że SPI musi być wyłączone, gdy chcemy sobie "tyknąć" softwarowo zegarem.
Wrzuciłem na atmege328p kod i z zrobiłem screeny z analizatora stanów:

Popatrz jak ładnie widać te 9 tyknięcie, jest nieco węższe, ale można regulować instrukcją nop.
Drugi obrazek to już prędkość 4MHz, oczywiście samego zegara SPI.

Oczywiście mogłem popełnić jakiś błąd myślowy, nie będę się upierał , ale na razie wychodzi mi, że to może działać.

------------------------ [ Dodano po: 1 minucie ]

krish napisał(a):

"Kto szuka ten błądzi"?
W poście #8 z tego linku po drobnych przeróbkach masz kod, który powinien załatwić Twój problem (mix of bit-bang and hardware SPI):
http://www.avrfreaks.net/forum/9-bit-spi

Hehe, wydaje się, że właśnie chyba o tym pisałem w tych moich "wywodach"

Statystyki: Napisane przez Zealota — 24 lut 2017, o 20:43

Re: SPI 9 bit na AtMega

2017-02-24T20:39:39+01:00

Statystyki: Napisane przez krish — 24 lut 2017, o 20:39

Re: SPI 9 bit na AtMega

2017-02-24T20:13:56+01:00

Zealota napisał(a):

Pomiędzy każdy bajt, wysłany sprzętowo, "wrzucasz" jedno "tyknięcie" zegara, po to by sterownik będący cały czas w CS = low, tylko "odhaczył, ten 9 nic nie znaczący bit.

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 20:13

Re: SPI 9 bit na AtMega

2017-02-24T19:41:22+01:00

radek3035 napisał(a):

Napisałem sterownik dla SPFD54124. Działa ale chciałbym szybciej. No i tu jest 128x160 pixeli a myślę o większym troszkę i wtedy będzie jeszcze wolniej...

Hmm a może taki "chytry sposób:
Dzielisz paczki na 8 bitowe. Każdy 9 bit jest bez znaczenia. Chodzi mi oczywiście o LSB.
Tworzysz więc 3 bajty, które wysyłasz po SPI sprzętowym, gdzie MSB jest oczywiście pierwszym wysłanym "bitem" dla każdej bajtu..
Pomiędzy każdy bajt, wysłany sprzętowo, "wrzucasz" jedno "tyknięcie" zegara, po to by sterownik będący cały czas w CS = low, tylko "odhaczył, ten 9 nic nie znaczący bit.
To 9 tyknięcie zegara należy dobrać czasowo tak by było zgodne z dokumentacją.
Prawdopodobnie wystarczy rzucić dwie komendy CLK_HI i CLK_LO, nawet bez dodatkowego opóźnienia i zbocze narastające "zaliczy" ostatni bit.
Oczywiście bajty z konkretnymi danymi w słowach 8 bitowych należy poprzestawiać przesunięciem bitowym.

[syntax=c]void hardware_SPI_write( uint8_t data ) {
SPDR = data;
while ( !( SPSR&(1<}

void send_colors(uint8_t r, uint8_t g, uint8_t b) {
CS_LO;

sw_hardware_SPI_write( r<<1 );//8 bitów
CLK_HI;// 9 bit
CLK_LO;
sw_hardware_SPI_write( g<<1 );//8 bitów
CLK_HI;// 9 bit
CLK_LO;
sw_hardware_SPI_write( b<<1 );//8 bitow
CLK_HI;// 9 bit
CLK_LO;

CS_HI;
}[/syntax]

Powyższy kod to taki niedoskonały zarys, ale mam nadzieję, że wiadomo o co chodzi.
Samo SPI w AVR po każdym wysłanym bajcie zatrzymuje zegar.
Dodatkowo należy oczywiście parametry dobrze ustawić CPOL, CPHA DORD i co tam jeszcze trzeba.

Statystyki: Napisane przez Zealota — 24 lut 2017, o 19:41

Re: SPI 9 bit na AtMega

2017-02-24T19:30:13+01:00

MirkoT napisał(a):

To może powinieneś troszkę inaczej podejść do tej transmisji.
Zrobić sobie bufor obrazu w którym od razu na poszczególnych bitach
ustalasz co tam jest czyli dane przeplatasz tym bitem data. Wiem to
komplikuje obliczanie pozycji.
A potem jednym ciągiem wyrzucasz cały bufor na wyświetlacz korzystając
ze sprzętowego I2C czy TWI to już wsio ryba.

Właśnie oglądam Magic Ledy p.Mirka i zaczynam mieć zarys pomysłu. Zajefajny poradnik i chyba sobie zafunduję książkę.
Natomiast bufor musiałby mieć 128*160*3 bajty to 61 440 bajtów..
Aczkolwiek można by wykorzystać Partial Area i buforować tylko potrzebny fragment.
Jeszcze raczkuję w C i AVR więc chętnie posłucham wszystkich którzy maja jakiś pomysł realizacji.

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 19:30

Re: SPI 9 bit na AtMega

2017-02-24T19:02:58+01:00

Statystyki: Napisane przez MirkoT — 24 lut 2017, o 19:02

Re: SPI 9 bit na AtMega

2017-02-24T18:36:49+01:00

Napisałem sterownik dla SPFD54124. Działa ale chciałbym szybciej. No i tu jest 128x160 pixeli a myślę o większym troszkę i wtedy będzie jeszcze wolniej...

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 18:36

Re: SPI 9 bit na AtMega

2017-02-24T18:34:47+01:00

radek3035 napisał(a):

W datasheet jest napisane: 3-pin 9 bits Serial Peripheral Interface (SPI)
Nazwy nadałem sam. Tak jak Zealota napisał SDA - Serial Data etc.

Zdradź może o jaki sterownik LCD chodzi.

Statystyki: Napisane przez Zealota — 24 lut 2017, o 18:34

Re: SPI 9 bit na AtMega

2017-02-24T18:43:11+01:00

SP2LUB napisał(a):

Ok ja tam sie nie znam, ale w magistrali SPI widzę MOSI i MISO natomiast nazwy linii które podajesz są charakterystyczne dla I2C. Tak samo wyświetlacz LCD który chcesz sterować jest zrobiony pewnie dla magistrali I2C.
Jak mówię ja się nie znam i początkujący jestem, ale SPI to SPI a I2C to I2C po coś te nazwy wprowadzono i łatwiej się poroznmiewać używając takich określeń. Tym bardziej że Atmega ma rozwiązania sprzętowe zarówno dla SPI jak i I2C więc nic tylko odpalać i śmigać.

Tutaj MOSI i MISO jest na linii DATA. Jest dwukierunkowa. Tak jak w I2C ale nie adresujesz układu tylko wybierasz poprzez LOW na CS.
9-ty bit transmisji ustala czy nadajesz komendę(LOW) czy dane(HIGH), tzn. następne 8 bitów
Jak widać a załączonym wcześniej obrazku z datasheet, piny również mają nazwy CSX, SCL i SDA...

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 18:32

Re: SPI 9 bit na AtMega

2017-02-24T18:26:13+01:00

Statystyki: Napisane przez SP2LUB — 24 lut 2017, o 18:26

Re: SPI 9 bit na AtMega

2017-02-24T18:27:04+01:00

W datasheet jest napisane: 3-pin 9 bits Serial Peripheral Interface (SPI)
Nazwy nadałem sam. Tak jak Zealota napisał SDA - Serial Data etc.

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 18:20

Re: SPI 9 bit na AtMega

2017-02-24T17:59:28+01:00

SP2LUB napisał(a):

Kolego a czy nie mylisz przypadkiem magistrali SPI z i2C? w Atmega masz śliczne i2c gotowe do śmigania.

Myślę, że Kolega nic nie myli, ale dowiemy się gdy sam się wypowie:)
SDA - to Serial Data
CS - Chip Select
CLK - Clock

SDA to prawdopodobnie zbieżność nazw z TWI.
A reszta nazw to klasyka dla transmisji szeregowej, w szerokim rozumieniu.

Statystyki: Napisane przez Zealota — 24 lut 2017, o 17:59

Re: SPI 9 bit na AtMega

2017-02-24T16:36:39+01:00

Kolego a czy nie mylisz przypadkiem magistrali SPI z i2C? w Atmega masz śliczne i2c gotowe do śmigania.

Statystyki: Napisane przez SP2LUB — 24 lut 2017, o 16:36

Re: SPI 9 bit na AtMega

2017-02-24T15:50:10+01:00

Zrobiłem tak:
[syntax=c]void Send(boolean isCmd, uint8_t Data) {
LCD_PORT &= ~(LCD_CLK | LCD_CS); //wyzerowanie CLK i CS
if (isCmd)LCD_PORT &= ~LCD_SDA; //if CMD wyzerowanie DATA (bit Comand/Data)
LCD_PORT |= LCD_CLK; //ustawienie CLK na 1
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA); //wyzerowanie CLK i DATA
if (Data & 128)LCD_PORT |= LCD_SDA; //if DATA 1 Ustawienie 1 na DATA
LCD_PORT |= LCD_CLK; //ustawienie CLK na 1
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 64)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 32)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 16)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 8)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 4)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 2)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT &= ~(LCD_CLK | LCD_SDA);
if (Data & 1)LCD_PORT |= LCD_SDA;
LCD_PORT |= LCD_CLK;
//
LCD_PORT |= (LCD_CLK | LCD_SDA | LCD_CS); //ustawienie portu na 1
}[/syntax]
Troszkę pomogło i jest ciut szybciej. Ale to jeszcze za mało.

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 15:50

Re: SPI 9 bit na AtMega

2017-02-24T14:15:58+01:00

radek3035 napisał(a):

Ewentualnie jak można inaczej zrealizować kod aby wysyłanie było bardziej "sprzętowe" lub szybsze?

Powinieneś zajrzeć do mirkowego poradnika na temat magic ledów, gdzie były opisywane, dodatkowe optymalizacje kodu dla transmisji szeregowych.
W skrócie musisz rozwinąć pętlę "for" do pojedynczych instrukcji, zyskasz wtedy na czasie, ale stracisz na objętości kodu w pamięci flash.

Statystyki: Napisane przez Zealota — 24 lut 2017, o 14:15

SPI 9 bit na AtMega

2017-02-24T13:09:11+01:00

Witam wszystkich.
Jestem w trakcie "robienia" biblioteki do obsługi lcd. Wadą a zarazem i zaletą tego wyświetlacza jest 3-pinowa transmisja danych (CS,SDA,CLK)
AtMega posiada sprzętowy interfejs SPI ale 8-mio bitowy, a tutaj jest potrzebny jeszcze dziewiąty do opcji COMAND/DATA.
Moje programowe SPI wygląda tak:
[syntax=c]void Send_to_LCD(boolean isCmd, uint8_t Data) {
LCD_PORT &= ~(LCD_CLK | LCD_CS); //wyzerowanie CLK i CS
if (isCmd)LCD_PORT &= ~LCD_SDA; //jeśli CMD wyzerowanie SDA (bit Comand/Data)
LCD_PORT |= LCD_CLK; //ustawienie CLK na 1
for (uint8_t x = 0; x < 8; x++) {
LCD_PORT &= ~(LCD_CLK | LCD_SDA); //wyzerowanie CLK i SDA
if (Data & 128)LCD_PORT |= LCD_SDA; //jeśli DATA = 1: Ustawienie 1 na SDA
LCD_PORT |= LCD_CLK; //ustawienie CLK na 1
Data = Data << 1; // przesuniecie bitow DATA
}
LCD_PORT |= (LCD_CLK | LCD_SDA | LCD_CS); //ustawienie portu na 1
}[/syntax]
Działa bezbłędnie ale chciałbym przyśpieszyć wysyłanie danych.
Czy można skonfigurować SPI sprzętowe aby dało się wysyłać dane w takim formacie jak w załączonym kodzie?
Ewentualnie jak można inaczej zrealizować kod aby wysyłanie było bardziej "sprzętowe" lub szybsze?

Statystyki: Napisane przez radek3035 — 24 lut 2017, o 13:09