witam
przelutowałem oleda na konfigurację SPI.
na oledzie szum. testowałem na ATB 1.05a 16MHz dzielnik 16 w konfiguracji SPI
oled działa prawidłowo na I2C.
Prawidłowo działa też aplikacja na COG-u po SPI.
nie mogę zaświecić oleda a SPI z Atnela
konfiguracja na SPI od cog-a rożni sie wyłącznie :
1. zmiana rodzaju wyświetlacza na oled 1306
2. wyłączeniu podświetlania

miał ktoś taki problem?
kompiluje prawidłowo. szum na ekranie




mk_spi.h

#ifndef MK_SPI_MK_SPI_H_
#define MK_SPI_MK_SPI_H_

//********************************************** SPI CONFIG ******************
#define USE_SOFT_SPI 0 // 1-tryb Software SPI, 0-tryb Hardware SPI

#define SEND_ONLY 0 // 1-jeśli mają być tylko wysyłane dane, linia MISO nie używana (tylko dla trybu MASTER)

/* PINY dla SPI, w przypadku SOFT SPI mogą być dowolne na dowolnym porcie! */
#define aSS PB4 // SS (CS Chip Select)
#define aMOSI PB5 // MOSI pin
#define aMISO PB6 // MISO pin
#define aSCK PB7 // SCK pin


#define MOSI_DIR DDRB // jeśli używasz hardware SPI
#define MOSI_PORT PORTB // wystarczy skonfigurować tylko te dwie linie

//------------------------------- część konfiguracji tylko na potrzeby soft spi ---
#define MISO_DIR DDRB
#define MISO_PORT PORTB
#define MISO_PIN PINB

#define SCK_DIR DDRB
#define SCK_PORT PORTB
//-------------------------------- koniec ------------------------

#define SS_DIR DDRB
#define SS_PORT PORTB


/* Sck Speed options
* SCK_FOSC_DIV_4 (default)
* SCK_FOSC_DIV_16
* SCK_FOSC_DIV_64
* SCK_FOSC_DIV_128
*
* SCK_FOSC_DIV_2
* SCK_FOSC_DIV_8
* SCK_FOSC_DIV_32
*/
#define SCK_SPEED SCK_FOSC_DIV_16 // taktowanie SPI

#define SPI_DATA_ORDER MSB_FIRST // MSB_FIRST (default), LSB_FIRST
#define SCK_POLARITY 0 // 0-Low when idle (default), 1-High when idle
#define SCK_PHASE 0 // 0-Data Sampled on First Edge (default), 1-Data Sampled on Second Edge

#define MASTER_SPI_DELAY_US 0

//----------------------------------- SPI CONFIG as SLAVE only in hardware mode -------------------

#define USE_SLAVE_MODE_HW_SPI 0

//********************************************** SPI CONFIG END ***********************************








//-----------------------------------------------------------------------------

typedef uint8_t (*THWSPI_CALLBACK_ISR)( uint8_t byte );


#ifdef SPCR0
#define SPCR SPCR0
#define SPSR SPSR0
#define SPIF SPIF0
#define SPDR SPDR0
#define SPE SPE0
#define MSTR MSTR0
#define CPOL CPOL0
#define DORD DORD0
#define CPHA CPHA0
#endif




#define SPRxMASK 0x03
#define SPI2XMASK 0x01

#define MSB_FIRST 0x00
#define LSB_FIRST 0x01

#define SCK_FOSC_DIV_4 0x00
#define SCK_FOSC_DIV_16 0x01
#define SCK_FOSC_DIV_64 0x02
#define SCK_FOSC_DIV_128 0x03

#define SCK_FOSC_DIV_2 0x10
#define SCK_FOSC_DIV_8 0x11
#define SCK_FOSC_DIV_32 0x12

#define SPI_DIR MOSI_DIR
#define SPI_PORT MOSI_PORT
#define SPI_PIN MISO_PIN

#define SS (1<<aSS) // SS (CS Chip Select)
#define MOSI (1<<aMOSI) // MOSI pin
#define MISO (1<<aMISO) // MISO pin
#define SCK (1<<aSCK) // SCK pin


