关于OLED iic驱动

只看该作者 · 2018-9-16 23:22

status_t I2C_MasterTransferBlocking(I2C_Type *base, i2c_master_transfer_t *xfer)
{
assert(xfer);

i2c_direction_t direction = xfer->direction;
status_t result = kStatus_Success;

/* Clear all status before transfer. */
I2C_MasterClearStatusFlags(base, kClearFlags);

/* Wait until ready to complete. */
while (!(base->S & kI2C_TransferCompleteFlag))
{
}

/* Change to send write address when it's a read operation with command. */
if ((xfer->subaddressSize > 0) && (xfer->direction == kI2C_Read))
{
      direction = kI2C_Write;
}

/* If repeated start is requested, send repeated start. */
if (xfer->flags & kI2C_TransferRepeatedStartFlag)
{
      result = I2C_MasterRepeatedStart(base, xfer->slaveAddress, direction);
}
else /* For normal transfer, send start. */
{
      result = I2C_MasterStart(base, xfer->slaveAddress, direction);
}

/* Return if error. */
if (result)
{
      return result;
}

/* Send subaddress. */
if (xfer->subaddressSize)
{
      do
      {
         /* Wait until data transfer complete. */
         while (!(base->S & kI2C_IntPendingFlag))
         {
         }

         /* Clear interrupt pending flag. */
         base->S = kI2C_IntPendingFlag;

         /* Check if there's transfer error. */
         result = I2C_CheckAndClearError(base, base->S);

         if (result)
         {
            if (result == kStatus_I2C_Nak)
            {
                  I2C_MasterStop(base);
            }

            return result;
         }

         xfer->subaddressSize--;
         base->D = ((xfer->subaddress) >> (8 * xfer->subaddressSize));

      } while ((xfer->subaddressSize > 0) && (result == kStatus_Success));

      if (xfer->direction == kI2C_Read)
      {
         /* Wait until data transfer complete. */
         while (!(base->S & kI2C_IntPendingFlag))
         {
         }

         /* Clear pending flag. */
         base->S = kI2C_IntPendingFlag;

         /* Check if there's transfer error. */
         result = I2C_CheckAndClearError(base, base->S);

         if (result)
         {
            if (result == kStatus_I2C_Nak)
            {
                  I2C_MasterStop(base);
            }

            return result;
         }

         /* Send repeated start and slave address. */
         result = I2C_MasterRepeatedStart(base, xfer->slaveAddress, kI2C_Read);

         /* Return if error. */
         if (result)
         {
            return result;
         }
      }
}

/* Wait until address + command transfer complete. */
while (!(base->S & kI2C_IntPendingFlag))
{
}

/* Check if there's transfer error. */
result = I2C_CheckAndClearError(base, base->S);

/* Return if error. */
if (result)
{
      if (result == kStatus_I2C_Nak)
      {
         I2C_MasterStop(base);
      }

      return result;
}

/* Transmit data. */
if ((xfer->direction == kI2C_Write) && (xfer->dataSize > 0))
{
      /* Send Data. */
      result = I2C_MasterWriteBlocking(base, xfer->data, xfer->dataSize);

      if (((result == kStatus_Success) && (!(xfer->flags & kI2C_TransferNoStopFlag))) || (result == kStatus_I2C_Nak))
      {
         /* Clear the IICIF flag. */
         base->S = kI2C_IntPendingFlag;

         /* Send stop. */
         result = I2C_MasterStop(base);
      }
}

/* Receive Data. */
if ((xfer->direction == kI2C_Read) && (xfer->dataSize > 0))
{
      result = I2C_MasterReadBlocking(base, xfer->data, xfer->dataSize);
}

return result;
}

只看该作者 · 2018-9-16 23:22

status_t I2C_MasterTransferNonBlocking(I2C_Type *base, i2c_master_handle_t *handle, i2c_master_transfer_t *xfer)
{
assert(handle);
assert(xfer);

status_t result = kStatus_Success;

/* Check if the I2C bus is idle - if not return busy status. */
if (handle->state != kIdleState)
{
      result = kStatus_I2C_Busy;
}
else
{
      /* Start up the master transfer state machine. */
      result = I2C_InitTransferStateMachine(base, handle, xfer);

      if (result == kStatus_Success)
      {
         /* Enable the I2C interrupts. */
         I2C_EnableInterrupts(base, kI2C_GlobalInterruptEnable);
      }
}

return result;
}

只看该作者 · 2018-9-16 23:23

