/*
 25.10.2020 ad0x0
 */
#include "RF24.h"
//#include "../ad0x0_spi2.h"
#include "../usart/ad0x0_usart.h"
#include "../spi/ad0x0_spi_ext.h"
#include <string.h>

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//хз, если я хочу записывать пачкой, то после чтения надо делать memcpy кроме 1го байта
//volatile ad0x0_nrf24_spi_regs_t r_spi_regs;
//volatile ad0x0_nrf24_regs_t r_regs;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#define AD0X0_RF24_REG_POST_READ

//void ce(uint8_t level){	HAL_GPIO_WritePin(AD_NFR24_CE_GPIO_Port, AD_NFR24_CE_Pin, (level ? GPIO_PIN_SET : GPIO_PIN_RESET));	}

enum{
	xNRF24_READALL,
	xNRF24_READALL_LOOP,
	xNRF24_CE_HIGH,
	xNRF24_CE_LOW
}ad0x0_regs_cb_t;

void	cb_rf24_set_ce(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	HAL_GPIO_WritePin(p_ext->user_pointer1, p_ext->user_data0, _sf_id ? GPIO_PIN_SET : GPIO_PIN_RESET);
}

void	rf24_set_ce(rf24_spi_regs_t *p, uint8_t _isHigh){
	uint8_t h_ext;
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	p->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди

	p_spi_ext_t->sf_id=_isHigh;
	p_spi_ext_t->user_data0 = p->CE_Pin;
	p_spi_ext_t->user_pointer1 = p->CE_GPIO_Port;
	p_spi_ext_t->_p_post_cb_func = cb_rf24_set_ce;
		
	p->ad0x0_spi_push(ADQS_USE_EXT,h_ext);
	
}

//init_spi_reg без s... s как доллар, как 1с.. как ass.. так ладно
void init_spi_reg(rf24_spi_regs_t *p,p_rf24_spi_REG_t preg,uint8_t _radr){
	preg->pspi=p;
	preg->radr=_radr;
	preg->so=1;
}

void init_spi_reg5(rf24_spi_regs_t *p,p_rf24_spi_REG5_t preg,uint8_t _radr){
	preg->pspi=p;
	preg->radr=_radr;
	preg->so=5;
}

void init_spi_regs(rf24_spi_regs_t *p){
	memset((void*)p,0,sizeof(rf24_spi_regs_t));
	init_spi_reg(p, &p->_CONFIG,0x0);
	init_spi_reg(p, &p->_EN_AA,0x1);
	init_spi_reg(p, &p->_EN_RXADDR, 0x2);
	init_spi_reg(p, &p->_SETUP_AW, 0x3);
	init_spi_reg(p, &p->_SETUP_RETR, 0x4);
	init_spi_reg(p, &p->_RF_CH, 0x5);
	init_spi_reg(p, &p->_RF_SETUP, 0x6);
	init_spi_reg(p, &p->_STATUS, 0x7);
	init_spi_reg(p, &p->_OBSERVE_TX, 0x8);
	init_spi_reg(p, &p->_RPD, 0x9);
	init_spi_reg5(p, &p->_RX_ADDR_P0,0xA);

	init_spi_reg5(p, &p->_RX_ADDR_P1,0xB);
	init_spi_reg(p, &p->_RX_ADDR_P2, 0xC);
	init_spi_reg(p, &p->_RX_ADDR_P3, 0xD);
	init_spi_reg(p, &p->_RX_ADDR_P4, 0xE);
	init_spi_reg(p, &p->_RX_ADDR_P5, 0xF);
	init_spi_reg5(p, &p->_TX_ADDR, 0x10);
	
	init_spi_reg(p, &p->_RX_PW_P0, 0x11);
	init_spi_reg(p, &p->_RX_PW_P1, 0x12);
	init_spi_reg(p, &p->_RX_PW_P2, 0x13);
	init_spi_reg(p, &p->_RX_PW_P3, 0x14);
	init_spi_reg(p, &p->_RX_PW_P4, 0x15);

	init_spi_reg(p, &p->_RX_PW_P5, 0x16);
	
	init_spi_reg(p, &p->_FIFO_STATUS, 0x17);

	init_spi_reg(p, &p->_DYNPD, 0x1C);
	init_spi_reg(p, &p->_FEATURE, 0x1D);
	
	init_spi_reg(p, &p->_R_RX_PL_WID, R_RX_PL_WID);
	
	

}