#define SS_LO SS_PORT &= ~SS
#define SS_HI SS_PORT |= SS

#define SCK_LO SCK_PORT &= ~SCK
#define SCK_HI SCK_PORT |= SCK

#define MOSI_LO MOSI_PORT &= ~MOSI
#define MOSI_HI MOSI_PORT |= MOSI

#define MISO_LO MISO_PORT &= ~MISO
#define MISO_HI MISO_PORT |= MISO






//-----------------------------------------------------------------------------

/* inicjalizacja SPI */
void spi_init( void );

#if USE_SLAVE_MODE_HW_SPI == 1 && USE_SOFT_SPI == 0
void register_spi_hw_callback_isr( THWSPI_CALLBACK_ISR callback );
#endif


#if SEND_ONLY == 0
/* nadawanie i odbiór jednego bajtu */
uint8_t spi_xmit_byte( uint8_t byte );
#else
/* nadawanie jednego bajtu */
void spi_xmit_byte( uint8_t byte );
#endif

/* nadawanie słowa 16-bitowego */
void spi_send_word( uint16_t word );

/* nadawanie danych z bufora */
void spi_send_buf( void * buf_out, uint8_t size );

/* nadawanie i odbieranie danych do i z - bufora. Bufor może być ten sam, nastąpi wymiana danych */
void spi_xmit_buf( void * buf_in, void * buf_out, uint8_t size );

/* wysłanie stringa */
void spi_master_puts( char * str );

/* odebranie stringa (zakończonego CR, albo LF albo NULL */
char * spi_master_gets( char * buf );

#if USE_SOFT_SPI == 1
uint16_t spi_xmit_n_bits( uint8_t bits_cnt, uint16_t bits_word );
#endif

#endif /* MK_SPI_MK_SPI_H_ */




mk_glcd_config.h

#ifndef MK_GLCD_CONFIG_H_
#define MK_GLCD_CONFIG_H_

//^^^^^^^^^^^^^^^^^^^^^^^ KONFIGURACJA BIBLIOTEKI ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

//..... wybór chipsetu - rodzaju wyświetlacza - odkomentuj właściwą linię ............................
#define USE_SSD1306 // OLED
//#define USE_SSD1309 // OLED
//#define USE_COG_ST7565R // COG
//#define USE_NOKIA_PCD8544 // NOKIA
//#define USE_UC1701 // LCX
//#define USE_ST7920 // DIGOLE


//..... wybór rozdzielczości - wyświetlacza - odkomentuj właściwą linię ...............................
#define GLCD_RES_128_64 // OLED / COG / LCX / DIGOLE
//#define GLCD_RES_128_32 // OLED
//#define GLCD_RES_84_48 // NOKIA

//..... ręczne ustawienie rozdzielczości - jeśli wiesz co robisz ......................................
//..............w przeciwnym wypadku użyj ustawień predefiniowanych powyżej GLCD_RES_xx_xx ............
//..... aby wymusić ręczne ustawienie rozdzielczości - zakomentuj wszystkie predefiniwane .............
#define GLCD_WIDTH 128
#define GLCD_HEIGHT 64



//........ ustawienia pinów sterujących ...............................................................

#define USE_RST_PIN 1 // jeśli pin RST sterowany z uC = 1

#define USE_BACKLIGHT 0 // jeśli podświetlenie sterowane z uC = 1
#define BACKLIGHT_ACTIVE_HIGH 0 // 0-jeśli podświetlenie załączane stanem niskim, 1-jeśli załączane stanem wysokim

#define DC (1<<2) // <---- A0/DC/RS
#define DC_PORT PORTD
#define DC_DDR DDRD

#if USE_BACKLIGHT == 1
#define BACKLIGHT_PORT PORTD
#define BACKLIGHT_DDR DDRD
#define BACKLIGHT (1<<7) // <---- podświetlenie (BackLight)
#endif


