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 #ifndef _AVR_SLEEP_H_

36 #define _AVR_SLEEP_H_ 1

37 

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 

129 

130 

131 

132 

133 

134 

135 

136 

137 

138 #if defined(SLEEP_CTRL)

139 

140 

141  #define _SLEEP_CONTROL_REG SLEEP_CTRL

142  #define _SLEEP_ENABLE_MASK SLEEP_SEN_bm

143 

144 #elif defined(SMCR)

145 

146  #define _SLEEP_CONTROL_REG SMCR

147  #define _SLEEP_ENABLE_MASK _BV(SE)

148 

149 #elif defined(__AVR_AT94K__)

150 

151  #define _SLEEP_CONTROL_REG MCUR

152  #define _SLEEP_ENABLE_MASK _BV(SE)

153 

154 #elif !defined(__DOXYGEN__)

155 

156  #define _SLEEP_CONTROL_REG MCUCR

157  #define _SLEEP_ENABLE_MASK _BV(SE)

158 

159 #endif

160 

161 

162 

163 

164 #if defined(__AVR_ATmega161__)

165 

166  #define set_sleep_mode(mode) \

167  do { \

168  MCUCR = ((MCUCR & ~_BV(SM1)) | ((mode) == SLEEP_MODE_PWR_DOWN || (mode) == SLEEP_MODE_PWR_SAVE ? _BV(SM1) : 0)); \

169  EMCUCR = ((EMCUCR & ~_BV(SM0)) | ((mode) == SLEEP_MODE_PWR_SAVE ? _BV(SM0) : 0)); \

170  } while(0)

171 

172 

173 #elif defined(__AVR_ATmega162__) \

174 || defined(__AVR_ATmega8515__)

175 

176  #define set_sleep_mode(mode) \

177  do { \

178  MCUCR = ((MCUCR & ~_BV(SM1)) | ((mode) == SLEEP_MODE_IDLE ? 0 : _BV(SM1))); \

179  MCUCSR = ((MCUCSR & ~_BV(SM2)) | ((mode) == SLEEP_MODE_STANDBY || (mode) == SLEEP_MODE_EXT_STANDBY ? _BV(SM2) : 0)); \

180  EMCUCR = ((EMCUCR & ~_BV(SM0)) | ((mode) == SLEEP_MODE_PWR_SAVE || (mode) == SLEEP_MODE_EXT_STANDBY ? _BV(SM0) : 0)); \

181  } while(0)

182 

183 

184 #elif defined(__AVR_XMEGA__)

185 #if defined(SLEEP_SMODE2_bm)

186 

187  #define set_sleep_mode(mode) \

188  do { \

189  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~(SLEEP_SMODE2_bm | SLEEP_SMODE1_bm | SLEEP_SMODE0_bm)) | (mode)); \

190  } while(0)

191 

192 #elif defined(SLEEP_SMODE1_bm)

193 

194  #define set_sleep_mode(mode) \

195  do { \

196  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~(SLEEP_SMODE1_bm | SLEEP_SMODE0_bm)) | (mode)); \

197  } while(0)

198 

199 #else

200 

201  #define set_sleep_mode(mode) \

202  do { \

203  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~( SLEEP_SMODE0_bm)) | (mode)); \

204  } while(0)

205 

206 

207 #endif

208 

209 

210 #else

211 #if defined(SM2)

212 

213  #define set_sleep_mode(mode) \

214  do { \

215  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~(_BV(SM0) | _BV(SM1) | _BV(SM2))) | (mode)); \

216  } while(0)

217 

218 #elif defined(SM1)

219 

220  #define set_sleep_mode(mode) \

221  do { \

222  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~(_BV(SM0) | _BV(SM1))) | (mode)); \

223  } while(0)

224 

225 #elif defined(SM)

226 

227  #define set_sleep_mode(mode) \

228  do { \

229  _SLEEP_CONTROL_REG = ((_SLEEP_CONTROL_REG & ~_BV(SM)) | (mode)); \

230  } while(0)

231 

232 #else

233 

234  #error "No SLEEP mode defined for this device."

235 

236 #endif

237 #endif

238 

239 

240 

241 

242 

243 

244 

245 

246 

247 

248 #if defined(__DOXYGEN__)

249 

250 

251 

252 

253 

255 

256 #else

257 

258 #define sleep_enable() \

259 do { \

260  _SLEEP_CONTROL_REG |= (uint8_t)_SLEEP_ENABLE_MASK; \

261 } while(0)

262 

263 #endif

264 

265 

266 #if defined(__DOXYGEN__)

267 

268 

269 

270 

271 

273 

274 #else

275 

276 #define sleep_disable() \

277 do { \

278  _SLEEP_CONTROL_REG &= (uint8_t)(~_SLEEP_ENABLE_MASK); \

279 } while(0)

280 

281 #endif

282 

283 

284 

285 

286 

287 

288 

289 #if defined(__DOXYGEN__)

290 

292 

293 #else

294 

295 #define sleep_cpu() \

296 do { \

297  __asm__ __volatile__ ( "sleep" "\n\t" :: ); \

298 } while(0)

299 

300 #endif

301 

302 

303 #if defined(__DOXYGEN__)

304 

305 

306 

307 

308 

310 

311 #else

312 

313 #define sleep_mode() \

314 do { \

315  sleep_enable(); \

316  sleep_cpu(); \

317  sleep_disable(); \

318 } while (0)

319 

320 #endif

321 

322 

323 #if defined(__DOXYGEN__)

324 

325 

326 

327 

328 

329 

331 

332 #else

333 

334 #if defined(BODS) && defined(BODSE)

335 

336 #ifdef BODCR

337 

338 #define BOD_CONTROL_REG BODCR

339 

340 #else

341 

342 #define BOD_CONTROL_REG MCUCR

343 

344 #endif

345 

346 #define sleep_bod_disable() \

347 do { \

348  uint8_t tempreg; \

349  __asm__ __volatile__("in %[tempreg], %[mcucr]" "\n\t" \

350  "ori %[tempreg], %[bods_bodse]" "\n\t" \

351  "out %[mcucr], %[tempreg]" "\n\t" \

352  "andi %[tempreg], %[not_bodse]" "\n\t" \

353  "out %[mcucr], %[tempreg]" \

354  : [tempreg] "=&d" (tempreg) \

355  : [mcucr] "I" _SFR_IO_ADDR(BOD_CONTROL_REG), \

356  [bods_bodse] "i" (_BV(BODS) | _BV(BODSE)), \

357  [not_bodse] "i" (~_BV(BODSE))); \

358 } while (0)

359 

360 #endif

361 

362 #endif

363 

364 

365 

366 

367 #endif