unsigned char ee_read(unsigned int BufferOffset)
{
unsigned char temp;
unsigned char temp2[1]={0xff};
bcm2835_gpio_write(PIN_CS, LOW); /*must be called*/
delay_ms(500);
bcm2835_spi_transfer(0xD4);
delay_ms(50);
bcm2835_spi_transfer(0xff);
delay_ms(50);
bcm2835_spi_transfer((unsigned char)(BufferOffset>>8));
delay_ms(50);
bcm2835_spi_transfer((unsigned char)BufferOffset);
delay_ms(50);
bcm2835_spi_transfer(0xff);
delay_ms(50);
bcm2835_spi_transfern(temp2,1);
delay_ms(50);
bcm2835_gpio_write(PIN_CS, HIGH); /*must be called*/
delay_ms(300);
return temp2[0];
}
u16 get_touch_data(u8 cmd)
{
/* u8 tmp1,tmp2;
u16 tmp;
bcm2835_spi_transfer(cmd);
tmp1=bcm2835_spi_transfer(0x00);
printf("tmp1: %d ",tmp1);
tmp2=bcm2835_spi_transfer(0x00);
printf("tmp2: %d ",tmp2);
tmp=((u16)(tmp1)<<5 | (u16)(tmp2)>>3 );
printf("tmp: %d ",tmp);
delayMicroseconds(50);
return (tmp);*/
unsigned int NUMH , NUML;
unsigned int Num;
dis_lcd();//LCD_CS_H()
en_touch();//TOUCH_nCS_L();
delayMicroseconds(2);
bcm2835_spi_transfer(cmd);
delayMicroseconds(2); // ÑÓʱµÈ´ýת»»Íê³É
NUMH=bcm2835_spi_transfer(0x00);//printf("tmp1: %d ",NUMH);
NUML=bcm2835_spi_transfer(0x00);//printf("tmp2: %d ",NUML);
Num=((NUMH)<<8)+NUML;
Num>>=4; // Ö»Óиß12λÓÐЧ.
dis_touch();//TOUCH_nCS_H();
//printf("tmp2: %d ",Num);
return(Num);
}
quint8 QRF24::getDynamicPayloadSize()
{
quint8 result = 0;
bcm2835_spi_transfer( R_RX_PL_WID );
result = bcm2835_spi_transfer(0xff);
return result;
}
void QRF24::writeAckPayload(quint8 pipe, const void* buf, quint8 len)
{
const quint8* current = reinterpret_cast<const quint8*>(buf);
bcm2835_spi_transfer( W_ACK_PAYLOAD | ( pipe & 0b111 ) );
const quint8 max_payload_size = 32;
quint8 data_len = qMin(len,max_payload_size);
while ( data_len-- )
bcm2835_spi_transfer(*current++);
}
void write_DAC8532(uint8_t channel, uint16_t Data) {
bcm2835_gpio_write(SPI_CS, HIGH);
bcm2835_gpio_write(SPI_CS, LOW);
bcm2835_spi_transfer(channel);
bcm2835_spi_transfer((Data >> 8));
bcm2835_spi_transfer((Data & 0xff));
printf("write dac8532 = %d ", Data>>8);
printf(" %d \n", Data& 0xff8);
bcm2835_gpio_write(SPI_CS, HIGH);
}
void lcm_clear()
{
int i;
unsigned char page;
for (page=0; page<8; page++)
{
lcm_set_command();
bcm2835_spi_transfer(0xB0 + page);
bcm2835_spi_transfer(0x01);
bcm2835_spi_transfer(0x10);
lcm_set_data();
for (i=0; i<128; i++)
bcm2835_spi_transfer(0);
}
}
int spi_writeBytes(uint8_t *data, unsigned int len) {
/*
uint8_t v[16];
data[len] = CRC8((unsigned char*)(data),len);
len++;
bcm2835_spi_transfernb((char*)data,(char*)v,len);
for (unsigned int i=0;i<len;i++) {
if (!t_start && v[i]!=0) t_start=true; //looking for the first non-zero byte which indicates start of a packet
if (t_start) //we have found begining of a transfer
if (_spi_addByte(v[i])) t_start = false;
//we have consumed the packet hence we will be waiting for a new start byte
}
*/
uint8_t v;
data[len] = CRC8((unsigned char*)(data),len);
len++;
for (unsigned int i=0;i<len;i++) {
v = bcm2835_spi_transfer(data[i]);
if (!t_start && v!=0) t_start=true; //looking for the first non-zero byte which indicates start of a packet
if (t_start) //we have found begining of a transfer
if (_spi_addByte(v)) t_start = false;
//we have consumed the packet hence we will be waiting for a new start byte
bcm2835_delay(1);
}
return ret;
}
void lcm_image(unsigned char *imgdata)
{
unsigned char *p;
int i, j;
p = imgdata;
for (i=0; i<8; i++) {
lcm_set_command();
bcm2835_spi_transfer(0xB0 + i);
bcm2835_spi_transfer(0x01);
bcm2835_spi_transfer(0x10);
lcm_set_data();
for (j=0; j<128; j++) {
bcm2835_spi_transfer(*p++);
}
}
}
int main(int argc, char **argv)
{
// If you call this, it will not actually access the GPIO
// Use for testing
// bcm2835_set_debug(1);
if (!bcm2835_init())
{
return 1;
}
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0); // The default
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536); // The default
bcm2835_spi_chipSelect(BCM2835_SPI_CS0); // The default
bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW); // the default
int i;
for( i = 0; i < 100; i++ )
{
// Send a byte to the slave and simultaneously read a byte back from the slave
// If you tie MISO to MOSI, you should read back what was sent
uint8_t data = bcm2835_spi_transfer(i);
printf("Wrote: %02X Read from SPI: %02X\n", i, data);
}
bcm2835_spi_end();
bcm2835_close();
return 0;
}
uint8_t RF24::flush_tx(void)
{
uint8_t status;
status = bcm2835_spi_transfer( FLUSH_TX );
return status;
}
quint8 QRF24::flushTx()
{
quint8 status;
status = bcm2835_spi_transfer( FLUSH_TX );
return status;
}
void post_data(u16 data)
{
en_lcd();
bcm2835_spi_transfer((u8)(data>>8));
//delayMicroseconds(12);
bcm2835_spi_transfer((u8)(data));
//delayMicroseconds(12);
}
quint8 QRF24::getStatus()
{
quint8 status;
status = bcm2835_spi_transfer( NOP );
return status;
}
uint8_t RF24::get_status(void)
{
uint8_t status;
status = bcm2835_spi_transfer( NOP );
return status;
}
byte SPIClass::transfer(byte _data)
{
//Set which CS pin to use for next transfers
bcm2835_spi_chipSelect(BCM2835_SPI_CS0);
//Transfer 1 byte
byte data;
data = bcm2835_spi_transfer((uint8_t)_data);
return data;
}
void wr_dat(uchar out_data)
{
LCD_CS_CLR;
LCD_RS_SET;
bcm2835_spi_transfer(out_data);
LCD_CS_SET;
}
uint8_t SPICom::CS1_transfer(uint8_t send_data) {
if (chipSelect != BCM2835_SPI_CS1) {
bcm2835_spi_setClockDivider(clockCS1);
bcm2835_spi_chipSelect(BCM2835_SPI_CS1);
chipSelect = BCM2835_SPI_CS1;
}
return bcm2835_spi_transfer(send_data);
}
//uint8_t bcm2835_spi_transfer(uint8_t value);
/// Call bcm2835_spi_transfer with 1 parameters
/// \par Refer
/// \par Modify
void ope_spi_transfer(void)
{
uint8_t ret;
get_byte_code();
ret = bcm2835_spi_transfer( *((uint8_t *)(buff+1)) );
set_ope_code( OPE_SPI_TRANSFER );
set_byte_code( ret );
put_reply();
mark_sync();
}
void ee_write(unsigned int BufferOffset,unsigned char data)
{
unsigned char temp[]={0x84,0xff};
bcm2835_gpio_write(PIN_CS, LOW); /*must be called*/
delay_ms(500);
bcm2835_spi_writenb(temp,2);
delay_ms(50);
bcm2835_spi_transfer((unsigned char)(BufferOffset>>8));
delay_ms(50);
bcm2835_spi_transfer((unsigned char)BufferOffset);
delay_ms(50);
bcm2835_spi_transfer(data);
delay_ms(50);
bcm2835_gpio_write(PIN_CS, HIGH); /*must be called*/
delay_ms(300);
}
uint8_t SpiPlateformImplementation::writeRead(const uint8_t &data )
{
#ifdef TARGET_RASPBERRY_PI
return bcm2835_spi_transfer( data);
#elif defined __APPLE__
return 0;
#endif
}
uint8_t exchangeByte(uint8_t byte, unsigned int clock_period) {
/*
uint8_t value = 0;
for (int i = 7; i >= 0; --i) {
if (HIGH == exchangeBit(0x1 & (byte >> i), clock_period)) {
value |= 1 << i;
}
}
return value;
*/
return bcm2835_spi_transfer(byte);
}
static PyObject *
PyBCM2835_spi_transfer(PyObject *self, PyObject *args)
{
uint8_t value;
if (!PyArg_ParseTuple(args,"i",&value)) {
return NULL;
}
uint8_t rtn = bcm2835_spi_transfer(value);
return Py_BuildValue("i",rtn);
}
void main(int argc, char* argv)
{
/* Pour le debugging
1 == Print sur la console les operations des fonctions
0 == Comportement normal du programme */
bcm2835_set_debug(0);
/* Initialisation de la librairie */
if(bcm2835_close())
{
/* code d'initialisation bcm */
printf("Version de la librairie : %d", bcm2835_version());
if(bcm2835_spi_begin())
{
/* Initialisation de la SPI
Voir header pour valeurs */
bcm2835_spi_setClockDivider(CLK_SPEED);
bcm2835_spi_setDataMode(PI_MODE);
bcm2835_spi_setBitOrder(BIT_ORDER);
/* Selecte un CS pour le transfert de donnees */
bcm2835_spi_chipSelect(CS_SLAVE);
/* Test de transfert avec retour */
uint8_t ret;
ret = bcm2835_spi_transfer(5);
printf("Retour de l'Arduino : %d", ret);
/* Test de transfert sans retour */
bcm2835_spi_transfern("A", 1);
bcm2835_spi_end();
}
else
{
printf("Erreur de l'init de SPI\n");
}
bcm2835_close(void); /* Libere la memoire et ferme la librairie */
}
else
{
printf("Echec de l'ouverture de la librairie\n");
}
}
uint8_t SPICom::CS0_transfer(uint8_t send_data) {
if ((micros() - time) < 50) // Check that we haven't send anything for 50 [us]
usleep((micros() - time));
if (DEBUG)
cout << "Data sent: " << send_data << "\n";
time = micros();
if (chipSelect != BCM2835_SPI_CS0) {
bcm2835_spi_setClockDivider(clockCS0);
bcm2835_spi_chipSelect(BCM2835_SPI_CS0);
chipSelect = BCM2835_SPI_CS0;
}
uint8_t read_Data = bcm2835_spi_transfer(send_data);
if (DEBUG)
cout << "read data: " << read_Data << "\n";
return read_Data;
}
uint8_t RF24::get_status(void)
{
return bcm2835_spi_transfer( NOP );
}
inline void ArduiPi_OLED::fastI2Cwrite(uint8_t d) {
bcm2835_spi_transfer(d);
}
/**
*@brief Reads a byte of data from the SPI bus
*@return result Result of data written on SPI bus.
*/
unsigned char SPI_Read(void)
{
unsigned char data = bcm2835_spi_transfer(0xff);
return data;
}
/**
*@brief Writes a byte of data to the SPI bus
*@param data Byte data to write on bus
*@return result Result of data written on SPI bus.
*/
unsigned char SPI_Write(unsigned char data)
{
return bcm2835_spi_transfer(data);
}
void QRF24::toggleFeatures()
{
bcm2835_spi_transfer( ACTIVATE );
bcm2835_spi_transfer( 0x73 );
}
void Write_Max7219_byte(uchar DATA)
{
bcm2835_gpio_write(Max7219_pinCS,LOW);
bcm2835_spi_transfer(DATA);
}