void rf24_init_spi_regs(rf24_spi_regs_t *p){
	init_spi_regs(p);
}

void	cb_read_all_regs(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	read_all_regs_postprocess(p_ext->user_pointer0,p_ext->user_pointer1);			
}
void	read_all_regs(rf24_spi_regs_t *p_spi_regs, rf24_regs_t *pregs){
read_register(&p_spi_regs->_CONFIG);
read_register(&p_spi_regs->_EN_AA);
read_register(&p_spi_regs->_EN_RXADDR);
read_register(&p_spi_regs->_FIFO_STATUS);
read_register(&p_spi_regs->_OBSERVE_TX);

read_register(&p_spi_regs->_RF_CH);
read_register(&p_spi_regs->_RF_SETUP);
read_register(&p_spi_regs->_RPD);
read_register5(&p_spi_regs->_RX_ADDR_P0);
read_register5(&p_spi_regs->_RX_ADDR_P1);

read_register(&p_spi_regs->_RX_ADDR_P2);
read_register(&p_spi_regs->_RX_ADDR_P3);
read_register(&p_spi_regs->_RX_ADDR_P4);
read_register(&p_spi_regs->_RX_ADDR_P5);
read_register(&p_spi_regs->_RX_PW_P0);

read_register(&p_spi_regs->_RX_PW_P1);
read_register(&p_spi_regs->_RX_PW_P2);
read_register(&p_spi_regs->_RX_PW_P3);
read_register(&p_spi_regs->_RX_PW_P4);
read_register(&p_spi_regs->_RX_PW_P5);

read_register(&p_spi_regs->_SETUP_AW);
read_register(&p_spi_regs->_SETUP_RETR);
read_register(&p_spi_regs->_STATUS);
read_register5(&p_spi_regs->_TX_ADDR);
read_register(&p_spi_regs->_DYNPD);

read_register(&p_spi_regs->_FEATURE);
read_register(&p_spi_regs->_R_RX_PL_WID);
	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	/*а вот ща очень внимательно!!!!!! вот как делать не рекомендуется*/
	uint8_t h_ext;
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	p_spi_regs->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди
	p_spi_ext_t->_p_post_cb_func = cb_read_all_regs;
	p_spi_ext_t->user_pointer0=p_spi_regs;
	p_spi_ext_t->user_pointer1=pregs;
	p_spi_regs->ad0x0_spi_push(ADQS_USE_EXT,h_ext);
	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	//ad0x0_spi2_push_ext_setfunc(xNRF24_READALL,ad0x0_regs_cb);
}

