[UNO] Mon croquis ne démarre pas ?

**cobra38** · 29/06/2022, 18h06

Bonjour à tous ,

Mon problème du jour est le suivant :

Je teste un petit de jeu fait à partir :
- Arduino UNO
- OLED 128x64 de type SSD1306 I2C ( A5 et A4 )
- Un bouton poussoir (D6)

que l'on va appeler PROGA
1) si je téléverse ce programme celui ne démarre pas, l’écran reste éteint

2) si je téléverse un autre programme totalement différent appelé PROGB avec les mêmes raccordements
ce dernier démarre normalement et l’écran s'affiche correctement

3) si je téléverse à nouveau le PROGA celui-ci se compile et consent à fonctionner normalement

4) si je coupe l'alimentation , je suis obligé de recommencer toute la procédure

j'ai renouvelé l'opération des dizaines de fois, changer les UNO (3) , changer les écrans OLED
j'ai toujours le même problème ..?

Je soupçonne fortement le traitement des entrées I2C mais sans pourvoir en identifier la raison
j'y ai aussi adjoint des résistances de 10k sur SDA et SCL
c'est pourquoi en désespoir de cause je fais appel à vos conseils

A toute fin utile
le PROGA est issu de ce modèle :
https://www.hackster.io/AlexIII/t-re...ex-game-2ed11f
je joins l'ensemble du croquis du PROGA composé de quelques sous-croquis ....
notamment celui-ci qui concerne le traitement de l'écran OLED

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
/*
 * Project name: T-rex-duino
 * Description: T-rex game from Chrome brower rewritten for Arduino
 * Project page: https://github.com/AlexIII/t-rex-duino
 * Author: github.com/AlexIII
 * E-mail: endoftheworld@bk.ru
 * License: MIT
*/ 
 
#ifndef _SH1106_H_
#define _SH1106_H_
 
#define SH1106_I2C_SCL_CLOCK  800000UL
#define SH1106_I2C_ADDR 0b01111000
#define SH1106_COMMAND 0x00
#define SH1106_DATA 0x40
 
#define SH1106_COLS_USED 128
#define SH1106_PAGES 8
 
#ifndef LCD_SSD1306
  #define SH1106_COLS_TOTAL 130
#else 
  #define SH1106_COLS_TOTAL SH1106_COLS_USED
#endif
 
template<class I2C_TYPE>
class SH1106 {
  I2C_TYPE &i2c;
  const uint16_t screenBufferSize;
public:
  enum AddressingMode {
    HorizontalAddressingMode = 0x00,
    VerticalAddressingMode = 0x01,
    PageAddressingMode = 0x02,
  };
  SH1106(I2C_TYPE &i2c, const uint16_t screenBufferSize): 
    i2c(i2c), screenBufferSize(screenBufferSize) {}
  void begin() {
    uint8_t col = 0;
    uint8_t page = 0;
  }
  void fillScreen(const uint8_t* buffer) {
    reinit();
    sendd(buffer, screenBufferSize);
  }
 
  void fillScreen(const uint8_t* buffer, const uint16_t size, const uint8_t stride = 0) { //stride is not supported
    reinit();
    sendd(buffer, size);
  }
 
  void setInverse(const bool v) {
    inverted = v;
    reinit();
  }
  //Only PageAddressingMode works for SH1106
  //Here we're emulating HorizontalAddressingMode programmatically
  void setAddressingMode(const AddressingMode addressingMode) {} 
 
private:
  /* lcd control */
  void reinit() {
    i2c.deinit();
    i2c.init(SH1106_I2C_SCL_CLOCK);
    sendc(0xAF); //display on
    sendc(inverted? 0xA7 : 0xA6); //inversion
  }
 