#if USE_RST_PIN == 1
#define RST (1<<7) // <---- RST
#define RST_PORT PORTC
#define RST_DDR DDRC
#endif




//..... wybór magistrali I2C lub SPI dla OLED ................................................
#define USE_I2C 0 // 0-use SPI, 1-use I2C


//................ Ustawienia I2C ............................................................
#define GLCD_I2C_BITRATE 400 // kHz

//..... wybór adresu wyświetlacza na magistrali I2C ..........................................
#define GLCD_I2C_ADDRESS 0x78 // 0x78, 0x7A (dla chipsetu SSD1306)





//..... wyświetlanie do celów testowych przy uruchomieniu ekranu DEMO po inicjalizaji ........
#define SHOW_DEMO_SCREEN 1



#define FX_MAX_IDX 9




//^^^^^^^^^^^^^^^^^^^^^^^ KONFIGURACJA - KONIEC ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^




#if USE_BACKLIGHT == 1
#if BACKLIGHT_ACTIVE_HIGH == 1
#define BACKLIGHT_OFF BACKLIGHT_PORT &= ~BACKLIGHT
#define BACKLIGHT_ON BACKLIGHT_PORT |= BACKLIGHT
#else
#define BACKLIGHT_ON BACKLIGHT_PORT &= ~BACKLIGHT
#define BACKLIGHT_OFF BACKLIGHT_PORT |= BACKLIGHT
#endif

#define BACKLIGHT_TOG BACKLIGHT_PORT ^= BACKLIGHT
#endif

#if USE_RST_PIN == 1
#define RST_LO RST_PORT &= ~RST
#define RST_HI RST_PORT |= RST
#endif

#define DC_LO DC_PORT &= ~DC
#define DC_HI DC_PORT |= DC

#define CS_LO SS_LO
#define CS_HI SS_HI


#ifdef GLCD_RES_128_64
#undef GLCD_WIDTH
#undef GLCD_HEIGHT
#define GLCD_WIDTH 128
#define GLCD_HEIGHT 64
#endif

#ifdef GLCD_RES_128_32
#undef GLCD_WIDTH
#undef GLCD_HEIGHT
#define GLCD_WIDTH 128
#define GLCD_HEIGHT 32
#endif

#ifdef GLCD_RES_84_48
#undef GLCD_WIDTH
#undef GLCD_HEIGHT
#define GLCD_WIDTH 84
#define GLCD_HEIGHT 48
#endif



#define GLCD_BUF_SIZE ( GLCD_WIDTH * GLCD_HEIGHT / 8 )

#endif /* MK_GLCD_CONFIG_H_ */


main.c


#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <stdlib.h>
#include <stdio.h>


/*
* UWAGA! w tym przykładzie użyto dużych fontów R2L !!!!!!!!!!!!!!!!!!!!!!!!!!!
*
* w związku z tym zmienione zostało ustawienie kompilacji:
*
* #define USE_TWO_FONTS_BITORIENT 1
*
* na JEDEN - w pliku mk_glcd_text.h
*
* zabiera to nieco więcej pamięci FLASH ale umożliwia obsługę fontów w dwóch orientacjach
* bitów, zarówno domyślne T2B jak też R2L
*
* Fonty R2L pozwala generować Pixel Factory w swojej podstawowej funkcjonalności na podstawie
* dowolnych fontów zawartych w MS Windows. Trzeba do tego używać najnowszej wersji
* Pixel Factory (minimum) 2.0.0.7 lub wyższej
*
*/


#include "MK_GLCD/mk_glcd_base.h"
#include "bitmapy.h"


void mkDelay( uint16_t ms ) {
while( --ms ) _delay_ms(1);
}