void I2C_MasterTransferAbort(I2C_Type *base, i2c_master_handle_t *handle)
{
assert(handle);

/* Disable interrupt. */
I2C_DisableInterrupts(base, kI2C_GlobalInterruptEnable);

/* Reset the state to idle. */
handle->state = kIdleState;
}

只看该作者 · 2018-9-16 23:24

status_t I2C_MasterTransferGetCount(I2C_Type *base, i2c_master_handle_t *handle, size_t *count)
{
assert(handle);

if (!count)
{
return kStatus_InvalidArgument;
}

*count = handle->transferSize - handle->transfer.dataSize;

return kStatus_Success;
}

只看该作者 · 2018-9-16 23:24

void I2C_MasterTransferHandleIRQ(I2C_Type *base, void *i2cHandle)
{
assert(i2cHandle);

i2c_master_handle_t *handle = (i2c_master_handle_t *)i2cHandle;
status_t result = kStatus_Success;
bool isDone;

/* Clear the interrupt flag. */
base->S = kI2C_IntPendingFlag;

/* Check transfer complete flag. */
result = I2C_MasterTransferRunStateMachine(base, handle, &isDone);

if (isDone || result)
{
      /* Send stop command if transfer done or received Nak. */
      if ((!(handle->transfer.flags & kI2C_TransferNoStopFlag)) || (result == kStatus_I2C_Nak))
      {
         /* Ensure stop command is a need. */
         if ((base->C1 & I2C_C1_MST_MASK))
         {
            if (I2C_MasterStop(base) != kStatus_Success)
            {
                  result = kStatus_I2C_Timeout;
            }
         }
      }

      /* Restore handle to idle state. */
      handle->state = kIdleState;

      /* Disable interrupt. */
      I2C_DisableInterrupts(base, kI2C_GlobalInterruptEnable);

      /* Call the callback function after the function has completed. */
      if (handle->completionCallback)
      {
         handle->completionCallback(base, handle, result, handle->userData);
      }
}
}

只看该作者 · 2018-9-16 23:24

void I2C_SlaveInit(I2C_Type *base, const i2c_slave_config_t *slaveConfig)
{
assert(slaveConfig);

uint8_t tmpReg;

CLOCK_EnableClock(s_i2cClocks[I2C_GetInstance(base)]);

/* Configure addressing mode. */
switch (slaveConfig->addressingMode)
{
      case kI2C_Address7bit:
         base->A1 = ((uint32_t)(slaveConfig->slaveAddress)) << 1U;
         break;

      case kI2C_RangeMatch:
         assert(slaveConfig->slaveAddress < slaveConfig->upperAddress);
         base->A1 = ((uint32_t)(slaveConfig->slaveAddress)) << 1U;
         base->RA = ((uint32_t)(slaveConfig->upperAddress)) << 1U;
         base->C2 |= I2C_C2_RMEN_MASK;
         break;

      default:
         break;
}

/* Configure low power wake up feature. */
tmpReg = base->C1;
tmpReg &= ~I2C_C1_WUEN_MASK;
base->C1 = tmpReg | I2C_C1_WUEN(slaveConfig->enableWakeUp) | I2C_C1_IICEN(slaveConfig->enableSlave);

/* Configure general call & baud rate control & high drive feature. */
tmpReg = base->C2;
tmpReg &= ~(I2C_C2_SBRC_MASK | I2C_C2_GCAEN_MASK);
tmpReg |= I2C_C2_SBRC(slaveConfig->enableBaudRateCtl) | I2C_C2_GCAEN(slaveConfig->enableGeneralCall);
#if defined(FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION) && FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION
tmpReg &= ~I2C_C2_HDRS_MASK;
tmpReg |= I2C_C2_HDRS(slaveConfig->enableHighDrive);
#endif
base->C2 = tmpReg;
}

只看该作者 · 2018-9-16 23:25

void I2C_SlaveDeinit(I2C_Type *base)
{
/* Disable I2C module. */
I2C_Enable(base, false);

/* Disable I2C clock. */
CLOCK_DisableClock(s_i2cClocks[I2C_GetInstance(base)]);
}

只看该作者 · 2018-9-16 23:25