  /* send bytes */
  void sendc(const uint8_t cmd) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd);
    i2c.stop();
  }
  void sendc(const uint8_t cmd1, const uint8_t cmd2) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd1);
    i2c.write(cmd2);
    i2c.stop();
  }
  void sendc(const uint8_t cmd1, const uint8_t cmd2, const uint8_t cmd3) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd1);
    i2c.write(cmd2);
    i2c.write(cmd3);
    i2c.stop();
  }
  void sendd(const uint8_t* d, uint16_t sz) {  
    const uint8_t blackPx = inverted? 0xFF : 0;
    while(sz) {  //page cycle
      sendc(0xB0 + page); //set page address to i (0..7)
      sendc(0x00 + (col&0x0F)); //Sets 4 lower bits of column address 
      sendc(0x10 + (col>>4)); //Sets 4 higher bits of column address 
 
      i2c.start(SH1106_I2C_ADDR);
      i2c.write(SH1106_DATA);
      while(sz) { //column cycle
        i2c.write(*d++);
        --sz;
        if(++col >= SH1106_COLS_USED) {
          while(col++ < SH1106_COLS_TOTAL) i2c.write(blackPx);
          col = 0;
          break;
        }
      }
      i2c.stop();
 
      if(col == 0 && ++page >= SH1106_PAGES) page = 0;
    }     
  }
 
  uint8_t col = 0;
  uint8_t page = 0;
  bool inverted = false;
};
 
 
#endif

Le PROGA se compile normalement avec quelques erreurs comme :