int main( void ) {


glcd_init();

glcd_backlight( 0 ); // dla OLED nie istotne - i tak nie działa - może nie być w ogóle tej funkcji dla OLEDów
glcd_flip_vertical( 0,0 ); // sprawdź jak działa z różnymi parametrami
glcd_inverse( 0 ); // sprawdź z argumentem = 1

/* <------ od wersji 1.1 domyślny font ładowany jest przy inicjalizacji, więc nie trzeba pamiętać o ręcznym ładowaniu -----> */
// setCurrentFont( &DefaultFont5x8 );



#ifdef GLCD_RES_84_48
glcd_fast_drawBitmap( logoAtnelNokia );
#endif
#ifdef GLCD_RES_128_64
glcd_fast_drawBitmap( logoAtnel );
#endif
#ifdef GLCD_RES_128_32
glcd_fast_drawBitmap( oled128x32logo );
#endif
glcd_display();
mkDelay(2500);
glcd_cls();

setCurrentFont( &DefaultFont5x8 );
text_align = _center;
uint8_t alw = (GLCD_HEIGHT/2) - (currentFont.heightPixels/2);

#ifdef GLCD_RES_128_32
alw = 20;
setCurrentFont( &FixedSys5x12 );
#endif

glcd_puts_P( GLCD_WIDTH-1, alw, PSTR("MK-GLCD Icons"), 1 );



#ifndef GLCD_RES_84_48
uint8_t a=1;
glcd_drawBitmap( 0, 0, network, 1 );
glcd_drawBitmap( 16+1+a++, 0, tools, 1 );
glcd_drawBitmap( 32+2+a++, 0, notepad, 1 );
glcd_drawBitmap( 48+3+a++, 0, speaker, 1 );
glcd_drawBitmap( 64+4+a++, 0, key, 1 );
glcd_drawBitmap( 80+5+a++, 0, save, 1 );
glcd_drawBitmap( 96+6+a++, 0, pwr, 1 );
#else
glcd_drawBitmap( 0, 0, network, 1 );
glcd_drawBitmap( 16+1, 0, tools, 1 );
glcd_drawBitmap( 32+2, 0, notepad, 1 );
glcd_drawBitmap( 48+3, 0, speaker, 1 );
glcd_drawBitmap( 64+4, 0, key, 1 );
glcd_drawBitmap( 80+5, 0, save, 1 );
glcd_drawBitmap( 96+6, 0, pwr, 1 );
#endif



#ifdef GLCD_RES_128_64
a=1;
glcd_drawBitmap( 0, GLCD_HEIGHT-16, wifi, 1 );
glcd_drawBitmap( 16+1+a++, GLCD_HEIGHT-16, save, 1 );
glcd_drawBitmap( 32+2+a++, GLCD_HEIGHT-16, pwr, 1 );
glcd_drawBitmap( 48+3+a++, GLCD_HEIGHT-16, gear, 1 );
glcd_drawBitmap( 64+4+a++, GLCD_HEIGHT-16, signal, 1 );
glcd_drawBitmap( 80+5+a++, GLCD_HEIGHT-16, tools, 1 );
glcd_drawBitmap( 96+6+a++, GLCD_HEIGHT-16, notepad, 1 );
#endif

#ifdef GLCD_RES_84_48
glcd_drawBitmap( 0, GLCD_HEIGHT-16, wifi, 1 );
glcd_drawBitmap( 16+1, GLCD_HEIGHT-16, save, 1 );
glcd_drawBitmap( 32+2, GLCD_HEIGHT-16, pwr, 1 );
glcd_drawBitmap( 48+3, GLCD_HEIGHT-16, gear, 1 );
glcd_drawBitmap( 64+4, GLCD_HEIGHT-16, signal, 1 );
glcd_drawBitmap( 80+5, GLCD_HEIGHT-16, tools, 1 );
glcd_drawBitmap( 96+6, GLCD_HEIGHT-16, notepad, 1 );
#endif

glcd_display();

mkDelay(5000);
glcd_cls();


setCurrentFont( &DefaultFont5x8 );
text_align = _right;
glcd_puts_P( GLCD_WIDTH-1, 0, PSTR("zdaanie na cały ekran"), 2 );

setCurrentFont( &FixedSys5x12 );

glcd_puts_P( GLCD_WIDTH-1, 10, PSTR("czerwan"), 2 );

#ifndef GLCD_RES_128_32
text_align = _center;
#ifdef GLCD_RES_84_48
setCurrentFont( &RockwellCondensed14x18 );
#else
setCurrentFont( &mkFontL2R );
#endif
glcd_puts_P( GLCD_WIDTH-1, 26, PSTR("06:35"), 2 );

szachownica = 6;
glcd_drawRect( 2,23, GLCD_WIDTH-2, currentFont.heightPixels+6, 1 );
szachownica = 2;
glcd_drawRect( 3,24, GLCD_WIDTH-4, currentFont.heightPixels+4, 1 );

glcd_drawBitmap( 1, 1, speaker, 1 );

glcd_display();
mkDelay(1000);

#else
setCurrentFont( &FixedSys5x12 );
text_align = _left;
glcd_puts_P( 22, 16, PSTR("[06:35]"), 2 );
#endif



setCurrentFont( &FixedSys5x12 );
text_align = _right;
glcd_puts_P( GLCD_WIDTH-1, 10, PSTR("czerwan"), 2 );


while(1) {
glcd_puts_P( GLCD_WIDTH-1, 10, PSTR("BUDZIK!"), 2 );
glcd_drawBitmap( 1, 1, speaker, 2 );
glcd_display();
mkDelay(1000);
glcd_puts_P( GLCD_WIDTH-1, 10, PSTR("BUDZIK!"), 2 );
glcd_drawBitmap( 1, 1, speaker, 2 );
glcd_display();
mkDelay(500);
}


}

