/* not very efficient, but simple */
void AccelerometerWrite(unsigned char Addr, unsigned char* pData, unsigned char Length)
{
EnableSmClkUser(ACCELEROMETER_USER);
xSemaphoreTake(AccelerometerMutex, portMAX_DELAY);
while (UCB1STAT & UCBBUSY);
AccelerometerBusy = 1;
LengthCount = Length;
Index = 0;
pAccelerometerData = pData;
/*
* enable transmit interrupt and
* setup for write and send the start condition
*/
ACCELEROMETER_IFG = 0;
ACCELEROMETER_CTL1 |= UCTR + UCTXSTT;
while (!(ACCELEROMETER_IFG & UCTXIFG));
/*
* clear transmit interrupt flag, enable interrupt,
* send the register address
*/
ACCELEROMETER_IFG = 0;
ACCELEROMETER_IE |= UCTXIE;
ACCELEROMETER_TXBUF = Addr;
while (AccelerometerBusy);
while (ACCELEROMETER_CTL1 & UCTXSTP);
DisableSmClkUser(ACCELEROMETER_USER);
xSemaphoreGive(AccelerometerMutex);
}
void SoftwareFllInit(void)
{
// Disable FLL loop control
__bis_SR_register(SCG0);
#if 0
TB0CTL = 0;
EnableSmClkUser(RESERVED_USER3);
// additional prescale by 8
TB0EX0 = TBIDEX__8;
// Start a timer to Re-adjust fll , using SMCLK in continous mode
// will interrupt on every input capture
TB0CTL = TBSSEL__SMCLK + MC__CONTINUOUS + TBIE + ID__8;
// 262.144 ms
// above / 0.9765625 = 268.43
ucs_dco_mod_saved = UCSCTL0 & MOD_MASK;
#endif
}
static void WriteTxBuffer(const tString *pBuf)
{
EnableSmClkUser(BT_DEBUG_UART_USER);
if (TimeStampEnabled) WriteTimeStamp();
while (*pBuf) WRITE_UART(*pBuf++);
/* wait until transmit is done */
while (UCA3STAT & UCBUSY);
DisableSmClkUser(BT_DEBUG_UART_USER);
}
static void WriteTxBuffer(tString * const pBuf)
{
unsigned char i = 0;
unsigned int LocalCount = TxCount;
/* if there isn't enough room in the buffer then characters are lost */
while ( pBuf[i] != 0 && LocalCount < TX_BUFFER_SIZE )
{
TxBuffer[WriteIndex] = pBuf[i++];
IncrementWriteIndex();
LocalCount++;
}
/* keep a sticky bit for lost characters */
if ( pBuf[i] != 0 )
{
gAppStats.DebugUartOverflow = 1;
}
/*
* update the count (which can be decremented in the ISR
* and start sending characters if the UART is currently idle
*/
if ( i > 0 )
{
portENTER_CRITICAL();
TxCount += i;
#if 0
if ( TxCount > TX_BUFFER_SIZE )
{
while(1);
}
#endif
if ( TxBusy == 0 )
{
EnableSmClkUser(BT_DEBUG_UART_USER);
UCA3TXBUF = TxBuffer[ReadIndex];
IncrementReadIndex();
TxBusy = 1;
TxCount--;
}
portEXIT_CRITICAL();
}
}
void EnableTermMode(unsigned char Enable)
{
if (Enable)
{
ReceiveCompleted = FALSE;
EnableSmClkUser(TERM_MODE_USER);
/* enable Rx interrupt */
UCA3IE |= UCRXIE;
}
else
{
UCA3IE &= ~UCRXIE;
DisableSmClkUser(TERM_MODE_USER);
}
// PrintF("%c EnTermMode", Enable ? OK : NOK);
}
static void EnableTestMode(void)
{
if ( !TestModeEnabled )
{
EnableSmClkUser(TEST_MODE_USER);
InitTestMode();
/* read any characters */
UCA3RXBUF;
UCA3IE |= UCRXIE;
TestModeEnabled = 1;
}
}
void ClearLcd(void)
{
EnableSmClkUser(LCD_USER);
LCD_CS_ASSERT();
LCD_SPI_UCBxTXBUF = LCD_CLEAR_CMD;
while (!(LCD_SPI_UCBxIFG & UCTXIFG));
LCD_SPI_UCBxTXBUF = 0x00;
while (!(LCD_SPI_UCBxIFG & UCTXIFG));
/* wait for shift to complete ( ~3 us ) */
while((LCD_SPI_UCBxSTAT & 0x01) != 0);
LCD_CS_DEASSERT();
DisableSmClkUser(LCD_USER);
}
void EnableSoftwareFll(void)
{
/* FLL loop control should already be disabled */
EnableSmClkUser(FLL_USER);
/* don't divide the clock */
TB0EX0 = 0;
/* Use TB0.6 CCI6B which is internally connected to ACLK in Capture on
* falling edge mode
*/
TB0CCTL6 = CM_2 + CCIS_1 + CAP + CCIE;
/* Start a timer to Re-adjust fll , using SMCLK in continuous mode
* will interrupt on every input capture
*/
TB0CTL = TBSSEL__SMCLK + MC__CONTINUOUS;
}
static void WriteTxBuffer(const tString * pBuf)
{
EnableSmClkUser(BT_DEBUG_UART_USER);
unsigned char i = 0;
while ( pBuf[i] != 0 )
{
/* writing buffer clears TXIFG */
UCA3TXBUF = pBuf[i++];
/* wait for transmit complete flag */
while( (UCA3IFG & UCTXIFG) == 0 );
}
/* wait until transmit is done */
while(UCA3STAT & UCBUSY);
DisableSmClkUser(BT_DEBUG_UART_USER);
}
/* not very efficient, but simple */
void OledWrite(unsigned char Command,unsigned char* pData,unsigned char Length)
{
if ( Length < 1 )
{
PrintString("Invalid OLED write Length\r\n");
return;
}
//OLED_I2C_CONFIG_FOR_PERIPHERAL_USE();
EnableSmClkUser(OLED_I2C_USER);
OledBusy = 1;
Count = Length;
Index = 0;
pOledData = pData;
/*
* enable transmit interrupt and
* setup for write and send the start condition
*/
OLED_I2C_IFG = 0;
OLED_I2C_CTL1 |= UCTR + UCTXSTT;
while(!(OLED_I2C_IFG & UCTXIFG));
/*
* clear transmit interrupt flag, enable interrupt,
* send the command first (data,command,or continuation)
*/
OLED_I2C_IFG = 0;
OLED_I2C_IE |= UCTXIE;
OLED_I2C_TXBUF = Command;
while(OledBusy);
while(OLED_I2C_CTL1 & UCTXSTP);
DisableSmClkUser(OLED_I2C_USER);
//OLED_I2C_CONFIG_FOR_SLEEP();
}
void AccelerometerReadSingle(unsigned char RegisterAddress, unsigned char* pData)
{
EnableSmClkUser(ACCELEROMETER_USER);
xSemaphoreTake(AccelerometerMutex, portMAX_DELAY);
/* wait for bus to be free */
while (UCB1STAT & UCBBUSY);
AccelerometerBusy = 1;
LengthCount = 1;
Index = 0;
pAccelerometerData = pData;
/* transmit address */
ACCELEROMETER_IFG = 0;
ACCELEROMETER_CTL1 |= UCTR + UCTXSTT;
while (!(ACCELEROMETER_IFG & UCTXIFG));
/* write register address */
ACCELEROMETER_IFG = 0;
ACCELEROMETER_TXBUF = RegisterAddress;
while (!(ACCELEROMETER_IFG & UCTXIFG));
/* send a repeated start (same slave address now it is a read command)
* read possible extra character from rxbuffer
*/
ACCELEROMETER_RXBUF;
ACCELEROMETER_IFG = 0;
ACCELEROMETER_IE |= UCRXIE;
ACCELEROMETER_CTL1 &= ~UCTR;
/* for a read of a single byte the stop must be sent while the byte is being
* received. If this is interrupted an extra byte may be read.
* however, it will be discarded during the next read
*/
if (LengthCount == 1)
{
/* errata usci30: prevent interruption of sending stop
* so that only one byte is read
* this requires 62 us @ 320 kHz, 51 @ 400 kHz
*/
portENTER_CRITICAL();
ACCELEROMETER_CTL1 |= UCTXSTT;
while (ACCELEROMETER_CTL1 & UCTXSTT);
ACCELEROMETER_CTL1 |= UCTXSTP;
portEXIT_CRITICAL();
}
else
{
ACCELEROMETER_CTL1 |= UCTXSTT;
}
/* wait until all data has been received and the stop bit has been sent */
while (AccelerometerBusy);
while (ACCELEROMETER_CTL1 & UCTXSTP);
Index = 0;
pAccelerometerData = NULL;
DisableSmClkUser(ACCELEROMETER_USER);
xSemaphoreGive(AccelerometerMutex);
}
static void Write(unsigned char Cmd, unsigned char *pBuffer, unsigned int Size)
{
EnableSmClkUser(LCD_USER);
LCD_CS_ASSERT();
#if LCD_DMA
LcdDmaBusy = 1;
/* send the lcd write command before starting the dma */
LCD_SPI_UCBxTXBUF = Cmd;
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
/* USCIB0 TXIFG is the DMA trigger
* DMACTL1 controls dma2 and [dma3]
*/
DMACTL1 = DMA2TSEL_19;
__data16_write_addr((unsigned short) &DMA2SA, (unsigned long) pBuffer);
__data16_write_addr((unsigned short) &DMA2DA, (unsigned long) &LCD_SPI_UCBxTXBUF);
DMA2SZ = Size;
/*
* single transfer, increment source address, source byte and dest byte,
* level sensitive, enable interrupt, clear interrupt flag
*/
DMA2CTL = DMADT_0 + DMASRCINCR_3 + DMASBDB + DMALEVEL + DMAIE;
/* start the transfer */
DMA2CTL |= DMAEN;
while(LcdDmaBusy);
#else
/* send the lcd write command */
LCD_SPI_UCBxTXBUF = Cmd;
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
for (unsigned int i = 0; i < Size; ++i)
{
LCD_SPI_UCBxTXBUF = pBuffer[i];
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
}
#endif
/* add one more dummy byte at the end */
LCD_SPI_UCBxTXBUF = 0x00;
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
/* wait for shift to complete ( ~3 us ) */
while((LCD_SPI_UCBxSTAT & 0x01) != 0);
LCD_SPI_UCBxTXBUF = LCD_STATIC_CMD;
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
LCD_SPI_UCBxTXBUF = 0x00;
while (!(LCD_SPI_UCBxIFG&UCTXIFG));
/* now the chip select can be deasserted */
LCD_CS_DEASSERT();
DisableSmClkUser(LCD_USER);
}