In file included from ...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\t-rex-duino.ino:105:0:
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h: In instantiation of 'void SH1106<I2C_TYPE>::fillScreen(const uint8_t*, uint16_t, uint8_t) [with I2C_TYPE = I2C; uint8_t = unsigned char; uint16_t = unsigned int]':
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\t-rex-duino.ino:201:93: required from here
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h:48:86: warning: unused parameter 'stride' [-Wunused-parameter]
void fillScreen(const uint8_t* buffer, const uint16_t size, const uint8_t stride = 0) { //stride is not supported
^
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h: In instantiation of 'void SH1106<I2C_TYPE>::setAddressingMode(SH1106<I2C_TYPE>::AddressingMode) [with I2C_TYPE = I2C]':
..\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\t-rex-duino.ino:274:53: required from here
..\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h:59:47: warning: unused parameter 'addressingMode' [-Wunused-parameter]
void setAddressingMode(const AddressingMode addressingMode) {}
^~~~~~~~~~~~~~
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h: In instantiation of 'void SH1106<I2C_TYPE>::begin() [with I2C_TYPE = I2C]':
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\t-rex-duino.ino:287:13: required from here
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h:40:13: warning: unused variable 'col' [-Wunused-variable]
uint8_t col = 0;
^~~
...\T-Rex-duino - Clone Arduino du jeu\t-rex-duino-1.1\t-rex-duino\SH1106.h:41:13: warning: unused variable 'page' [-Wunused-variable]
uint8_t page = 0;
^~~~
Le croquis utilise 12872 octets (39%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 449 octets (21%) de mémoire dynamique, ce qui laisse 1599 octets pour les variables locales. Le maximum est de 2048 octets.

en vous remerciant
pascal

**Jay M** · 29/06/2022, 20h21

vous avez vu les explications sur son GitHub ?

➜ https://github.com/AlexIII/t-rex-duino

Note that in order to achieve desirable performance I2C is substantially overclocked (it works at 800kHz vs 400kHz as per display specification). It is possible that not every display will work under these conditions. The display I have works fine mostly, but a stray broken frame still appears now and then. As much as I can assume small artifacts are unavoidable with this display.

=> il a changé les résistances de pullup I2C de l'écran et il faut en mettre des bien moins fortes - il a pris 470 ohm

order to use SH1106/SSD1306 you will need to add two 470 ohm resistors to the display board. You can add these resistors right on top of 10k resistors that already present (or replace them).

**cobra38** · 29/06/2022, 20h51

Bonsoir Jay M

j'ai effectivement vu sa remarque et j'ai mis sur SDA et SCL 2 résistances de 10k sous 5v en lieu et place 470 ohms sous 3.3v
mais je me suis dis que si le prg démarrait, çà ne pouvait pas provenir de ces dites résistances de pullup
çà me parait logique

pascal

**Jay M** · 29/06/2022, 21h53

il monte l'I2C à 800kHz au lieu des 400kHz standard et donc l'I2C peut bugger (et la bibliothèque Arduino peut bloquer). Je suppose que pour que les transitions du signal I2C soient "propres" il faut un pullup fort, donc des résistance faibles (plus de courant va circuler). donc c'est important

Vous pouvez essayer le même code avec l'I2C à 400KHz ==>changez le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define SH1106_I2C_SCL_CLOCK  800000UL

en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define SH1106_I2C_SCL_CLOCK  400000UL

L'affichage va être deux fois moins réactif donc ça va impacter la qualité de jeu, mais ça devrait vous permettre de voir si c'est le problème

**cobra38** · 30/06/2022, 10h55

Bonjour Jay M

j'ai essayé de mettre à 400KHZ et installer les résistances de 470 ohms
mais sans résultat
une piste toutefois :
dans le programme d'origine il y avait les lignes suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
#define LCD_SH1106  
.../...
// -- Display Connection for SH1106/SSD1306 --
LCD_SH1106_SDA -> A4 (I2C SDA)
LCD_SH1106_SCL -> A5 (I2C SCL)

mais il faisait une erreur à la compilation :

'LCD_SH1106_SDA' does not name a type; did you mean 'LCD_SH1106'?

j'ai donc remplacé peut-être à tort par les lignes suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
// -- Display Connection for SH1106/SSD1306 --
#define LCD_SH1106_SDA -> A4 (I2C SDA)
#define LCD_SH1106_SCL -> A5 (I2C SCL)

c'est peut-être la raison pour laquelle il ne trouve pas les connexions ad'hoc

pascal

**Jay M** · 30/06/2022, 15h01

Envoyé par cobra38

j'ai donc remplacé peut-être à tort par les lignes suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
// -- Display Connection for SH1106/SSD1306 --
#define LCD_SH1106_SDA -> A4 (I2C SDA)
#define LCD_SH1106_SCL -> A5 (I2C SCL)

c'est pas bon en effet, dans l'absolu il ne faut pas mettre les ->, la substitution génèrerait du code qui ne veut rien dire en C++ mais comme ce n'est pas utilisé ce n'est pas grave

dans son code d'origine ce n'était que des commentaires

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
//LCD_SH1106_SDA -> A4 (I2C SDA)
32	//LCD_SH1106_SCL -> A5 (I2C SCL)

pour expliquer qu'il faut effectuer la connexion vers les pins A4 et A5 sur votre UNO. il suffit de conserver cela en commentaire

**cobra38** · 30/06/2022, 18h17

J'ai permuté sur un NANO V3.0
et le phénomène reste identique ..(?)

le problème semble provenir de
IC2.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
*
 * Project name: T-rex-duino
 * Description: T-rex game from Chrome brower rewritten for Arduino
 * Project page: https://github.com/AlexIII/t-rex-duino
 * Author: github.com/AlexIII
 * E-mail: endoftheworld@bk.ru
 * License: MIT
*/ 
 
#ifndef _I2C_CALSS_H_
#define _I2C_CALSS_H_
 
#include <compat/twi.h>
 
struct I2C {
  I2C() {}
 
 
  static void init(const uint32_t clock) {
    TWSR = 0;                         // no prescaler
    TWBR = ((F_CPU/clock)-16)/2;  // must be > 10 for stable operation
  }
 
  static void deinit(void) {
    TWBR = 0;
    TWCR = 0;
  }
 
  static uint8_t start(uint8_t address) {
    uint8_t   twst, i;
    // send START condition
    TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
 
    // wait until transmission completed
    //while(!(TWCR & (1<<TWINT)));
    for(i = 255; i; --i) {
      if(TWCR & (1<<TWINT)) break;
      asm volatile("nop");
      asm volatile("nop");
    }
    if(!i) return 0xFF;
 
    // check value of TWI Status Register. Mask prescaler bits.
    twst = TW_STATUS & 0xF8;
    if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;
 
    // send device address
    TWDR = address;
    TWCR = (1<<TWINT) | (1<<TWEN);
 
    // wail until transmission completed and ACK/NACK has been received
    //while(!(TWCR & (1<<TWINT)));
    for(i = 255; i; --i) {
      if(TWCR & (1<<TWINT)) break;
      asm volatile("nop");
      asm volatile("nop");
    }
    if(!i) return 0xFF;
 
    // check value of TWI Status Register. Mask prescaler bits.
    twst = TW_STATUS & 0xF8;
    if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;
 
    return 0;
  }
 
  static void stop(void) {
    //send stop condition
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
 
    // wait until stop condition is executed and bus released
    //while(TWCR & (1<<TWSTO));
    for(uint8_t i = 255; i; --i) {
      if(!(TWCR & (1<<TWSTO))) break;
      asm volatile("nop");
      asm volatile("nop");
    }
  }
 
  static uint8_t write(uint8_t data) {  
    uint8_t   twst;
 
    // send data to the previously addressed device
    TWDR = data;
    TWCR = (1<<TWINT) | (1<<TWEN);
 
    // wait until transmission completed
    //while(!(TWCR & (1<<TWINT)));
    uint8_t i;
    for(i = 255; i; --i) {
      if(TWCR & (1<<TWINT)) break;
      asm volatile("nop");
      asm volatile("nop");
    }
    if(!i) return 0xFF;
 
    // check value of TWI Status Register. Mask prescaler bits
    twst = TW_STATUS & 0xF8;
    if( twst != TW_MT_DATA_ACK) return twst;
    return 0;
  }
 
  static uint8_t readAck(void) {
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
    //while(!(TWCR & (1<<TWINT)));
    for(uint8_t i = 255; i; --i) {
      if(TWCR & (1<<TWINT)) break;
      asm volatile("nop");
      asm volatile("nop");
    }
    return TWDR;
  }
 
  static uint8_t readNak(void) {
    TWCR = (1<<TWINT) | (1<<TWEN);
    //while(!(TWCR & (1<<TWINT)));
    for(uint8_t i = 255; i; --i) {
      if(TWCR & (1<<TWINT)) break;
      asm volatile("nop");
      asm volatile("nop");
    }
    return TWDR;
  }
};
 
 
#endif

ou de
SH1106.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
#ifndef _SH1106_H_
#define _SH1106_H_
 
#define SH1106_I2C_SCL_CLOCK  800000UL
#define SH1106_I2C_ADDR 0b01111000
#define SH1106_COMMAND 0x00
#define SH1106_DATA 0x40
 
#define SH1106_COLS_USED 128
#define SH1106_PAGES 8
 
#ifndef LCD_SSD1306
  #define SH1106_COLS_TOTAL 130
#else 
  #define SH1106_COLS_TOTAL SH1106_COLS_USED
#endif
 
template<class I2C_TYPE>
class SH1106 {
  I2C_TYPE &i2c;
  const uint16_t screenBufferSize;
public:
  enum AddressingMode {
    HorizontalAddressingMode = 0x00,
    VerticalAddressingMode = 0x01,
    PageAddressingMode = 0x02,
  };
  SH1106(I2C_TYPE &i2c, const uint16_t screenBufferSize): 
    i2c(i2c), screenBufferSize(screenBufferSize) {}
  void begin() {
    uint8_t col = 0;
    uint8_t page = 0;
  }
  void fillScreen(const uint8_t* buffer) {
    reinit();
    sendd(buffer, screenBufferSize);
  }
 
  void fillScreen(const uint8_t* buffer, const uint16_t size, const uint8_t stride = 0) { //stride is not supported
    reinit();
    sendd(buffer, size);
  }
 
  void setInverse(const bool v) {
    inverted = v;
    reinit();
  }
  //Only PageAddressingMode works for SH1106
  //Here we're emulating HorizontalAddressingMode programmatically
  void setAddressingMode(const AddressingMode addressingMode) {} 
 
private:
  /* lcd control */
  void reinit() {
    i2c.deinit();
    i2c.init(SH1106_I2C_SCL_CLOCK);
    sendc(0xAF); //display on
    sendc(inverted? 0xA7 : 0xA6); //inversion
  }
 
  /* send bytes */
  void sendc(const uint8_t cmd) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd);
    i2c.stop();
  }
  void sendc(const uint8_t cmd1, const uint8_t cmd2) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd1);
    i2c.write(cmd2);
    i2c.stop();
  }
  void sendc(const uint8_t cmd1, const uint8_t cmd2, const uint8_t cmd3) {
    i2c.start(SH1106_I2C_ADDR);
    i2c.write(SH1106_COMMAND);
    i2c.write(cmd1);
    i2c.write(cmd2);
    i2c.write(cmd3);
    i2c.stop();
  }
  void sendd(const uint8_t* d, uint16_t sz) {  
    const uint8_t blackPx = inverted? 0xFF : 0;
    while(sz) {  //page cycle
      sendc(0xB0 + page); //set page address to i (0..7)
      sendc(0x00 + (col&0x0F)); //Sets 4 lower bits of column address 
      sendc(0x10 + (col>>4)); //Sets 4 higher bits of column address 
 
      i2c.start(SH1106_I2C_ADDR);
      i2c.write(SH1106_DATA);
      while(sz) { //column cycle
        i2c.write(*d++);
        --sz;
        if(++col >= SH1106_COLS_USED) {
          while(col++ < SH1106_COLS_TOTAL) i2c.write(blackPx);
          col = 0;
          break;
        }
      }
      i2c.stop();
 
      if(col == 0 && ++page >= SH1106_PAGES) page = 0;
    }     
  }
 
  uint8_t col = 0;
  uint8_t page = 0;
  bool inverted = false;
};
 
 
#endif

