BME.h 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606
  1. /******************************************************************************
  2. ******************************************************************************/
  3. #ifndef __BME_H
  4. #define __BME_H
  5. #ifdef __cplusplus
  6. extern "C" {
  7. #endif
  8. /******************************************************************************
  9. * BME operation code
  10. *
  11. *//*! @addtogroup BME_OPCode
  12. * @{
  13. *******************************************************************************/
  14. #define BME_OPCODE_AND 1 /*!< AND opcode */
  15. #define BME_OPCODE_OR 2 /*!< OR opcode */
  16. #define BME_OPCODE_XOR 3 /*!< XOR opcode */
  17. #define BME_OPCODE_BITFIELD 4 /*!< Bit field opcode */
  18. #define BME_OPCODE_BIT_CLEAR 2 /*!< Bit clear opcode */
  19. #define BME_OPCODE_BIT_SET 3 /*!< Bit set opcode */
  20. /*! @} End of BME_OPCode */
  21. /******************************************************************************
  22. * BME macro used to generate hardcoded BME addresses
  23. *
  24. *//*! @addtogroup BME_Utilities
  25. * @{
  26. *******************************************************************************/
  27. /******************************************************************************
  28. * macro used to generate hardcoded AND address.
  29. *
  30. *******************************************************************************/
  31. /*****************************************************************************//*!
  32. *
  33. * @brief generates BME AND operation addresss (hardcoded 32-bit address).
  34. *
  35. * @param[in] ADDR 32-bit address.
  36. *
  37. * @return hardcoded 32-bit address.
  38. *
  39. * @ Pass/ Fail criteria: none.
  40. *
  41. *****************************************************************************/
  42. #define BME_AND(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26)))
  43. /******************************************************************************
  44. * macro used to generate hardcoded OR address.
  45. *
  46. *******************************************************************************/
  47. /*****************************************************************************//*!
  48. *
  49. * @brief generates BME OR operation addresss (hardcoded 32-bit address).
  50. *
  51. * @param[in] ADDR 32-bit address.
  52. *
  53. * @return hardcoded 32-bit address.
  54. *
  55. * @ Pass/ Fail criteria: none.
  56. *
  57. *****************************************************************************/
  58. #define BME_OR(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26)))
  59. /******************************************************************************
  60. * macro used to generate hardcoded XOR address.
  61. *
  62. *******************************************************************************/
  63. /*****************************************************************************//*!
  64. *
  65. * @brief generates BME XOR operation addresss (hardcoded 32-bit address).
  66. *
  67. * @param[in] ADDR 32-bit address.
  68. *
  69. * @return hardcoded 32-bit address.
  70. *
  71. * @ Pass/ Fail criteria: none.
  72. *
  73. *****************************************************************************/
  74. #define BME_XOR(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26)))
  75. #if !defined(BME_SANITY_CHECK)
  76. /*!
  77. * @brief This is fastest way for BME without sanity check.
  78. */
  79. /******************************************************************************
  80. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  81. *
  82. *******************************************************************************/
  83. /*****************************************************************************//*!
  84. *
  85. * @brief generates BME bit clear operation addresss (hardcoded 32-bit address).
  86. *
  87. * @param[in] ADDR 32-bit address.
  88. * @param[in] bit bit number, 0-based.
  89. *
  90. * @return hardcoded 32-bit address.
  91. *
  92. * @ Pass/ Fail criteria: none.
  93. *
  94. *****************************************************************************/
  95. #define BME_BIT_CLEAR(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  96. | (BME_OPCODE_BIT_CLEAR <<26) \
  97. | ((bit)<<21)))
  98. /******************************************************************************
  99. * macro used to generate hardcoded load 1 bit set address (LAS1).
  100. *
  101. *******************************************************************************/
  102. /*****************************************************************************//*!
  103. *
  104. * @brief generates BME bit set operation addresss (hardcoded 32-bit address).
  105. *
  106. * @param[in] ADDR 32-bit address.
  107. * @param[in] bit bit number, 0-based.
  108. *
  109. * @return hardcoded 32-bit address.
  110. *
  111. * @ Pass/ Fail criteria: none.
  112. *
  113. *****************************************************************************/
  114. #define BME_BIT_SET(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  115. | (BME_OPCODE_BIT_SET <<26) \
  116. | ((bit)<<21)))
  117. /******************************************************************************
  118. * macro used to generate hardcoded bit field insert address (BFI).
  119. *
  120. *******************************************************************************/
  121. /*****************************************************************************//*!
  122. *
  123. * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address).
  124. *
  125. * @param[in] ADDR 32-bit address.
  126. * @param[in] bit bit number, 0-based.
  127. * @param[in] width bitfield width, 1-based.
  128. *
  129. * @return hardcoded 32-bit address.
  130. *
  131. * @ Pass/ Fail criteria: none.
  132. *
  133. *****************************************************************************/
  134. #define BME_BITFIELD_INSERT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  135. | (BME_OPCODE_BITFIELD <<26) \
  136. | ((bit)<<23) | ((width-1))<<19))
  137. /******************************************************************************
  138. * macro used to generate hardcoded bit field extract address (UBFX).
  139. *
  140. *******************************************************************************/
  141. /*****************************************************************************//*!
  142. *
  143. * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address).
  144. *
  145. * @param[in] ADDR 32-bit address.
  146. * @param[in] bit bit number, 0-based.
  147. * @param[in] width bitfield width, 1-based.
  148. *
  149. * @return hardcoded 32-bit address.
  150. *
  151. * @ Pass/ Fail criteria: none.
  152. *
  153. *****************************************************************************/
  154. #define BME_BITFIELD_EXTRACT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  155. | (BME_OPCODE_BITFIELD <<26) \
  156. | ((bit)<<23) | ((width-1))<<19))
  157. #else
  158. /*!
  159. * @brief This is slow way for BME as it has sanity check.
  160. */
  161. /******************************************************************************
  162. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  163. *
  164. *******************************************************************************/
  165. #define BME_BIT_CLEAR(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  166. | (BME_OPCODE_BIT_CLEAR <<26) \
  167. | ((bit & 0x1F)<<21))) /*!< Bit clear operation */
  168. /******************************************************************************
  169. * macro used to generate hardcoded load 1 bit set address (LAS1).
  170. *
  171. *******************************************************************************/
  172. #define BME_BIT_SET(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  173. | (BME_OPCODE_BIT_SET <<26) \
  174. | ((bit & 0x1F)<<21))) /*!< Bit set operation */
  175. /******************************************************************************
  176. * macro used to generate hardcoded bit field insert address (BFI).
  177. *
  178. *******************************************************************************/
  179. #define BME_BITFIELD_INSERT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  180. | (BME_OPCODE_BITFIELD <<26) \
  181. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation */
  182. /******************************************************************************
  183. * macro used to generate hardcoded bit field extract address (UBFX).
  184. *
  185. *******************************************************************************/
  186. #define BME_BITFIELD_EXTRACT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \
  187. | (BME_OPCODE_BITFIELD <<26) \
  188. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation */
  189. #endif
  190. /******************************************************************************
  191. * The following macros are used to generate hardcoded address for 8-bit operation.
  192. *
  193. *******************************************************************************/
  194. /******************************************************************************
  195. * macro used to generate hardcoded AND address for 8-bit operation.
  196. *
  197. *******************************************************************************/
  198. /*****************************************************************************//*!
  199. *
  200. * @brief generates BME AND operation addresss (hardcoded 32-bit address) for 8-bit data.
  201. *
  202. * @param[in] ADDR 32-bit address.
  203. *
  204. * @return hardcoded 32-bit address.
  205. *
  206. * @ Pass/ Fail criteria: none.
  207. *
  208. *****************************************************************************/
  209. #define BME_AND_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26)))
  210. /******************************************************************************
  211. * macro used to generate hardcoded OR address.
  212. *
  213. *******************************************************************************/
  214. /*****************************************************************************//*!
  215. *
  216. * @brief generates BME OR operation addresss (hardcoded 32-bit address) for 8-bit data.
  217. *
  218. * @param[in] ADDR 32-bit address.
  219. *
  220. * @return hardcoded 32-bit address.
  221. *
  222. * @ Pass/ Fail criteria: none.
  223. *
  224. *****************************************************************************/
  225. #define BME_OR_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26)))
  226. /******************************************************************************
  227. * macro used to generate hardcoded XOR address.
  228. *
  229. *******************************************************************************/
  230. /*****************************************************************************//*!
  231. *
  232. * @brief generates BME XOR operation addresss (hardcoded 32-bit address) for 8-bit data.
  233. *
  234. * @param[in] ADDR 32-bit address.
  235. *
  236. * @return hardcoded 32-bit address.
  237. *
  238. * @ Pass/ Fail criteria: none.
  239. *
  240. *****************************************************************************/
  241. #define BME_XOR_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26)))
  242. #if !defined(BME_SANITY_CHECK)
  243. /*!
  244. * @brief This is fastest way for BME without sanity check.
  245. */
  246. /******************************************************************************
  247. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  248. *
  249. *******************************************************************************/
  250. /*****************************************************************************//*!
  251. *
  252. * @brief generates BME bit clear operation addresss (hardcoded 32-bit address) for 8-bit data.
  253. *
  254. * @param[in] ADDR 32-bit address.
  255. * @param[in] bit bit number, 0-based.
  256. *
  257. * @return hardcoded 32-bit address.
  258. *
  259. * @ Pass/ Fail criteria: none.
  260. *
  261. *****************************************************************************/
  262. #define BME_BIT_CLEAR_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  263. | (BME_OPCODE_BIT_CLEAR <<26) \
  264. | ((bit)<<21)))
  265. /******************************************************************************
  266. * macro used to generate hardcoded load 1 bit set address (LAS1).
  267. *
  268. *******************************************************************************/
  269. /*****************************************************************************//*!
  270. *
  271. * @brief generates BME bit set operation addresss (hardcoded 32-bit address) for 8-bit data.
  272. *
  273. * @param[in] ADDR 32-bit address.
  274. * @param[in] bit bit number, 0-based.
  275. *
  276. * @return hardcoded 32-bit address.
  277. *
  278. * @ Pass/ Fail criteria: none.
  279. *
  280. *****************************************************************************/
  281. #define BME_BIT_SET_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  282. | (BME_OPCODE_BIT_SET <<26) \
  283. | ((bit)<<21)))
  284. /******************************************************************************
  285. * macro used to generate hardcoded bit field insert address (BFI).
  286. *
  287. *******************************************************************************/
  288. /*****************************************************************************//*!
  289. *
  290. * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address) for 8-bit data.
  291. *
  292. * @param[in] ADDR 32-bit address.
  293. * @param[in] bit bit number, 0-based.
  294. * @param[in] width bitfield width, 1-based.
  295. *
  296. * @return hardcoded 32-bit address.
  297. *
  298. * @ Pass/ Fail criteria: none.
  299. *
  300. *****************************************************************************/
  301. #define BME_BITFIELD_INSERT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  302. | (BME_OPCODE_BITFIELD <<26) \
  303. | ((bit)<<23) | ((width-1))<<19))
  304. /******************************************************************************
  305. * macro used to generate hardcoded bit field extract address (UBFX).
  306. *
  307. *******************************************************************************/
  308. /*****************************************************************************//*!
  309. *
  310. * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address) for 8-bit data.
  311. *
  312. * @param[in] ADDR 32-bit address.
  313. * @param[in] bit bit number, 0-based.
  314. * @param[in] width bitfield width, 1-based.
  315. *
  316. * @return hardcoded 32-bit address.
  317. *
  318. * @ Pass/ Fail criteria: none.
  319. *
  320. *****************************************************************************/
  321. #define BME_BITFIELD_EXTRACT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  322. | (BME_OPCODE_BITFIELD <<26) \
  323. | ((bit<<23) | ((width-1))<<19))
  324. #else
  325. /*!
  326. * @brief This is slow way for BME as it has sanity check.
  327. */
  328. /******************************************************************************
  329. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  330. *
  331. *******************************************************************************/
  332. #define BME_BIT_CLEAR_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  333. | (BME_OPCODE_BIT_CLEAR <<26) \
  334. | ((bit & 0x1F)<<21))) /*!< Bit clear operation on 8-bit*/
  335. /******************************************************************************
  336. * macro used to generate hardcoded load 1 bit set address (LAS1).
  337. *
  338. *******************************************************************************/
  339. #define BME_BIT_SET_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  340. | (BME_OPCODE_BIT_SET <<26) \
  341. | ((bit & 0x1F)<<21))) /*!< Bit set operation on 8-bit */
  342. /******************************************************************************
  343. * macro used to generate hardcoded bit field insert address (BFI).
  344. *
  345. *******************************************************************************/
  346. #define BME_BITFIELD_INSERT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  347. | (BME_OPCODE_BITFIELD <<26) \
  348. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation on 8-bit */
  349. /******************************************************************************
  350. * macro used to generate hardcoded bit field extract address (UBFX).
  351. *
  352. *******************************************************************************/
  353. #define BME_BITFIELD_EXTRACT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \
  354. | (BME_OPCODE_BITFIELD <<26) \
  355. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation on 8-bit*/
  356. #endif
  357. /******************************************************************************
  358. * The following macros are used to generate hardcoded address for 16-bit operation.
  359. *
  360. *******************************************************************************/
  361. /******************************************************************************
  362. * macro used to generate hardcoded AND address for 16-bit operation.
  363. *
  364. *******************************************************************************/
  365. /*****************************************************************************//*!
  366. *
  367. * @brief generates BME AND operation addresss (hardcoded 32-bit address) for 16-bit data.
  368. *
  369. * @param[in] ADDR 32-bit address.
  370. *
  371. * @return hardcoded 32-bit address.
  372. *
  373. * @ Pass/ Fail criteria: none.
  374. *
  375. *****************************************************************************/
  376. #define BME_AND_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26)))
  377. /******************************************************************************
  378. * macro used to generate hardcoded OR address.
  379. *
  380. *******************************************************************************/
  381. /*****************************************************************************//*!
  382. *
  383. * @brief generates BME OR operation addresss (hardcoded 32-bit address) for 16-bit data.
  384. *
  385. * @param[in] ADDR 32-bit address.
  386. *
  387. * @return hardcoded 32-bit address.
  388. *
  389. * @ Pass/ Fail criteria: none.
  390. *
  391. *****************************************************************************/
  392. #define BME_OR_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26)))
  393. /******************************************************************************
  394. * macro used to generate hardcoded XOR address.
  395. *
  396. *******************************************************************************/
  397. /*****************************************************************************//*!
  398. *
  399. * @brief generates BME XOR operation addresss (hardcoded 32-bit address) for 16-bit data.
  400. *
  401. * @param[in] ADDR 32-bit address.
  402. *
  403. * @return hardcoded 32-bit address.
  404. *
  405. * @ Pass/ Fail criteria: none.
  406. *
  407. *****************************************************************************/
  408. #define BME_XOR_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26)))
  409. #if !defined(BME_SANITY_CHECK)
  410. /*!
  411. * @brief This is fastest way for BME without sanity check.
  412. */
  413. /******************************************************************************
  414. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  415. *
  416. *******************************************************************************/
  417. /*****************************************************************************//*!
  418. *
  419. * @brief generates BME bit clear operation addresss (hardcoded 32-bit address) for 16-bit data.
  420. *
  421. * @param[in] ADDR 32-bit address.
  422. * @param[in] bit bit number, 0-based.
  423. *
  424. * @return hardcoded 32-bit address.
  425. *
  426. * @ Pass/ Fail criteria: none.
  427. *
  428. *****************************************************************************/
  429. #define BME_BIT_CLEAR_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  430. | (BME_OPCODE_BIT_CLEAR <<26) \
  431. | ((bit)<<21)))
  432. /******************************************************************************
  433. * macro used to generate hardcoded load 1 bit set address (LAS1).
  434. *
  435. *******************************************************************************/
  436. /*****************************************************************************//*!
  437. *
  438. * @brief generates BME bit set operation addresss (hardcoded 32-bit address) for 16-bit data.
  439. *
  440. * @param[in] ADDR 32-bit address.
  441. * @param[in] bit bit number, 0-based.
  442. *
  443. * @return hardcoded 32-bit address.
  444. *
  445. * @ Pass/ Fail criteria: none.
  446. *
  447. *****************************************************************************/
  448. #define BME_BIT_SET_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  449. | (BME_OPCODE_BIT_SET <<26) \
  450. | ((bit)<<21)))
  451. /******************************************************************************
  452. * macro used to generate hardcoded bit field insert address (BFI).
  453. *
  454. *******************************************************************************/
  455. /*****************************************************************************//*!
  456. *
  457. * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address) for 16-bit data.
  458. *
  459. * @param[in] ADDR 32-bit address.
  460. * @param[in] bit bit number, 0-based.
  461. * @param[in] width bitfield width, 1-based.
  462. *
  463. * @return hardcoded 32-bit address.
  464. *
  465. * @ Pass/ Fail criteria: none.
  466. *
  467. *****************************************************************************/
  468. #define BME_BITFIELD_INSERT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  469. | (BME_OPCODE_BITFIELD <<26) \
  470. | ((bit)<<23) | ((width-1))<<19))
  471. /******************************************************************************
  472. * macro used to generate hardcoded bit field extract address (UBFX).
  473. *
  474. *******************************************************************************/
  475. /*****************************************************************************//*!
  476. *
  477. * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address) for 16-bit data.
  478. *
  479. * @param[in] ADDR 32-bit address.
  480. * @param[in] bit bit number, 0-based.
  481. * @param[in] width bitfield width, 1-based.
  482. *
  483. * @return hardcoded 32-bit address.
  484. *
  485. * @ Pass/ Fail criteria: none.
  486. *
  487. *****************************************************************************/
  488. #define BME_BITFIELD_EXTRACT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  489. | (BME_OPCODE_BITFIELD <<26) \
  490. | ((bit)<<23) | ((width-1))<<19))
  491. #else
  492. /*!
  493. * @brief This is slow way for BME as it has sanity check.
  494. */
  495. /******************************************************************************
  496. * macro used to generate hardcoded load 1 bit clear address (LAC1).
  497. *
  498. *******************************************************************************/
  499. #define BME_BIT_CLEAR_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  500. | (BME_OPCODE_BIT_CLEAR <<26) \
  501. | ((bit & 0x1F)<<21))) /*!< Bit clear operation on 16-bit*/
  502. /******************************************************************************
  503. * macro used to generate hardcoded load 1 bit set address (LAS1).
  504. *
  505. *******************************************************************************/
  506. #define BME_BIT_SET_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  507. | (BME_OPCODE_BIT_SET <<26) \
  508. | ((bit & 0x1F)<<21))) /*!< Bit set operation on 16-bit */
  509. /******************************************************************************
  510. * macro used to generate hardcoded bit field insert address (BFI).
  511. *
  512. *******************************************************************************/
  513. #define BME_BITFIELD_INSERT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  514. | (BME_OPCODE_BITFIELD <<26) \
  515. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation on 16-bit */
  516. /******************************************************************************
  517. * macro used to generate hardcoded bit field extract address (UBFX).
  518. *
  519. *******************************************************************************/
  520. #define BME_BITFIELD_EXTRACT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \
  521. | (BME_OPCODE_BITFIELD <<26) \
  522. | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation on 16-bit*/
  523. #endif
  524. /*! @} End of BME_Utilities */
  525. #ifdef __cplusplus
  526. }
  527. #endif
  528. #endif /* __BME_H */