void	read_all_regs_postprocess(rf24_spi_regs_t *p_spi_regs,rf24_regs_t *pregs){
	//не надо срать кирпичами про фор и как круто в одном цикле все перенести,
	//мож так длиннее, зато так все понятно -//
	pregs->_CONFIG = p_spi_regs->_CONFIG.value;
	pregs->_EN_AA = p_spi_regs->_EN_AA.value;
	pregs->_EN_RXADDR = p_spi_regs->_EN_RXADDR.value;
	pregs->_FIFO_STATUS = p_spi_regs->_FIFO_STATUS.value;
	pregs->_OBSERVE_TX = p_spi_regs->_OBSERVE_TX.value;
	
	pregs->_RF_CH = p_spi_regs->_RF_CH.value;	
	pregs->_RF_SETUP = p_spi_regs->_RF_SETUP.value;
	pregs->_RPD = p_spi_regs->_RPD.value;
	memcpy((void*) pregs->_RX_ADDR_P0, (void*)p_spi_regs->_RX_ADDR_P0.value, 5);
	memcpy((void*) pregs->_RX_ADDR_P1, (void*)p_spi_regs->_RX_ADDR_P1.value, 5);
	
	pregs->_RX_ADDR_P2 = p_spi_regs->_RX_ADDR_P2.value;
	pregs->_RX_ADDR_P3 = p_spi_regs->_RX_ADDR_P3.value;
	pregs->_RX_ADDR_P4 = p_spi_regs->_RX_ADDR_P4.value;
	pregs->_RX_ADDR_P5 = p_spi_regs->_RX_ADDR_P5.value;
	pregs->_RX_PW_P0 = p_spi_regs->_RX_PW_P0.value;
	
	pregs->_RX_PW_P1 = p_spi_regs->_RX_PW_P1.value;
	pregs->_RX_PW_P2 = p_spi_regs->_RX_PW_P2.value;
	pregs->_RX_PW_P3 = p_spi_regs->_RX_PW_P3.value;
	pregs->_RX_PW_P4 = p_spi_regs->_RX_PW_P4.value;
	pregs->_RX_PW_P5 = p_spi_regs->_RX_PW_P5.value;
	
	pregs->_SETUP_AW = p_spi_regs->_SETUP_AW.value;
	pregs->_SETUP_RETR = p_spi_regs->_SETUP_RETR.value;
	pregs->_STATUS = p_spi_regs->_STATUS.value;
	memcpy((void*) pregs->_TX_ADDR, (void*)p_spi_regs->_TX_ADDR.value, 5);
	pregs->_DYNPD = p_spi_regs->_DYNPD.value;
	
	pregs->_FEATURE= p_spi_regs->_FEATURE.value;
}

void spi_cmd(rf24_spi_regs_t *p, uint8_t _val)
{
uint8_t h_ext;
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	p->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди
	p_spi_ext_t->user_data0=_val;
	p_spi_ext_t->pbuf_count=1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	p->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
}

void	cb_read_register(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(((ad0x0_spi_ext_t*)p_spi_ext_t)->user_pointer1);
	preg->value = (uint8_t)(p_ext->user_data0>>8);
}

void read_register(rf24_spi_REG_t *preg_radr)
{
uint8_t h_ext;
	if(preg_radr->so!=1)ad0x0_err();
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	preg_radr->pspi->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди
	p_spi_ext_t->user_data0=preg_radr->radr | (uint32_t)0xFF<<8;
	p_spi_ext_t->user_pointer1=preg_radr;
	p_spi_ext_t->_p_post_cb_func = cb_read_register;
	
	p_spi_ext_t->pbuf_count=preg_radr->so+1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	
	/*preg_radr->wr = preg_radr->radr | 0x0;//ПРОВЕРИТЬ!!!!!!!!
	preg_radr->value=0xFF;
	ad0x0_spi2_push_txrx_dma_ext(&preg_radr->wr,&preg_radr->wr,1+preg_radr->so);*/
}

void	cb_read_register5(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG5_t *preg5=(rf24_spi_REG5_t*)(((ad0x0_spi_ext_t*)p_spi_ext_t)->user_pointer1);
	//preg->value = (uint8_t)(p_ext->user_data0>>8);
	memcpy(preg5->value,((uint8_t*)(&p_ext->user_data0))+1,preg5->so);
}

void read_register5(rf24_spi_REG5_t *preg_radr)
{
uint8_t h_ext;
	if(preg_radr->so!=5)ad0x0_err();
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	preg_radr->pspi->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди
	//да я знаю, что через Ж... но мы 3 байта адреса читаем в дата0,и два в дата1
	p_spi_ext_t->user_data0=preg_radr->radr;// | (uint32_t)0xFF<<8;
	p_spi_ext_t->user_pointer1=preg_radr;
	p_spi_ext_t->_p_post_cb_func = cb_read_register5;
	
	p_spi_ext_t->pbuf_count=preg_radr->so+1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);	
}

