Поясните? Не понял.
ну почему вместо привычного i++, ты пишешь ++i ?
понятно что тут это “на скорость” не влияет, но все же))
1 стандарту не противоречит
2 дело вкуса, мне непривычно, я пишу i++ исключительно там, где это необходимо в логике программы
Это код из какой-то процедуры/функции? Если да, то покажи «обрамление» (что до, что после).
3 строка из кода выше?
Тупо массив заполняется байтами.
Весь код выведу как до компа доберусь. Но там инициализация quad spi, ничего примечательного.
А если эту строку закомментировать?
Убирал все выводы в лог, менял на прямой вывод на экран, без библиотек studio, пофиг, объявляю переменную - все рушится.
Еще оди бред - а волотальной ее сделать?
Попробую, завтра.
/*
* h7flashW25qspi.cpp
*
* Created on: Oct 23, 2025
* Author: seleznev_a
*
* SPI Flash W25Q64JV
*
* H743VI QSPI <-> W25Q64JV
*
* PB6 BK1 NCS AF10 1 CS
* PD12 BK1 IO1 AF9 2 DO (IO1)
* PE2 BK1 IO2 AF9 3 IO2
* GND 4 GND
* PD11 BK1 IO0 AF9 5 DI (IO0)
* PB2 SCK AF9 6 CLK
* PD13 BK1 IO3 AF9 7 IO3
* 3V3 8 VCC
*
* https://vivonomicon.com/2020/08/08/bare-metal-stm32-programming-part-12-using-quad-spi-flash-memory/
*
*/
#include "h7flashW25qspi.h"
#include "stm32h7xx.h"
#include <stdio.h>
#include "h7base.h"
//#include "h7tftST7735.h"
unsigned char w25_read_reg_inSPImode(const unsigned char reg) {
// Disable the peripheral.
QUADSPI->CR &= ~QUADSPI_CR_EN;
// clear in data
while(QUADSPI->SR & QUADSPI_SR_FLEVEL) __attribute__((unused)) unsigned int inB = *((unsigned int*)&QUADSPI->DR);
// Clear instruction, mode and transaction phases.
QUADSPI->CCR =0;
// Set 1-wire instruction and data modes
QUADSPI->CCR |= (1 << QUADSPI_CCR_IMODE_Pos) |
(1 << QUADSPI_CCR_DMODE_Pos) |
(1 << QUADSPI_CCR_FMODE_Pos);
QUADSPI->DLR = 0;
// Enable the peripheral.
QUADSPI->CR |= QUADSPI_CR_EN;
// Set the given 'read register' instruction to start polling.
QUADSPI->CCR |= reg << QUADSPI_CCR_INSTRUCTION_Pos;
// Wait for a read
while(QUADSPI->SR & QUADSPI_SR_BUSY) {
if (QUADSPI->SR & QUADSPI_SR_FTF) break;
};
// Disable the peripheral.
QUADSPI->CR &= ~QUADSPI_CR_EN;
unsigned int inData = QUADSPI->DR;
return (inData & 0x000000FF);
}
void w25_qspi_reg_wait(const unsigned char reg, const unsigned char msk, const unsigned char mat ) {
unsigned char inReg = w25_read_reg_inSPImode(reg);
while((inReg & msk) != mat) inReg = w25_read_reg_inSPImode(reg);
}
void w25_qspi_wen() {
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Clear the instruction, mode, and transaction phases.
QUADSPI->CCR = 0;
QUADSPI->DLR = 0;
// Set 4-wire instruction mode.
QUADSPI->CCR |= ( 1 << QUADSPI_CCR_IMODE_Pos );
// Enable the peripheral and send the 'write enable' command.
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_WRITE_ENABLE << QUADSPI_CCR_INSTRUCTION_Pos );
// Wait for the transaction to finish.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Wait until 'writes enabled' is set in the config register.
w25_qspi_reg_wait(qW25_READ_STATUS_1, 0x01, 0x00);
}
void w25_qspi_wds() {
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Clear the instruction, mode, and transaction phases.
QUADSPI->CCR = 0;
QUADSPI->DLR = 0;
// Set 4-wire instruction mode.
QUADSPI->CCR |= ( 1 << QUADSPI_CCR_IMODE_Pos );
// Enable the peripheral and send the 'write disable' command.
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_WRITE_DISABLE << QUADSPI_CCR_INSTRUCTION_Pos );
// Wait for the transaction to finish.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Wait until 'writes enabled' is set in the config register.
w25_qspi_reg_wait(qW25_READ_STATUS_1, 0x01, 0x00);
}
// Erase a 4KB sector. Sector address = ( snum * 0x1000 )
void w25_qspi_erase_sector(const unsigned int snum ) {
// Send 'enable writes' command.
w25_qspi_wen();
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Erase the sector, and wait for the operation to complete.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
QUADSPI->CCR =0;
QUADSPI->DLR = 0;
QUADSPI->CCR |= ( ( 1 << QUADSPI_CCR_IMODE_Pos ) |
( 2 << QUADSPI_CCR_ADSIZE_Pos ) |
( 1 << QUADSPI_CCR_ADMODE_Pos ) );
QUADSPI->CR |= ( QUADSPI_CR_EN );
// 0x20 is the "sector erase" command.
QUADSPI->CCR |= ( qW25_SECTOR_ERASE << QUADSPI_CCR_INSTRUCTION_Pos );
// The address is equal to the sector number * 4KB.
QUADSPI->AR = ( snum * qw25sectorSize );
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral once the transaction is complete.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Wait for the 'write in progress' bit to clear.
w25_qspi_reg_wait(qW25_READ_STATUS_1, 0x01, 0x00);
w25_qspi_wds();
}
void w25_qspi_page_program(const unsigned int snum, const unsigned char * inPage) {
// Send 'enable writes' command.
w25_qspi_wen();
// Erase the sector, and wait for the operation to complete.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
QUADSPI->CCR = 0;
QUADSPI->CCR |= ( ( 1 << QUADSPI_CCR_IMODE_Pos ) |
( 3 << QUADSPI_CCR_DMODE_Pos ) |
( 2 << QUADSPI_CCR_ADSIZE_Pos ) |
(QUADSPI_CCR_SIOO) |
( 1 << QUADSPI_CCR_ADMODE_Pos ) );
constexpr unsigned int countBytesSend = qw25pageSize;
QUADSPI->DLR = countBytesSend - 1;
unsigned int countDWordSend = countBytesSend/4;
unsigned int * inData = (unsigned int *)inPage;
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_QUAD_PAGE_PROGRAMM << QUADSPI_CCR_INSTRUCTION_Pos );
QUADSPI->AR = ( snum * qw25pageSize);
while(countDWordSend--) {
*((unsigned int*)&QUADSPI->DR) = *(inData++);
while(!(QUADSPI->SR & QUADSPI_SR_FTF)) {};
}
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral once the transaction is complete.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Wait for the 'write in progress' bit to clear.
w25_qspi_reg_wait(qW25_READ_STATUS_1, 0x01, 0x00);
w25_qspi_wds();
}
void w25QSPIreadSector(const unsigned int numSector, unsigned char * data) {
// clear in data
while(QUADSPI->SR & QUADSPI_SR_FTF) __attribute__((unused)) unsigned int inB = *((unsigned int*)&QUADSPI->DR);
QUADSPI->CCR = 0;
QUADSPI->CCR |= ( 1 << QUADSPI_CCR_IMODE_Pos ) |
( 3 << QUADSPI_CCR_DMODE_Pos ) |
( 1 << QUADSPI_CCR_FMODE_Pos ) |
( 8 << QUADSPI_CCR_DCYC_Pos) |
( 2 << QUADSPI_CCR_ADSIZE_Pos ) |
//( 1 << QUADSPI_CCR_ABMODE_Pos ) |
//( 3 << QUADSPI_CCR_ABSIZE_Pos ) |
(QUADSPI_CCR_SIOO) |
( 1 << QUADSPI_CCR_ADMODE_Pos );
constexpr unsigned int countBytesRead = qw25sectorSize;
QUADSPI->DLR = countBytesRead - 1;
//QUADSPI->ABR = 0xFFFFFFFF;
unsigned int countDWordRead = countBytesRead/4;
unsigned int * outData = (unsigned int *)data;
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_QUAD_READ << QUADSPI_CCR_INSTRUCTION_Pos );
QUADSPI->AR = ( numSector * qw25sectorSize);
//printf("- %08X\r\n", countDWordRead);
while(countDWordRead--) {
while(!(QUADSPI->SR & QUADSPI_SR_FTF)) {};
*(outData++) = *((unsigned int*)&QUADSPI->DR);
}
//printf("- %08X\r\n", countDWordRead);
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral once the transaction is complete.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
}
void w25_reset(void) {
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Clear the instruction, mode, and transaction phases.
QUADSPI->CCR = 0;
QUADSPI->DLR = 0;
// Set 4-wire instruction mode.
QUADSPI->CCR |= ( 1 << QUADSPI_CCR_IMODE_Pos );
// Enable the peripheral and send the 'write enable' command.
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_ENABLE_RESET << QUADSPI_CCR_INSTRUCTION_Pos );
// Wait for the transaction to finish.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
// Clear the instruction, mode, and transaction phases.
QUADSPI->CCR = 0;
QUADSPI->DLR = 0;
// Set 4-wire instruction mode.
QUADSPI->CCR |= ( 1 << QUADSPI_CCR_IMODE_Pos );
// Enable the peripheral and send the 'write enable' command.
QUADSPI->CR |= ( QUADSPI_CR_EN );
QUADSPI->CCR |= ( qW25_RESET << QUADSPI_CCR_INSTRUCTION_Pos );
// Wait for the transaction to finish.
while ( QUADSPI->SR & QUADSPI_SR_BUSY ) {};
// Disable the peripheral.
QUADSPI->CR &= ~( QUADSPI_CR_EN );
delay_ms(100U);
}
void w25QSPIwriteSector(const unsigned int numSector, const unsigned char * data) {
w25_qspi_erase_sector(numSector);
for(unsigned int j = 0; j < qw25countPagesInSector; ++j) w25_qspi_page_program(numSector*qw25countPagesInSector+j, (const unsigned char *)((unsigned char *)data+(j*qw25pageSize)));
}
bool qw25testEndSector(void) {
constexpr unsigned int testSector = qw25countAllSectors - 127;
static unsigned char tempBuf[qw25sectorSize];
for(unsigned int i = 0; i < qw25sectorSize; ++i) tempBuf[i] = i;
unsigned int * bD = (unsigned int *)&tempBuf[0];
printf("bD %08X\r\n", (unsigned int)(*(bD)));
//w25QSPIwriteSector(testSector, (unsigned char *)&tempBuf[0]);
for(unsigned int i = 0; i < qw25sectorSize; ++i) tempBuf[i] = 0x00;
w25QSPIreadSector(testSector, (unsigned char *)&tempBuf[0]);
printf("In %08X\r\n", (unsigned int)(*bD));
printf("2n %08X\r\n", (unsigned int)(*(bD+1)));
printf("3n %08X\r\n", (unsigned int)(*(bD+2)));
printf("4n %08X\r\n", (unsigned int)(*(bD+3)));
//for(unsigned int i = 0; i < qw25sectorSize; ++i) if (tempBuf[i] != (unsigned char)(i & 0x000000FF)) return false;
return true;
}
void h743initW25Q64QSPI(void) {
RCC->AHB4ENR |= RCC_AHB4ENR_GPIOBEN; // GPIOB enable
RCC->AHB4ENR |= RCC_AHB4ENR_GPIODEN; // GPIOD enable
RCC->AHB4ENR |= RCC_AHB4ENR_GPIOEEN; // GPIOE enable
// PB6 BK1 NCS AF10 1 CS
GPIOB->MODER |= GPIO_MODER_MODER6_1; // 10: Alternate function mode
GPIOB->MODER &= ~GPIO_MODER_MODER6_0; // 10: Alternate function mode
GPIOB->OTYPER &= ~GPIO_OTYPER_OT6; // 0: Output push-pull (reset state)
GPIOB->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED6; // 00: Low speed
GPIOB->OSPEEDR |= GPIO_OSPEEDR_OSPEED6_1; // 10: High speed
//GPIOB->OSPEEDR |= GPIO_OSPEEDR_OSPEED6_0; // 11: Very high speed
GPIOB->PUPDR &= ~GPIO_PUPDR_PUPD6; // 00: No pull-up, pull-down
//GPIOB->PUPDR |= GPIO_PUPDR_PUPD6_0; // 01: pull-up
GPIOB->AFR[0] |= (0x0A << GPIO_AFRL_AFSEL6_Pos); // AF10
// PD12 BK1 IO1 AF9 2 DO (IO1)
GPIOD->MODER |= GPIO_MODER_MODER12_1; // 10: Alternate function mode
GPIOD->MODER &= ~GPIO_MODER_MODER12_0; // 10: Alternate function mode
GPIOD->OTYPER &= ~GPIO_OTYPER_OT12; // 0: Output push-pull (reset state)
GPIOD->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED12; // 00: Low speed
GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED12_1; // 10: High speed
//GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED12_0; // 11: Very high speed
//GPIOD->PUPDR |= GPIO_PUPDR_PUPD12_0; // 01: pull-up
GPIOD->AFR[1] |= (0x09 << GPIO_AFRH_AFSEL12_Pos); // AF9
// PE2 BK1 IO2 AF9 3 IO2
GPIOE->MODER |= GPIO_MODER_MODER2_1; // 10: Alternate function mode
GPIOE->MODER &= ~GPIO_MODER_MODER2_0; // 10: Alternate function mode
GPIOE->OTYPER &= ~GPIO_OTYPER_OT2; // 0: Output push-pull (reset state)
GPIOE->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED2; // 00: Low speed
GPIOE->OSPEEDR |= GPIO_OSPEEDR_OSPEED2_1; // 10: High speed
//GPIOE->OSPEEDR |= GPIO_OSPEEDR_OSPEED2_0; // 11: Very high speed
//GPIOE->PUPDR |= GPIO_PUPDR_PUPD2_0; // 01: pull-up
GPIOE->AFR[0] |= (0x09 << GPIO_AFRL_AFSEL2_Pos); // AF9
// PD11 BK1 IO0 AF9 5 DI (IO0)
GPIOD->MODER |= GPIO_MODER_MODER11_1; // 10: Alternate function mode
GPIOD->MODER &= ~GPIO_MODER_MODER11_0; // 10: Alternate function mode
GPIOD->OTYPER &= ~GPIO_OTYPER_OT11; // 0: Output push-pull (reset state)
GPIOD->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED11; // 00: Low speed
GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED11_1; // 10: High speed
//GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED11_0; // 11: Very high speed
//GPIOD->PUPDR |= GPIO_PUPDR_PUPD11_0; // 01: pull-up
GPIOD->AFR[1] |= (0x09 << GPIO_AFRH_AFSEL11_Pos); // AF9
// PB2 SCK AF9 6 CLK
GPIOB->MODER |= GPIO_MODER_MODER2_1; // 10: Alternate function mode
GPIOB->MODER &= ~GPIO_MODER_MODER2_0; // 10: Alternate function mode
GPIOB->OTYPER &= ~GPIO_OTYPER_OT2; // 0: Output push-pull (reset state)
GPIOB->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED2; // 00: Low speed
GPIOB->OSPEEDR |= GPIO_OSPEEDR_OSPEED2_1; // 10: High speed
//GPIOB->OSPEEDR |= GPIO_OSPEEDR_OSPEED2_0; // 11: Very high speed
//GPIOB->PUPDR |= GPIO_PUPDR_PUPD2_1; // 10: pull-down
GPIOB->AFR[0] |= (0x09 << GPIO_AFRL_AFSEL2_Pos); // AF9
// PD13 BK1 IO3 AF9 7 IO3
GPIOD->MODER |= GPIO_MODER_MODER13_1; // 10: Alternate function mode
GPIOD->MODER &= ~GPIO_MODER_MODER13_0; // 10: Alternate function mode
GPIOD->OTYPER &= ~GPIO_OTYPER_OT13; // 0: Output push-pull (reset state)
GPIOD->OSPEEDR &= ~GPIO_OSPEEDR_OSPEED13; // 00: Low speed
GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED13_1; // 10: High speed
//GPIOD->OSPEEDR |= GPIO_OSPEEDR_OSPEED13_0; // 11: Very high speed
//GPIOD->PUPDR |= GPIO_PUPDR_PUPD13_0; // 01: pull-up
GPIOD->AFR[1] |= (0x09 << GPIO_AFRH_AFSEL13_Pos); // AF9
// Quad SPI
RCC->D1CCIPR |= RCC_D1CCIPR_QSPISEL_0; // 01: pll1_q_ck clock selected as kernel peripheral clock
RCC->D1CCIPR &= ~RCC_D1CCIPR_QSPISEL_1; // 01: pll1_q_ck clock selected as kernel peripheral clock
RCC->AHB3ENR |= RCC_AHB3RSTR_QSPIRST; // reset
for(unsigned int i = 0; i < 0x1000; i++){__NOP();} // wait reset
RCC->AHB3ENR &= ~RCC_AHB3RSTR_QSPIRST; // reset
RCC->AHB3ENR |= RCC_AHB3ENR_QSPIEN; // QSPI clock EN
// QSPI peripheral initialization.
QUADSPI->FCR = 0;
QUADSPI->CR = 0;
QUADSPI->CR |= QUADSPI_CR_PRESCALER_0; // Bits 31:24 PRESCALER[7:0]: Clock prescaler // 7: FCLK = Fquadspi_ker_ck/8
QUADSPI->CR |= QUADSPI_CR_PRESCALER_1; // Bits 31:24 PRESCALER[7:0]: Clock prescaler // 7: FCLK = Fquadspi_ker_ck/8
QUADSPI->CR |= QUADSPI_CR_PRESCALER_2; // Bits 31:24 PRESCALER[7:0]: Clock prescaler // 7: FCLK = Fquadspi_ker_ck/8
QUADSPI->CR |= QUADSPI_CR_PRESCALER_3;
QUADSPI->CR |= QUADSPI_CR_PRESCALER_4;
// Set Flash size; 512Mb = 64MB = 2^(25+1) bytes. // QUADSPI->DCR |= ( 25 << QUADSPI_DCR_FSIZE_Pos );
QUADSPI->DCR |= 22 << QUADSPI_DCR_FSIZE_Pos; // Set Flash size; 64Mb = 8MB = 2^(22+1) bytes.
// Wait an extra half-cycle to read, and set a clock prescaler of 2+1=3.
QUADSPI->CR |= QUADSPI_CR_SSHIFT; // 1: 1/2 cycle shift
QUADSPI->CR |= QUADSPI_CR_FTHRES_0;
QUADSPI->CR |= QUADSPI_CR_FTHRES_1;
// Initialization W25Q64
w25_reset();
// для начала нам необходимо прочитать Read Status Register-2 35h (S15-S8)(2) // команда соотвественно 35h
unsigned char sReg = w25_read_reg_inSPImode(qW25_READ_STATUS_2);
if (!(sReg & 0x00000002)) return; // если бит S9(1) Quad Enable (QE) отсутствует, значит дальше нечего делать, т к Quad SPI режим на флэшке выключен
// считаем идентификатор чипа уже в режиме Quad SPI // Read Manufacturer / Device ID Quad I/O (94h)
// Disable the peripheral.
QUADSPI->CR &= ~QUADSPI_CR_EN;
// clear in data
while(QUADSPI->SR & QUADSPI_SR_FLEVEL) __attribute__((unused)) unsigned int inB = *((unsigned int*)&QUADSPI->DR);
// Clear instruction, mode and transaction phases.
QUADSPI->CCR = 0;
QUADSPI->CCR = (1 << QUADSPI_CCR_IMODE_Pos) | // 01: Instruction on a single line
(3 << QUADSPI_CCR_DMODE_Pos) | // 11: Data on four lines
(1 << QUADSPI_CCR_FMODE_Pos) | // 01: Indirect-read mode
(16 << QUADSPI_CCR_DCYC_Pos); // Number of dummy cycles
QUADSPI->DLR = 1; // надо два байта прочитать
// Enable the peripheral.
QUADSPI->CR |= QUADSPI_CR_EN;
// Set the given 'read register' instruction to start polling.
QUADSPI->CCR |= qW25_QUAD_GET_MNF_DID << QUADSPI_CCR_INSTRUCTION_Pos;
// Wait for a read
while(QUADSPI->SR & QUADSPI_SR_BUSY) {
if (QUADSPI->SR & QUADSPI_SR_FLEVEL) break;
};
// Disable the peripheral.
QUADSPI->CR &= ~QUADSPI_CR_EN;
unsigned int inData = *((unsigned int*)&QUADSPI->DR);
// читаем два байта
if ((inData & 0x0000EF00) != 0x0000EF00) return; // первый байт Manufacture ID должен быть равен 0xEF Winbond
printf("W25QSPI %0x\r\n", (unsigned int)inData);
//if (!qw25testEndSector()) printf("W25QSPI err\r\n");
constexpr unsigned int testSector = qw25countAllSectors - 1863;
unsigned char tempBuf[qw25sectorSize];
for(unsigned int i = 0; i < qw25sectorSize; ++i) tempBuf[i] = i;
unsigned int * bD = (unsigned int *)&tempBuf[0];
printf("bD %08X\r\n", (unsigned int)(*(bD+687)));
w25QSPIwriteSector(testSector, (unsigned char *)&tempBuf[0]);
for(unsigned int i = 0; i < qw25sectorSize; ++i) tempBuf[i] = 0x00;
//unsigned int i = 5;//qw25sectorSize;
w25QSPIreadSector(testSector, (unsigned char *)&tempBuf[0]);
printf("In %08X\r\n", (unsigned int)(*bD));
printf("2n %08X\r\n", (unsigned int)(*(bD+1)));
printf("3n %08X\r\n", (unsigned int)(*(bD+687)));
printf("4n %08X\r\n", (unsigned int)(*(bD+3)));
//for(unsigned int i = 0; i < qw25sectorSize; ++i) tempBuf[i] = 0x00;
//unsigned int i = qw25sectorSize;
w25QSPIreadSector(testSector, (unsigned char *)&tempBuf[0]);
printf("In %08X\r\n", (unsigned int)(*bD));
printf("2n %08X\r\n", (unsigned int)(*(bD+1)));
printf("3n %08X\r\n", (unsigned int)(*(bD+687)));
printf("4n %08X\r\n", (unsigned int)(*(bD+3)));
}
```
Ты просто монстр 
Уважуха!
1 лайк
А что за прикол с последним кодом? Какие-то «порно-ограничения»? По возрасту? Раз 15 обновлял - одно и тоже:
Я тоже, пару раз тыкнул, муар пропал.
1 лайк
Волшебник блин, только не продавай «волшебные бобы» малолетним девочкам ))))
ЗЫ: А почему такое вообще? Вопрос открытый. Может даже в тему работы форума?
тест
Тест пройден.
Похоже @andycat напорнокодил 
1 лайк
Я с телефона как то криво вставил, потому и такой результат, какое то полу скрытое отображение.
Обновил свой пост STM32CubeIDE (вопросы и ответы) - #1159 от пользователя BOOM чтобы было понятнее о чем я )))
@толстый перестань форум ломать
2 лайка