mais çà dépasse mes compétences

pascal

**Jay M** · 01/07/2022, 18h45

Avez vous essayé avec l’horloge à 400KHz?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 define SH1106_I2C_SCL_CLOCK  400000UL

**cobra38** · 01/07/2022, 19h08

Oui j'ai essayé cela aussi
rien ne change,
1) j'ai essayé aussi sur un Nano ...même résultat
2) j'ai essayé aussi les résistances de 470 ohms ( ce qui une résistance équivalente de 427 ohms ) sur les sorties I2C ...même résultat
3) j'ai aussi regardé les adresses via la datasheet OLED SH1106, elles ont l'air correcte

il faut précisé, par contre, que contrairement au titre du post le programme semble tourner, seul l'affichage ne fonctionne pas car il y a dans
le prg une fonction "DEBUG" qui m'a permis de vérifier le bon fonctionnement du CPU
je vais devoir lâcher l'affaire car je ne trouve pas de solution , c'est dommage car le prg est vraiment rapide

pascal

**Jay M** · 04/07/2022, 10h25

le programme pousse l'I2C dans ses derniers retranchements... souvent les composants ne sont pas qualifiés pour cette vitesse

**cobra38** · 04/07/2022, 12h16

Ce que je n'arrive pas à comprendre
c'est que ce prg fonctionne parfaitement à la vitesse requise 800Kz
si j'ai préalablement téléversé un autre prg (utilisant par ex : ssd1306_128x64_i2C )
ce qui sous-entend qu'il garde en Ram des données permettant l'affichage
car le prg tourne de façon normale en m'indiquant
le taux d'utilisation du CPU via le DEBUG et ceci tant que je ne coupe pas l'alimentation
sinon il démarre mais il ne s'affiche plus....

l'idéal serait de pouvoir utiliser les 2 librairies <I2C.h> et <SH1106>
de façon indépendante à l'aide d'un prg test mais je n'ai pas trouvé d'autres exemples

par ailleurs, en regardant les 2 croquis, je n'ai pas vu où était affichée l'adresse de l'écran OLED ici 0x3C
par contre il y a bien l'adresse I2C en 0x78

pascal

[UNO] Mon croquis ne démarre pas ?

Arduino

Discussions similaires

Partager

Partager