void	cb_write_register2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t);
void	cb_write_register(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(p_ext->user_pointer1);
	preg->value = _sf_id;	
	#ifdef AD0X0_RF24_REG_POST_READ
	p_ext->reference_count++;
	p_ext->user_data0=preg->radr;
	p_ext->user_pointer1=preg;
	p_ext->_p_post_cb_func = cb_write_register2;
	#endif
}
#ifdef AD0X0_RF24_REG_POST_READ
void	cb_write_register2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(p_ext->user_pointer1);
	preg->value = (uint8_t)(p_ext->user_data0>>8);
	
	//чтобы сбросить бит, например TX_DS, надо записать в него 1.
	//по этому то что мы пишим будет иногда разнИца с тем, что читаем
	//здесь пока что перечитываем чисто в отладочных целях
	if(preg->value!=_sf_id){
	//	ad0x0_err();
	}
}
#endif

void write_register(rf24_spi_REG_t *preg_radr, uint8_t _val)
{
	//*пишим, затем читаем и сравниваем записанное с прочитанным*/
uint8_t h_ext;
	if(preg_radr->so!=1)ad0x0_err();
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	preg_radr->pspi->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди

	p_spi_ext_t->sf_id=_val;
	p_spi_ext_t->user_data0=(preg_radr->radr | 0x20) | (uint32_t)_val<<8;
	p_spi_ext_t->user_pointer1=preg_radr;
	p_spi_ext_t->_p_post_cb_func = cb_write_register;
	
	p_spi_ext_t->pbuf_count=preg_radr->so+1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	/*я не просто так делал проверку записанного... отловились неочевидные ошибки*/	
	#ifdef AD0X0_RF24_REG_POST_READ
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	#endif
}
//!5555555555555555555555555555555555555555555555
void	cb_write_register5_2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t);
void	cb_write_register5(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG5_t *preg5=(rf24_spi_REG5_t*)(p_ext->user_pointer1);
	
//	memcpy(preg5->value,((uint8_t*)(&p_ext->user_data0))+1,preg5->so);
	#ifdef AD0X0_RF24_REG_POST_READ
	p_ext->reference_count++;
	p_ext->user_data0=preg5->radr;
	p_ext->user_pointer1=preg5;
	p_ext->_p_post_cb_func = cb_write_register5_2;
	#endif
}
#ifdef AD0X0_RF24_REG_POST_READ
void	cb_write_register5_2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	rf24_spi_REG5_t *preg5=(rf24_spi_REG5_t*)(p_ext->user_pointer1);
	//preg->value = (uint8_t)(p_ext->user_data0>>8);
	memcpy(preg5->value,((uint8_t*)(&p_ext->user_data0))+1,preg5->so);
}
#endif

void write_register5(rf24_spi_REG5_t *preg_radr5, uint8_t *_buf5)
{
	//*пишим, затем читаем и сравниваем записанное с прочитанным*/
uint8_t h_ext;
	if(preg_radr5->so!=5)ad0x0_err();
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;
	preg_radr5->pspi->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди

	//p_spi_ext_t->sf_id=_val;
	p_spi_ext_t->user_data0=preg_radr5->radr | 0x20;
	//сохраняем значение буфера, наглейшим образом затирая часть p_spi_ext_t->user_data1
	memcpy(((uint8_t*)(&p_spi_ext_t->user_data0))+1,_buf5,preg_radr5->so);
	p_spi_ext_t->user_pointer1=preg_radr5;
	p_spi_ext_t->_p_post_cb_func = cb_write_register5;
	
	p_spi_ext_t->pbuf_count=preg_radr5->so+1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	preg_radr5->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	/*я не просто так делал проверку записанного... отловились неочевидные ошибки*/	
	#ifdef AD0X0_RF24_REG_POST_READ
	preg_radr5->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	#endif
}

void	cb_write_register_bit(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t);
void	cb_write_register_bit2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t);
#ifdef AD0X0_RF24_REG_POST_READ
void	cb_write_register_bit3(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t);
#endif