Sorki ale kolega nie wie co pisze niestety. PODSTAWOWA zaleta gdy jest SPI - to dużo większa szybkość obsługi wyświetlacza a co za tym idzie lepsze i szybsze animacje szczególnie na wyświetlaczach typu OLED.

Wada SPI - więcej przewodów ...

---------------

Zaleta I2C - tylko dwa przewody SDA i SCL plus dwa na zasilanie, jeśli chodzi o animacje nieco wolniej ale bez przesady nie jest aż tak źle i kto tam zaraz powymyśla tak szybkie animacje. Poza tym dla np wyświetlaczy COG nawet nie ma co myśleć o szybkich animacjach ze względu na bardzo kocie czasy odświeżania.

_________________
zapraszam na blog: http://www.mirekk36.blogspot.com (mój nick Skype: mirekk36 ) [ obejrzyj Kurs EAGLE ] [ mój kanał YT TV www.youtube.com/mirekk36 ]

Trochę tu kolega miesza pojęcia ale już wyjaśniam - bo co mają wspólnego dłuższe połączenia SPI z działaniem I2C na przerwaniach ?


To już jest (bez urazy) herezja

a teraz wyjaśnienie:

Zarówno SPI jak i I2C to są magistrale przeznaczone TYLKO I WYŁĄCZNIE do pracy wewnątrz urządzenia, czyli w ramach najlepiej jednej płyty PCB ew kilku PCB ale połączonych krótkimi przewodami czy w slotach - i nadal TYLKO wewnątrz urządzenia. I nie ma że boli - żadna z tych magistral nie służy do komunikacji pomiędzy dwoma różnymi urządzeniami na odległości np 1m - to już dużo za dużo.

Poza tym jak można pisać, że SPI nie działa na przerwaniach Owszem można w ogóle bez przerwań i to może być często też szybsze niż I2C na przerwaniach ale pal pies. SPI na przerwaniach przy clocku F_CPU/2 czyli maksymalnym dla AVR, możesz przy taktowaniu procka np 20MHz mieć dla SPI clock = 10 MHz no i teraz powiedz mi ile maksymalnie możesz mieć dla I2C.

Ale teraz uwaga - bo ty pisząc o SPI na przerwaniach myślisz o jakimś dziwnym zaawansowanym protokole ? Po co ? bez żadnych przerwań ! tylko SPI w oparciu o moduł sprzętowy SPI a nie metodę programową - i to puszczasz na clocku 10MHz ! Nie wiem wprawdzie czy SSD1306 zdzierży - ale 1 MHz napewno a i więcej.


