AVR用のコンパクト＆高速なI2Cライブラリの実験

メモリの少ないAVR向けにGPIOのみを利用したコンパクトなソフトウェアI2Cライブラリを作ってみた。コンパクト化のためシングル・マスター構成に限定し通信高速化のための立ち上がり信号高速化機能を実装。立ち上がり信号高速化機能とはオープンコレクタ(ドレイン)回路を高速化するために制御線をオープン(HIGH)にする一瞬だけアクティブ駆動させ強制的にHIGHにする機能。タイミングを間違うとスレーブデバイス側の出力回路とショート状態になるので注意が必要であるがプッシュプル回路と同程度まで高速化でき、制御線の外部プルアップ抵抗が不要となるメリットもある。

【続編】
AVR用のコンパクト＆高速なI2Cライブラリの改良版

【実際の通信波形(外部プルアップ抵抗無し)】

ATtiny85(16MHz)での実測値では最高速でも800KHz程度止まりであるが、立ち上がり信号高速化機能がない場合、立ち上がり信号がかなりなまり、外部プルアップ抵抗1KΩでもせいぜい頑張って1MHz程度であることや、そもそも1MHzを超える高速クロック対応のデバイスもそうなさそうなので、ほんの少しの高速化よりもプルアップ抵抗が省略できるメリットのほうが大きい。

コンパクト＆高速化のためSDA/SCLポートの変更はライブラリを直接書き換える必要がある。ライブラリのコードサイズは340バイト程度。

2017-07-30
read()/write()の戻り値の型をint8_tからuint8_tに型変更し最大データ長を254バイトとした。スレーブが見つからないときは戻り値が255となる。

2017-07-29
I2Cで使用するGPIOをアプリ側で定義できるように変更。その他、全体的に仕様変更を含む最適化をしてみた。また、標準のWire互換クラスを作成＆試してみたがコードサイズが大きくなるだけなのでボツとした。メモリの少ないCPUには重すぎる仕様かも．．．

【サンプル・スケッチ】

#define HSWIRE_SCL_PORT B
#define HSWIRE_SCL_BITN 2
#define HSWIRE_SDA_PORT B
#define HSWIRE_SDA_BITN 0
#include "hswire.h"

HSWire<HSWIRE_1M> Wire;

void setup()
{
  pinMode(1, OUTPUT);
  Wire.begin();
}

void loop()
{
  uint8_t data[] = {0x12, 0x55, 0xAA};
  Wire.write(0x20, data, sizeof(data));
  Wire.read(0x20, data, sizeof(data));
  digitalWrite(1, !digitalRead(1));
  delay(1000);
}

#define HSWIRE_SCL_PORT B

#define HSWIRE_SCL_BITN 2

#define HSWIRE_SDA_PORT B

#define HSWIRE_SDA_BITN 0

#include "hswire.h"

HSWire<HSWIRE_1M> Wire;

void setup()

{

pinMode(1, OUTPUT);

Wire.begin();

}

void loop()

{

uint8_t data[] = {0x12, 0x55, 0xAA};

Wire.write(0x20, data, sizeof(data));

Wire.read(0x20, data, sizeof(data));

digitalWrite(1, !digitalRead(1));

delay(1000);

}

【ライブラリ】

/*
 * I2C Library for AVR
 *   
 *   Sasapea's Lab.
 *   2019-07-29
 *
 * code example:
 * 
 *   #define HSWIRE_SCL_PORT B // SCL = PB2
 *   #define HSWIRE_SCL_BITN 2 //
 *   #define HSWIRE_SDA_PORT B // SDA = PB0
 *   #define HSWIRE_SDA_BITN 0 //
 *   #include "hswire.h"
 *
 *   HSWire<HSWIRE_100K> Wire;
 */
#ifndef _HSWIRE_H
#define _HSWIRE_H

#define HSWIRE_100K 0
#define HSWIRE_400K 1
#define HSWIRE_1M   2

#define HSWIRE_CAT(a, b) a##b
#define HSWIRE_REG(r, p) HSWIRE_CAT(r, p)
#define HSWIRE_SCL(r)    HSWIRE_REG(r, HSWIRE_SCL_PORT)
#define HSWIRE_SDA(r)    HSWIRE_REG(r, HSWIRE_SDA_PORT)