void	cb_write_register_bit(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;
	//ad0x0_spi_ext_t *p_ext1=ad0x0_spi_ext_get_pdesc(_sf_id);
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(p_ext->user_pointer1);
	preg->value =  (uint8_t)(p_ext->user_data0>>8);//прочитанный байт
	preg->value &= (uint8_t)(p_ext->user_data0>>24);//_and_mask
	preg->value |= (uint8_t)(p_ext->user_data0>>16);//_or_bits
	//модифицируем ячейку под следующую команду
	//preg->radr нужен новый, т.к. старый затерт записью сраного STATUS-регистра
	p_ext->user_data0 = (uint32_t)preg->value<<8 | (preg->radr | 0x20);
	p_ext->reference_count++;
	p_ext->_p_post_cb_func = cb_write_register_bit2;//тока теперь другой колбэк
}

void	cb_write_register_bit2(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;	
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(p_ext->user_pointer1);
	#ifdef AD0X0_RF24_REG_POST_READ
	//регистр записан, модифицируем под чтение с проверкой
	p_ext->reference_count++;//продлить жизнь на 1 цикл
	p_ext->_p_post_cb_func = cb_write_register_bit3;//тока теперь другой колбэк
	//p_ext->user_data0 &=0xFFFFFF00;//пихаем значения для операции чтения
	p_ext->user_data0 = preg->radr;	
	#endif

}

#ifdef AD0X0_RF24_REG_POST_READ
void	cb_write_register_bit3(uint8_t _sf_id,ad0x0_spi_desc_s *pdspi,void *p_spi_ext_t){
	ad0x0_spi_ext_t *p_ext=(ad0x0_spi_ext_t*)p_spi_ext_t;	
	rf24_spi_REG_t *preg=(rf24_spi_REG_t*)(p_ext->user_pointer1);
	//регистр прочитан
	preg->value =  (uint8_t)(p_ext->user_data0>>8);
	//p_ext->reference_count++; все! жизнь не продляем, ее завалит построцесс
	//if(preg->value_r !=  (uint8_t)(p_ext->user_data0>>8)){		ad0x0_err();	}
}
#endif

void write_register_bits(rf24_spi_REG_t *preg_radr, uint8_t _or_bits, uint8_t _and_mask)
{
	if(preg_radr->so!=1)ad0x0_err();
	//что б понять, что тут ха херня, я пишу комменты для себя
	uint8_t h_ext;	
	ad0x0_spi_ext_t *p_spi_ext_t=NULL;	
	preg_radr->pspi->ad0x0_spi_get_ext_async2(&h_ext,(void**)&p_spi_ext_t);//получить ячейку, ассоциированную с командой в очереди
	//дальше полный изврат
	
	//читаем значение регистра и модифицируем, используя 1ю ячейку
	//p_spi_ext_t->sf_id=h_ext1;//ячейка для слудующей команды SPI, сюда положим модифицировнное значение регистра
	p_spi_ext_t->user_data0=preg_radr->radr | (uint32_t)0xFF00 | (uint32_t)_or_bits<<16 | (uint32_t)_and_mask<<24;
	p_spi_ext_t->user_pointer1=preg_radr;
	p_spi_ext_t->_p_post_cb_func = cb_write_register_bit;
	
	p_spi_ext_t->pbuf_count=preg_radr->so+1;
	p_spi_ext_t->pbuf_rx=p_spi_ext_t->pbuf_tx=(uint8_t*)&p_spi_ext_t->user_data0;
	p_spi_ext_t->p_pre_SetTXRXBuf=EXT_SetTXRXBuf;
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);

	/*если сейчас, поставить точку останова и прийти сюда,
	то preg_radr->value еще не будет нашим прочитанным из
	предыдущего пуша, т.к. он еще не выполнился
	То что нам нужно - это значение по адресу &preg_radr->value
	По этому мы вроде должны оперировать адресами, а не значениями
	Однако, в коллбэках у нас будут значения, по этому путем подмены 
	указателей на коллбэки мы одной межкомандной-проститучной ячейкой
	выполним чтение-модификацию-запись-проверку
	31.10.2020 - нахер проверку
	*/
	
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	#ifdef AD0X0_RF24_REG_POST_READ
	preg_radr->pspi->ad0x0_spi_push(ADQS_TXRX_PBUF_DMA_EXT,h_ext);
	#endif
}