Tutaj to już kolega niestety popłynął albo w jakiś przedziwny sposób pisze oprogramowanie z udziałem SPI i dlatego może ja nie rozumiem kompletnie tych słów
Owszem niektóre wyświetlacze OLED właściwie kontrolery jak SSD1306 mogą śmigać z I2C na prędkości ok 600 kHz !!! ale zwykle nie więcej.

A zatem jak ma się 600 kHz clock I2C do 10 MHz clock dla SPI ?



Obejrzyj sobie moje filmiki z OLEDowymi wyświetlaczami i animacjami - to zrozumiesz w czym rzecz

_________________
zapraszam na blog: http://www.mirekk36.blogspot.com (mój nick Skype: mirekk36 ) [ obejrzyj Kurs EAGLE ] [ mój kanał YT TV www.youtube.com/mirekk36 ]

Też miałem podobny problem, ale próbując zaadaptować bibliotekę MK_GLCD do kolorowego wyświetlacza SSD1331. Nie wiem, czy w Twoim przypadku to też będzie rozwiązanie, ale być do niego doprowadzi.

W plikach HARDWARE/mk_TYP_WYSWIETLACZA.c
Na poziomie funkcji mk_XXXXX_cmd( uint8_t cmd)
jest mniej więcej taka konstrukcja



Żeby ten wyświetlacz mi zadziałał zakomentowałem wywołanie CS_HI;
sygnał CHIP_SELECT podnoszę dopiero po wysłaniu całego bloku - czyli niestety trzeba to umieścić w każdej funkcji gdzieś na końcu która wykorzystuje wyżej wymienione mk_XXXXX_cmd
Jeśłi jest to jedyne urządzenie SPI podłączone do procka, to działo mi to nawet jak CS był zawsze na LO

Mimo tego, że w teorii zgodnie z notami wszystko powinno działać kiedy linia CS zmienia się po każdym wysłaniu bajta, to po prostu to nie działało.

A jak do tego doszedłem? Do każdego wyświetlacza dołączone jest oprogramowanie referencyjne dla różnych procków - zwykle również dla Arduino. Po prostu ściągnąłem sobie tą referencyjną bibliotekę i na jakiejś płytce arduino odpaliłem przykładowy program. Podłączyłem analizator stanów logicznych i patrzyłem, czym różnią się sygnały w moim programie oraz w programie referencyjnym.
W końcu doszedłem do tego, że akurat w przypadku mojego wyświetlacza jedyna różnica to były latające w górę i w dół sygnały CHIP_SELECT i zmiana tego zachowania okazało się rozwiązaniem.



PS. A u mnie działa na AVR z kolorowym OLEDem ;-)

Pytanie co to znaczy "w czasie transmisji" i co to znaczy "inne zadania".
Generalnie akurat moje podejście polegało na wysyłaniu całej potrzebnej komunikacji SPI w "jednym bloku" w pętli głównej. Jeśli coś działało "w tle" to były to przerwania timerów. A kiedy ta komunikacja się kończyła, to procek przechodził do innych zadań.
Co do "szybkości" to przy moim podejściu zależy trochę od tego co dokładnie na wyświetlaczu jest robione, ale przy zastosowaniach typu MK Menu, czy programach przykładowych biblioteki MK GLCD uzyskiwałem niewiele gorsze wyniki niż przy podobnej wielkości wyświetlaczach monochromatycznych z użyciem standardowej biblioteki MK GLCD .
Niektóre przykłady nie poszły na Atmega32 (okazało się, że trochę za mało pamięci i czasem heap się nadpisywał), ale już m644 dał radę jak widać na załączonym obrazku.
Program nie jest na Arduino - tylko native C dla AVR :-)

Oczywiście jak się wysyła dane bez żadnej optymalizacji, to jest naprawdę "słabo"... ale jak się trochę pomyśli i zrobi parę "sztuczek" rodem ze sceny ośmiobitowców lat 80-tych, to zaczyna to nawet fajnie działać :-)