#include <stdint.h>
#include <stdbool.h>
#include <util/delay_basic.h>

#define HSWIRE_DELAY(t) \
do { \
  uint8_t n = (uint8_t)((((t) / 1000.0) * (F_CPU / 1000000) * 256) / 768); \
  if (n) _delay_loop_1(n); \
} while (0)

//
// Standard Mode
//
#define HSWIRE_100K_THDSTA HSWIRE_DELAY(4000) // 4000
#define HSWIRE_100K_TLOW   HSWIRE_DELAY(4400) // 4700
#define HSWIRE_100K_THIGH  HSWIRE_DELAY(4000) // 4000
#define HSWIRE_100K_TSUSTA HSWIRE_DELAY(4700) // 4700
#define HSWIRE_100K_THDDAT HSWIRE_DELAY( 200) //  300
#define HSWIRE_100K_TSUSTO HSWIRE_DELAY(4000) // 4000
#define HSWIRE_100K_TSUDAT HSWIRE_DELAY( 200) //  250
#define HSWIRE_100K_TBUF   HSWIRE_DELAY(4700) // 4700
//
// Fast Mode
//
#define HSWIRE_400K_THDSTA                    //  600
#define HSWIRE_400K_TLOW   HSWIRE_DELAY( 800) // 1300
#define HSWIRE_400K_THIGH  HSWIRE_DELAY( 200) //  600
#define HSWIRE_400K_TSUSTA HSWIRE_DELAY( 600) //  600
#define HSWIRE_400K_THDDAT                    //    0
#define HSWIRE_400K_TSUSTO HSWIRE_DELAY( 400) //  600
#define HSWIRE_400K_TSUDAT                    //  100
#define HSWIRE_400K_TBUF   HSWIRE_DELAY(1300) // 1300
//
// Hs Mode
//
#define HSWIRE_1M_THDSTA // 160 
#define HSWIRE_1M_TLOW   // 160
#define HSWIRE_1M_THIGH  //  60
#define HSWIRE_1M_TSUSTA // 160
#define HSWIRE_1M_THDDAT //   0
#define HSWIRE_1M_TSUSTO // 160
#define HSWIRE_1M_TSUDAT //  10
#define HSWIRE_1M_TBUF   //  60

#define HSWIRE_DELAY_THDSTA(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_THDSTA;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_THDSTA; \
  else                         HSWIRE_100K_THDSTA; \
} while (0)

#define HSWIRE_DELAY_TLOW(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_TLOW;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_TLOW; \
  else                         HSWIRE_100K_TLOW; \
} while (0)

#define HSWIRE_DELAY_THIGH(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_THIGH;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_THIGH; \
  else                         HSWIRE_100K_THIGH; \
} while (0)

#define HSWIRE_DELAY_TSUSTA(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_TSUSTA;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUSTA; \
  else                         HSWIRE_100K_TSUSTA; \
} while (0)

#define HSWIRE_DELAY_THDDAT(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_THDDAT;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_THDDAT; \
  else                         HSWIRE_100K_THDDAT; \
} while (0)

#define HSWIRE_DELAY_TSUSTO(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_TSUSTO;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUSTO; \
  else                         HSWIRE_100K_TSUSTO; \
} while (0)

#define HSWIRE_DELAY_TSUDAT(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_TSUDAT;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUDAT; \
  else                         HSWIRE_100K_TSUDAT; \
} while (0)

#define HSWIRE_DELAY_TBUF(m) \
do { \
  if      ((m) == HSWIRE_1M  ) HSWIRE_1M_TBUF;   \
  else if ((m) == HSWIRE_400K) HSWIRE_400K_TBUF; \
  else                         HSWIRE_100K_TBUF; \
} while (0)