void I2C_SlaveGetDefaultConfig(i2c_slave_config_t *slaveConfig)
{
assert(slaveConfig);

/* By default slave is addressed with 7-bit address. */
slaveConfig->addressingMode = kI2C_Address7bit;

/* General call mode is disabled by default. */
slaveConfig->enableGeneralCall = false;

/* Slave address match waking up MCU from low power mode is disabled. */
slaveConfig->enableWakeUp = false;

#if defined(FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION) && FSL_FEATURE_I2C_HAS_HIGH_DRIVE_SELECTION
/* Default pin high drive is disabled. */
slaveConfig->enableHighDrive = false;
#endif

/* Independent slave mode baud rate at maximum frequency is disabled. */
slaveConfig->enableBaudRateCtl = false;

/* Enable the I2C peripheral. */
slaveConfig->enableSlave = true;
}

只看该作者 · 2018-9-16 23:26

status_t I2C_SlaveWriteBlocking(I2C_Type *base, const uint8_t *txBuff, size_t txSize)
{
return I2C_MasterWriteBlocking(base, txBuff, txSize);
}

void I2C_SlaveReadBlocking(I2C_Type *base, uint8_t *rxBuff, size_t rxSize)
{
/* Clear the IICIF flag. */
base->S = kI2C_IntPendingFlag;

/* Wait until the data register is ready for receive. */
while (!(base->S & kI2C_TransferCompleteFlag))
{
}

/* Setup the I2C peripheral to receive data. */
base->C1 &= ~(I2C_C1_TX_MASK);

while (rxSize--)
{
      /* Clear the IICIF flag. */
      base->S = kI2C_IntPendingFlag;

      /* Read from the data register. */
      *rxBuff++ = base->D;

      /* Wait until data transfer complete. */
      while (!(base->S & kI2C_IntPendingFlag))
      {
      }
}
}

只看该作者 · 2018-9-16 23:26

void I2C_SlaveTransferCreateHandle(I2C_Type *base,
                                 i2c_slave_handle_t *handle,
                                 i2c_slave_transfer_callback_t callback,
                                 void *userData)
{
assert(handle);

uint32_t instance = I2C_GetInstance(base);

/* Zero handle. */
memset(handle, 0, sizeof(*handle));

/* Set callback and userData. */
handle->callback = callback;
handle->userData = userData;

/* Save the context in global variables to support the double weak mechanism. */
s_i2cHandle[instance] = handle;

/* Save slave interrupt handler. */
s_i2cSlaveIsr = I2C_SlaveTransferHandleIRQ;

/* Enable NVIC interrupt. */
EnableIRQ(s_i2cIrqs[instance]);
}

只看该作者 · 2018-9-16 23:27

status_t I2C_SlaveTransferNonBlocking(I2C_Type *base, i2c_slave_handle_t *handle, uint32_t eventMask)
{
assert(handle);

/* Check if the I2C bus is idle - if not return busy status. */
if (handle->isBusy)
{
      return kStatus_I2C_Busy;
}
else
{
      /* Disable LPI2C IRQ sources while we configure stuff. */
      I2C_DisableInterrupts(base, kIrqFlags);

      /* Clear transfer in handle. */
      memset(&handle->transfer, 0, sizeof(handle->transfer));

      /* Record that we're busy. */
      handle->isBusy = true;

      /* Set up event mask. tx and rx are always enabled. */
      handle->eventMask = eventMask | kI2C_SlaveTransmitEvent | kI2C_SlaveReceiveEvent;

      /* Clear all flags. */
      I2C_SlaveClearStatusFlags(base, kClearFlags);

      /* Enable I2C internal IRQ sources. NVIC IRQ was enabled in CreateHandle() */
      I2C_EnableInterrupts(base, kIrqFlags);
}

return kStatus_Success;
}

只看该作者 · 2018-9-16 23:27

void I2C_SlaveTransferAbort(I2C_Type *base, i2c_slave_handle_t *handle)
{
assert(handle);

if (handle->isBusy)
{
      /* Disable interrupts. */
      I2C_DisableInterrupts(base, kIrqFlags);

      /* Reset transfer info. */
      memset(&handle->transfer, 0, sizeof(handle->transfer));

      /* Reset the state to idle. */
      handle->isBusy = false;
}
}

只看该作者 · 2018-9-17 09:18

status_t I2C_SlaveTransferGetCount(I2C_Type *base, i2c_slave_handle_t *handle, size_t *count)
{
assert(handle);

if (!count)
{
      return kStatus_InvalidArgument;
}

/* Catch when there is not an active transfer. */
if (!handle->isBusy)
{
      *count = 0;
      return kStatus_NoTransferInProgress;
}

/* For an active transfer, just return the count from the handle. */
*count = handle->transfer.transferredCount;

return kStatus_Success;
}