Przerwanie jest oczywiście bez sensu, ale w pollingu, być możę (bardzo ciasno!) dało by się wyciągnąć te 10MHz. Z tym, że być może, konieczna by była wstawka asemblerowa, by zapewnić odpowiednią sekwencję instrukcji.

_________________
Think for yourself and question authority.

Dziwnie się z tobą dyskutuje - tu mówimy o standardowym I2C i SPI a ty mi tu o expanderach i wydłużaniu magistrali ... a ja o prędkości przesyłania danych do sterownika wyświetlacza ... a ty dodatkowo jakieś bzdury o menu i andruino ....

Zrozum, taki SSD1306 po SPI potrafi łykać dane z clockiem (nie pamietam teraz dokładnie ale ok 1-2MHz) a po I2C tylko ok 600KHz

rozumiesz to czy nie ... ?

I nie pisz mi tu bajek o tym, że przy 10MHz clocka dla SPI będzie jakaś wolna transmisja bo czas pomiędzy bajtami będzie mniejszy niż między bitami ... no sorki ale ręce opadają.

Krótko mówiąc SPI daje większe możliwości gdy chcesz robić zaawansowane animacje do czegoś na LCD. Jak nie chcesz - to obojętnie co użyjesz czy SPI czy I2C. Bez animacji ja zawsze wybrałbym I2C bo mniej linii i to tyle

_________________
zapraszam na blog: http://www.mirekk36.blogspot.com (mój nick Skype: mirekk36 ) [ obejrzyj Kurs EAGLE ] [ mój kanał YT TV www.youtube.com/mirekk36 ]

Proszę cię czytaj uważniej co piszę, bo zafixowałeś się na czymś i nie odpuszczasz bez sensu

Nigdzie nie pisałem, żeby akurat do wyświetlacza pchać 10MHz !

ostatni raz

Jeśli mam możliwość przesyłania danych po SPI z prędkością (chodzi TYLKO o clock a nie o durne odstępy między bajtami co do których się uparłeś jak ...) 1-2 MHz to mam dużo szybsze odświeżanie ekranów niż po I2C z clockiem 600 kHz mówi ci to coś ?

_________________
zapraszam na blog: http://www.mirekk36.blogspot.com (mój nick Skype: mirekk36 ) [ obejrzyj Kurs EAGLE ] [ mój kanał YT TV www.youtube.com/mirekk36 ]

Pod ręką miałem AVRa i akurat ten konkretny wyświetlacz... i chwilę czasu, żeby się pobawić. Być może inny procek kosztuje grosze, ale po pierwsze akurat takiego innego nie miałem pod ręką, po drugie jakbym go zamówił, to pewnie bym czekał kolejne parę dni na dostawę i jeszcze spędził pewnie więcej czasu nad poinstalowaniem całego środowiska.
W sumie to nie są jakieś nie wiadomo jakie sztuczki, razem z wymyśleniem i zaprogramowaniem zajęło mi to może parę godzin.
Więcej czasu spędziłem nad rozkminieniem dlaczego mam sieczkę na ekranie - a o tym jest ten wątek i swoje rozwiązanie oraz dojście do tego problemu tutaj pokazałem.
O wyższości świąt nie bardzo mam ochoty dyskutować...


Pewnie można kupić gotowe urządzenie "od Chińczyka"... ale można też trochę pobawić się samemu i czegoś nauczyć, poćwiczyć szare komórki... dla mnie to jest hobby, w czasie wolnym robię to co lubię i nie mam specjalnie ochoty tłumaczyć się, dlaczego nie zrobiłem tego inaczej.


A to byś się zdziwił... moda na "retro" wraca i się okazuje, że jest to całkiem niezły biznes. To raczej nie jest to forum, żeby o taki rzeczach pisać, ale ostatnio sobie poskładałem ZXUno i MiSTer'a (repliki sprzętu na FPGA) i zabawa jest naprawdę przednia :-)

Retro żyje i ma się bardzo dobrze. Poza sprzętem wychodzą i gry i demka

oled Atnela lata po SPI jak usuniemy dodatkowo zworkę z adresem I2C