#define HSWIRE_SCL_LOW  do {       HSWIRE_SCL(PORT) &= ~_BV(HSWIRE_SCL_BITN); HSWIRE_SCL(DDR) |=  _BV(HSWIRE_SCL_BITN);       } while (0)
#define HSWIRE_SCL_HIGH do {cli(); HSWIRE_SCL(PORT) |=  _BV(HSWIRE_SCL_BITN); HSWIRE_SCL(DDR) &= ~_BV(HSWIRE_SCL_BITN); sei();} while (0)
#define HSWIRE_SDA_LOW  do {       HSWIRE_SDA(PORT) &= ~_BV(HSWIRE_SDA_BITN); HSWIRE_SDA(DDR) |=  _BV(HSWIRE_SDA_BITN);       } while (0)
#define HSWIRE_SDA_HIGH do {cli(); HSWIRE_SDA(PORT) |=  _BV(HSWIRE_SDA_BITN); HSWIRE_SDA(DDR) &= ~_BV(HSWIRE_SDA_BITN); sei();} while (0)
#define HSWIRE_SDA_IN   (HSWIRE_SDA(PIN) & _BV(HSWIRE_SDA_BITN))

template<uint8_t MODE = HSWIRE_100K>
class HSWire
{
  private:

    void start(void)
    {
      HSWIRE_SDA_LOW;
      HSWIRE_DELAY_THDSTA(MODE);
    }

    void stop()
    {
      HSWIRE_SCL_LOW;
      HSWIRE_DELAY_THDDAT(MODE);
      HSWIRE_SDA_LOW;
      HSWIRE_DELAY_TLOW(MODE);
      HSWIRE_SCL_HIGH;
      HSWIRE_DELAY_TSUSTO(MODE);
      HSWIRE_SDA_HIGH;
      HSWIRE_DELAY_TBUF(MODE);
    }

    void transfer(uint8_t b)
    {
      for (uint8_t i = 8; i--; )
      {
        HSWIRE_SCL_LOW;
        HSWIRE_DELAY_THDDAT(MODE);
        if (b & 0x80)
          HSWIRE_SDA_HIGH;
        else
          HSWIRE_SDA_LOW;
        HSWIRE_DELAY_TLOW(MODE);
        HSWIRE_SCL_HIGH;
        HSWIRE_DELAY_THIGH(MODE);
        b <<= 1;
      }
    }

    uint8_t receive(void)
    {
      uint8_t b = 0;
      for (uint8_t i = 8; i--; )
      {
        HSWIRE_SCL_LOW;
        HSWIRE_DELAY_THDDAT(MODE);
        HSWIRE_SDA_HIGH;
        HSWIRE_DELAY_TLOW(MODE);
        HSWIRE_SCL_HIGH;
        HSWIRE_DELAY_THIGH(MODE);
        b = (b << 1) | (HSWIRE_SDA_IN ? 1 : 0);
      }
      return b;
    }

    bool ack(uint8_t sda)
    {
      bool rv;
      HSWIRE_SCL_LOW;
      HSWIRE_DELAY_THDDAT(MODE);
      if (sda)
        HSWIRE_SDA_HIGH;
      else
        HSWIRE_SDA_LOW;
      HSWIRE_DELAY_TLOW(MODE);
      HSWIRE_SCL_HIGH;
      HSWIRE_DELAY_THIGH(MODE);
      rv = (HSWIRE_SDA_IN ? false : true);
      return rv;
    }

  public:

    HSWire(void)
    {
    }

    void begin()
    {
      HSWIRE_SDA_HIGH;
      HSWIRE_SCL_HIGH;
    }

    uint8_t write(uint8_t addr, uint8_t *buf, uint8_t len)
    {
      uint8_t cnt = 0xFF; // max 254 bytes.
      if (len == 0xFF)
        len = 0xFE;
      start();
      transfer((addr << 1) | 0);
      while (1)
      {
        if (!ack(HIGH))
          break;
        if (++cnt >= len)
          break;
        transfer(*buf++);
      }
      stop();
      return cnt;
    }

    uint8_t read(uint8_t addr, uint8_t *buf, uint8_t len)
    {
      uint8_t cnt = 0xFF; // max 254 bytes.
      if (len == 0xFF)
        len = 0xFE;
      start();
      transfer((addr << 1) | 1);
      while (1)
      {
        if (!ack(cnt + 1 < len ? LOW : HIGH))
          break;
        if (++cnt >= len)
          break; // no data
        *buf++ = receive();
      }
      stop();
      return cnt;
    }
};

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

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

* I2C Library for AVR

* Sasapea's Lab.

* 2019-07-29

* code example:

* #define HSWIRE_SCL_PORT B // SCL = PB2

* #define HSWIRE_SCL_BITN 2 //

* #define HSWIRE_SDA_PORT B // SDA = PB0