只看该作者 · 2018-9-17 09:18

void I2C_SlaveTransferHandleIRQ(I2C_Type *base, void *i2cHandle)
{
assert(i2cHandle);

uint16_t status;
bool doTransmit = false;
i2c_slave_handle_t *handle = (i2c_slave_handle_t *)i2cHandle;
i2c_slave_transfer_t *xfer;
volatile uint8_t dummy = 0;

/* Add this to avoid build warning. */
dummy++;

status = I2C_SlaveGetStatusFlags(base);
xfer = &(handle->transfer);

#ifdef I2C_HAS_STOP_DETECT
/* Check stop flag. */
if (status & kI2C_StopDetectFlag)
{
      I2C_MasterClearStatusFlags(base, kI2C_StopDetectFlag);

      /* Clear the interrupt flag. */
      base->S = kI2C_IntPendingFlag;

      /* Call slave callback if this is the STOP of the transfer. */
      if (handle->isBusy)
      {
         xfer->event = kI2C_SlaveCompletionEvent;
         xfer->completionStatus = kStatus_Success;
         handle->isBusy = false;

         if ((handle->eventMask & xfer->event) && (handle->callback))
         {
            handle->callback(base, xfer, handle->userData);
         }
      }

      return;
}
#endif /* I2C_HAS_STOP_DETECT */

#if defined(FSL_FEATURE_I2C_HAS_START_STOP_DETECT) && FSL_FEATURE_I2C_HAS_START_STOP_DETECT
/* Check start flag. */
if (status & kI2C_StartDetectFlag)
{
      I2C_MasterClearStatusFlags(base, kI2C_StartDetectFlag);

      /* Clear the interrupt flag. */
      base->S = kI2C_IntPendingFlag;

      xfer->event = kI2C_SlaveRepeatedStartEvent;

      if ((handle->eventMask & xfer->event) && (handle->callback))
      {
         handle->callback(base, xfer, handle->userData);
      }

      if (!(status & kI2C_AddressMatchFlag))
      {
         return;
      }
}
#endif /* FSL_FEATURE_I2C_HAS_START_STOP_DETECT */

/* Clear the interrupt flag. */
base->S = kI2C_IntPendingFlag;

/* Check NAK */
if (status & kI2C_ReceiveNakFlag)
{
      /* Set receive mode. */
      base->C1 &= ~(I2C_C1_TX_MASK | I2C_C1_TXAK_MASK);

      /* Read dummy. */
      dummy = base->D;

      if (handle->transfer.dataSize != 0)
      {
         xfer->event = kI2C_SlaveCompletionEvent;
         xfer->completionStatus = kStatus_I2C_Nak;
         handle->isBusy = false;

         if ((handle->eventMask & xfer->event) && (handle->callback))
         {
            handle->callback(base, xfer, handle->userData);
         }
      }
      else
      {
#ifndef I2C_HAS_STOP_DETECT
         xfer->event = kI2C_SlaveCompletionEvent;
         xfer->completionStatus = kStatus_Success;
         handle->isBusy = false;

         if ((handle->eventMask & xfer->event) && (handle->callback))
         {
            handle->callback(base, xfer, handle->userData);
         }
#endif /* !FSL_FEATURE_I2C_HAS_START_STOP_DETECT or !FSL_FEATURE_I2C_HAS_STOP_DETECT */
      }
}
/* Check address match. */
else if (status & kI2C_AddressMatchFlag)
{
      handle->isBusy = true;
      xfer->event = kI2C_SlaveAddressMatchEvent;

      if ((handle->eventMask & xfer->event) && (handle->callback))
      {
         handle->callback(base, xfer, handle->userData);
      }

      /* Slave transmit, master reading from slave. */
      if (status & kI2C_TransferDirectionFlag)
      {
         /* Change direction to send data. */
         base->C1 |= I2C_C1_TX_MASK;

         /* If we're out of data, invoke callback to get more. */
         if ((!xfer->data) || (!xfer->dataSize))
         {
            xfer->event = kI2C_SlaveTransmitEvent;

            if (handle->callback)
            {
                  handle->callback(base, xfer, handle->userData);
            }

            /* Clear the transferred count now that we have a new buffer. */
            xfer->transferredCount = 0;
         }

         doTransmit = true;
      }
      else
      {
         /* Slave receive, master writing to slave. */
         base->C1 &= ~(I2C_C1_TX_MASK | I2C_C1_TXAK_MASK);

         /* If we're out of data, invoke callback to get more. */
         if ((!xfer->data) || (!xfer->dataSize))
         {
            xfer->event = kI2C_SlaveReceiveEvent;

            if (handle->callback)
            {
                  handle->callback(base, xfer, handle->userData);
            }

            /* Clear the transferred count now that we have a new buffer. */
            xfer->transferredCount = 0;
         }

         /* Read dummy to release the bus. */
         dummy = base->D;
      }
}
/* Check transfer complete flag. */
else if (status & kI2C_TransferCompleteFlag)
{
      /* Slave transmit, master reading from slave. */
      if (status & kI2C_TransferDirectionFlag)
      {
         doTransmit = true;
      }
      else
      {
         /* Slave receive, master writing to slave. */
         uint8_t data = base->D;

         if (handle->transfer.dataSize)
         {
            /* Receive data. */
            *handle->transfer.data++ = data;
            handle->transfer.dataSize--;
            xfer->transferredCount++;
            if (!handle->transfer.dataSize)
            {
#ifndef I2C_HAS_STOP_DETECT
                  xfer->event = kI2C_SlaveCompletionEvent;
                  xfer->completionStatus = kStatus_Success;
                  handle->isBusy = false;

                  /* Proceed receive complete event. */
                  if ((handle->eventMask & xfer->event) && (handle->callback))
                  {
                     handle->callback(base, xfer, handle->userData);
                  }
#endif /* !FSL_FEATURE_I2C_HAS_START_STOP_DETECT or !FSL_FEATURE_I2C_HAS_STOP_DETECT */
            }
         }
      }
}
else
{
      /* Read dummy to release bus. */
      dummy = base->D;
}

/* Send data if there is the need. */
if (doTransmit)
{
      if (handle->transfer.dataSize)
      {
         /* Send data. */
         base->D = *handle->transfer.data++;
         handle->transfer.dataSize--;
         xfer->transferredCount++;
      }
      else
      {
         /* Switch to receive mode. */
         base->C1 &= ~(I2C_C1_TX_MASK | I2C_C1_TXAK_MASK);

         /* Read dummy to release bus. */
         dummy = base->D;

#ifndef I2C_HAS_STOP_DETECT
         xfer->event = kI2C_SlaveCompletionEvent;
         xfer->completionStatus = kStatus_Success;
         handle->isBusy = false;

         /* Proceed txdone event. */
         if ((handle->eventMask & xfer->event) && (handle->callback))
         {
            handle->callback(base, xfer, handle->userData);
         }
#endif /* !FSL_FEATURE_I2C_HAS_START_STOP_DETECT or !FSL_FEATURE_I2C_HAS_STOP_DETECT */
      }
}
}