* #define HSWIRE_SDA_BITN 0 //

* #include "hswire.h"

* HSWire<HSWIRE_100K> Wire;

#ifndef _HSWIRE_H

#define _HSWIRE_H

#define HSWIRE_100K 0

#define HSWIRE_400K 1

#define HSWIRE_1M 2

#define HSWIRE_CAT(a, b) a##b

#define HSWIRE_REG(r, p) HSWIRE_CAT(r, p)

#define HSWIRE_SCL(r) HSWIRE_REG(r, HSWIRE_SCL_PORT)

#define HSWIRE_SDA(r) HSWIRE_REG(r, HSWIRE_SDA_PORT)

#include <stdint.h>

#include <stdbool.h>

#include <util/delay_basic.h>

#define HSWIRE_DELAY(t) \

do { \

uint8_t n = (uint8_t)((((t) / 1000.0) * (F_CPU / 1000000) * 256) / 768); \

if (n) _delay_loop_1(n); \

} while (0)

// Standard Mode

#define HSWIRE_100K_THDSTA HSWIRE_DELAY(4000) // 4000

#define HSWIRE_100K_TLOW HSWIRE_DELAY(4400) // 4700

#define HSWIRE_100K_THIGH HSWIRE_DELAY(4000) // 4000

#define HSWIRE_100K_TSUSTA HSWIRE_DELAY(4700) // 4700

#define HSWIRE_100K_THDDAT HSWIRE_DELAY( 200) // 300

#define HSWIRE_100K_TSUSTO HSWIRE_DELAY(4000) // 4000

#define HSWIRE_100K_TSUDAT HSWIRE_DELAY( 200) // 250

#define HSWIRE_100K_TBUF HSWIRE_DELAY(4700) // 4700

// Fast Mode

#define HSWIRE_400K_THDSTA // 600

#define HSWIRE_400K_TLOW HSWIRE_DELAY( 800) // 1300

#define HSWIRE_400K_THIGH HSWIRE_DELAY( 200) // 600

#define HSWIRE_400K_TSUSTA HSWIRE_DELAY( 600) // 600

#define HSWIRE_400K_THDDAT // 0

#define HSWIRE_400K_TSUSTO HSWIRE_DELAY( 400) // 600

#define HSWIRE_400K_TSUDAT // 100

#define HSWIRE_400K_TBUF HSWIRE_DELAY(1300) // 1300

// Hs Mode

#define HSWIRE_1M_THDSTA // 160

#define HSWIRE_1M_TLOW // 160

#define HSWIRE_1M_THIGH // 60

#define HSWIRE_1M_TSUSTA // 160

#define HSWIRE_1M_THDDAT // 0

#define HSWIRE_1M_TSUSTO // 160

#define HSWIRE_1M_TSUDAT // 10

#define HSWIRE_1M_TBUF // 60

#define HSWIRE_DELAY_THDSTA(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_THDSTA; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_THDSTA; \

else HSWIRE_100K_THDSTA; \

} while (0)

#define HSWIRE_DELAY_TLOW(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_TLOW; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_TLOW; \

else HSWIRE_100K_TLOW; \

} while (0)

#define HSWIRE_DELAY_THIGH(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_THIGH; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_THIGH; \

else HSWIRE_100K_THIGH; \

} while (0)

#define HSWIRE_DELAY_TSUSTA(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_TSUSTA; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUSTA; \

else HSWIRE_100K_TSUSTA; \

} while (0)

#define HSWIRE_DELAY_THDDAT(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_THDDAT; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_THDDAT; \

else HSWIRE_100K_THDDAT; \

} while (0)

#define HSWIRE_DELAY_TSUSTO(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_TSUSTO; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUSTO; \

else HSWIRE_100K_TSUSTO; \

} while (0)

#define HSWIRE_DELAY_TSUDAT(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_TSUDAT; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_TSUDAT; \

else HSWIRE_100K_TSUDAT; \

} while (0)

#define HSWIRE_DELAY_TBUF(m) \

do { \

if ((m) == HSWIRE_1M ) HSWIRE_1M_TBUF; \

else if ((m) == HSWIRE_400K) HSWIRE_400K_TBUF; \

else HSWIRE_100K_TBUF; \

} while (0)

#define HSWIRE_SCL_LOW do { HSWIRE_SCL(PORT) &= ~_BV(HSWIRE_SCL_BITN); HSWIRE_SCL(DDR) |= _BV(HSWIRE_SCL_BITN); } while (0)

#define HSWIRE_SCL_HIGH do {cli(); HSWIRE_SCL(PORT) |= _BV(HSWIRE_SCL_BITN); HSWIRE_SCL(DDR) &= ~_BV(HSWIRE_SCL_BITN); sei();} while (0)

#define HSWIRE_SDA_LOW do { HSWIRE_SDA(PORT) &= ~_BV(HSWIRE_SDA_BITN); HSWIRE_SDA(DDR) |= _BV(HSWIRE_SDA_BITN); } while (0)

#define HSWIRE_SDA_HIGH do {cli(); HSWIRE_SDA(PORT) |= _BV(HSWIRE_SDA_BITN); HSWIRE_SDA(DDR) &= ~_BV(HSWIRE_SDA_BITN); sei();} while (0)

#define HSWIRE_SDA_IN (HSWIRE_SDA(PIN) & _BV(HSWIRE_SDA_BITN))

template<uint8_t MODE = HSWIRE_100K>

class HSWire

{

private:

void start(void)

{

HSWIRE_SDA_LOW;

HSWIRE_DELAY_THDSTA(MODE);

}

void stop()

{

HSWIRE_SCL_LOW;

HSWIRE_DELAY_THDDAT(MODE);

HSWIRE_SDA_LOW;

HSWIRE_DELAY_TLOW(MODE);

HSWIRE_SCL_HIGH;

HSWIRE_DELAY_TSUSTO(MODE);

HSWIRE_SDA_HIGH;

HSWIRE_DELAY_TBUF(MODE);

}

void transfer(uint8_t b)

{

for (uint8_t i = 8; i--; )

{

HSWIRE_SCL_LOW;

HSWIRE_DELAY_THDDAT(MODE);

if (b & 0x80)

HSWIRE_SDA_HIGH;

else

HSWIRE_SDA_LOW;

HSWIRE_DELAY_TLOW(MODE);

HSWIRE_SCL_HIGH;

HSWIRE_DELAY_THIGH(MODE);

b <<= 1;

}

uint8_t receive(void)

{

uint8_t b = 0;

for (uint8_t i = 8; i--; )

{

HSWIRE_SCL_LOW;

HSWIRE_DELAY_THDDAT(MODE);

HSWIRE_SDA_HIGH;

HSWIRE_DELAY_TLOW(MODE);

HSWIRE_SCL_HIGH;

HSWIRE_DELAY_THIGH(MODE);

b = (b << 1) | (HSWIRE_SDA_IN ? 1 : 0);

}

return b;

}

bool ack(uint8_t sda)

{

bool rv;

HSWIRE_SCL_LOW;

HSWIRE_DELAY_THDDAT(MODE);

if (sda)

HSWIRE_SDA_HIGH;

else

HSWIRE_SDA_LOW;

HSWIRE_DELAY_TLOW(MODE);

HSWIRE_SCL_HIGH;

HSWIRE_DELAY_THIGH(MODE);

rv = (HSWIRE_SDA_IN ? false : true);

return rv;

}

public:

HSWire(void)

{

}

void begin()

{

HSWIRE_SDA_HIGH;

HSWIRE_SCL_HIGH;

}

uint8_t write(uint8_t addr, uint8_t *buf, uint8_t len)

{

uint8_t cnt = 0xFF; // max 254 bytes.

if (len == 0xFF)

len = 0xFE;

start();

transfer((addr << 1) | 0);

while (1)

{

if (!ack(HIGH))

break;

if (++cnt >= len)

break;

transfer(*buf++);

}

stop();

return cnt;

}

uint8_t read(uint8_t addr, uint8_t *buf, uint8_t len)

{

uint8_t cnt = 0xFF; // max 254 bytes.

if (len == 0xFF)

len = 0xFE;

start();

transfer((addr << 1) | 1);

while (1)

{

if (!ack(cnt + 1 < len ? LOW : HIGH))

break;

if (++cnt >= len)

break; // no data

*buf++ = receive();

}

stop();

return cnt;

}

};

コメントを残す コメントをキャンセル

コメントを残すコメントをキャンセル