只看该作者 · 2018-9-17 09:19

void I2C0_DriverIRQHandler(void)
{
I2C_TransferCommonIRQHandler(I2C0, s_i2cHandle[0]);
}

只看该作者 · 2018-9-17 09:19

#if (FSL_FEATURE_SOC_I2C_COUNT > 1)
void I2C1_DriverIRQHandler(void)
{
I2C_TransferCommonIRQHandler(I2C1, s_i2cHandle[1]);
}
#endif /* I2C COUNT > 1 */

#if (FSL_FEATURE_SOC_I2C_COUNT > 2)
void I2C2_DriverIRQHandler(void)
{
I2C_TransferCommonIRQHandler(I2C2, s_i2cHandle[2]);
}
#endif /* I2C COUNT > 2 */
#if (FSL_FEATURE_SOC_I2C_COUNT > 3)
void I2C3_DriverIRQHandler(void)
{
I2C_TransferCommonIRQHandler(I2C3, s_i2cHandle[3]);
}

1万 · 2018-10-9 10:36

OLED 是什么呀请问

1万 · 2018-10-9 11:32

晓伍发表于 2018-10-9 10:36
OLED 是什么呀请问

有机发光二极管(Organic Light-Emitting Diode, OLED)又称为有机电激光显示、有机发光半导体。由美籍华裔教授邓青云(Ching W. Tang)于1979年在实验室中发现。OLED显示技术具有自发光、广视角、几乎无穷高的对比度、较低耗电、极高反应速度等优点。但是，作为高端显示屏，价格上也会比液晶电视要贵。

1万 · 2018-10-9 12:39

非常感谢楼主分享

1万 · 2018-10-9 14:56

非常感谢楼主分享

关于OLED iic驱动

精英会员奖章

奔腾之江水

常驻人口

技术高手奖章

无冕之王奖章

经常做客