/*
* File: KeyboardScanModule.c
*
* Code generated for Simulink model 'KeyboardScanModule'.
*
* Model version : 1.5
* Simulink Coder version : 8.14 (R2018a) 06-Feb-2018
* C/C++ source code generated on : Sat Jun 23 17:02:12 2018
*
* Target selection: ert.tlc
* Embedded hardware selection: ARM Compatible->ARM Cortex
* Code generation objectives:
* 1. Execution efficiency
* 2. Traceability
* Validation result: Not run
*/

#include "KeyboardScanModule.h"

/* Block signals and states (default storage) */
DW rtDW;

/* External outputs (root outports fed by signals with default storage) */
ExtY rtY;

/* Real-time model */
RT_MODEL rtM_;
RT_MODEL *const rtM = &rtM_;
static void rate_scheduler(void);

/*
* This function updates active task flag for each subrate.
* The function is called at model base rate, hence the
* generated code self-manages all its subrates.
*/
static void rate_scheduler(void)
{
/* Compute which subrates run during the next base time step. Subrates
* are an integer multiple of the base rate counter. Therefore, the subtask
* counter is reset when it reaches its limit (zero means run).
*/
(rtM->Timing.TaskCounters.TID[1])++;
if ((rtM->Timing.TaskCounters.TID[1]) > 2) {/* Sample time: [3.0s, 0.0s] */
rtM->Timing.TaskCounters.TID[1] = 0;
}
}

/* Model step function */
void KeyboardScanModule_step(void)
{
int32_T uyIdx;
int32_T currentOffset;
int32_T nSampsAtBot;
int32_T rtb_Add[9];
boolean_T rtb_RelationalOperator[9];
boolean_T rtb_TmpSignalConversionAtDelayI[9];
boolean_T rtb_Delay[9];
int32_T rtb_Switch[9];
uint8_T rtb_FixPtSum1;
boolean_T rtb_Buffer2[3];
boolean_T rtb_Buffer1[3];
boolean_T rtb_Buffer[3];
int32_T i;
int32_T rtb_Add_d;
if (rtM->Timing.TaskCounters.TID[1] == 0) {
for (i = 0; i < 9; i++) {
/* Sum: '<S1>/Add' incorporates:
* Constant: '<S1>/Constant3'
* Delay: '<S1>/Delay1'
*/
rtb_Add_d = rtDW.Delay1_DSTATE[i] + 1;

/* RelationalOperator: '<S1>/Relational Operator' incorporates:
* Constant: '<S1>/Constant2'
*/
rtb_RelationalOperator[i] = (10 > rtb_Add_d);

/* Delay: '<S1>/Delay' */
rtb_Delay[i] = rtDW.Delay_DSTATE[i];

/* Sum: '<S1>/Add' */
rtb_Add[i] = rtb_Add_d;
}
}

/* Buffer: '<S1>/Buffer2' incorporates:
* Constant: '<S1>/Constant'
* MultiPortSwitch: '<S1>/Multiport Switch'
*/
rtb_Add_d = 6;
uyIdx = rtDW.Buffer2_inBufPtrIdx;
if (6 - rtDW.Buffer2_inBufPtrIdx <= 1) {
for (i = 0; i < 6 - rtDW.Buffer2_inBufPtrIdx; i++) {
rtDW.Buffer2_CircBuf[rtDW.Buffer2_inBufPtrIdx + i] = false;
}

uyIdx = 0;
rtb_Add_d = rtDW.Buffer2_inBufPtrIdx;
}

for (i = 0; i < rtb_Add_d - 5; i++) {
rtDW.Buffer2_CircBuf[uyIdx + i] = false;
}

rtDW.Buffer2_inBufPtrIdx++;
if (rtDW.Buffer2_inBufPtrIdx >= 6) {
rtDW.Buffer2_inBufPtrIdx -= 6;
}

rtDW.Buffer2_bufferLength++;
if (rtDW.Buffer2_bufferLength > 6) {
rtDW.Buffer2_outBufPtrIdx = (rtDW.Buffer2_outBufPtrIdx +
rtDW.Buffer2_bufferLength) - 6;
if (rtDW.Buffer2_outBufPtrIdx > 6) {
rtDW.Buffer2_outBufPtrIdx -= 6;
}

rtDW.Buffer2_bufferLength = 6;
}

if (rtM->Timing.TaskCounters.TID[1] == 0) {
rtDW.Buffer2_bufferLength -= 3;
if (rtDW.Buffer2_bufferLength < 0) {
rtDW.Buffer2_outBufPtrIdx += rtDW.Buffer2_bufferLength;
if (rtDW.Buffer2_outBufPtrIdx < 0) {
rtDW.Buffer2_outBufPtrIdx += 6;
}

rtDW.Buffer2_bufferLength = 0;
}

uyIdx = 0;
currentOffset = rtDW.Buffer2_outBufPtrIdx;
if (rtDW.Buffer2_outBufPtrIdx < 0) {
currentOffset = rtDW.Buffer2_outBufPtrIdx + 6;
}

nSampsAtBot = 6 - currentOffset;
rtb_Add_d = 3;
if (6 - currentOffset <= 3) {
for (i = 0; i < 6 - currentOffset; i++) {
rtb_Buffer2[i] = rtDW.Buffer2_CircBuf[currentOffset + i];
}

uyIdx = 6 - currentOffset;
currentOffset = 0;
rtb_Add_d = 3 - nSampsAtBot;
}

for (i = 0; i < rtb_Add_d; i++) {
rtb_Buffer2[uyIdx + i] = rtDW.Buffer2_CircBuf[currentOffset + i];
}

rtDW.Buffer2_outBufPtrIdx = currentOffset + rtb_Add_d;
}

/* End of Buffer: '<S1>/Buffer2' */

/* Buffer: '<S1>/Buffer1' incorporates:
* Constant: '<S1>/Constant'
* MultiPortSwitch: '<S1>/Multiport Switch2'
*/
rtb_Add_d = 6;
uyIdx = rtDW.Buffer1_inBufPtrIdx;
if (6 - rtDW.Buffer1_inBufPtrIdx <= 1) {
for (i = 0; i < 6 - rtDW.Buffer1_inBufPtrIdx; i++) {
rtDW.Buffer1_CircBuf[rtDW.Buffer1_inBufPtrIdx + i] = false;
}

uyIdx = 0;
rtb_Add_d = rtDW.Buffer1_inBufPtrIdx;
}

for (i = 0; i < rtb_Add_d - 5; i++) {
rtDW.Buffer1_CircBuf[uyIdx + i] = false;
}

rtDW.Buffer1_inBufPtrIdx++;
if (rtDW.Buffer1_inBufPtrIdx >= 6) {
rtDW.Buffer1_inBufPtrIdx -= 6;
}

rtDW.Buffer1_bufferLength++;
if (rtDW.Buffer1_bufferLength > 6) {
rtDW.Buffer1_outBufPtrIdx = (rtDW.Buffer1_outBufPtrIdx +
rtDW.Buffer1_bufferLength) - 6;
if (rtDW.Buffer1_outBufPtrIdx > 6) {
rtDW.Buffer1_outBufPtrIdx -= 6;
}

rtDW.Buffer1_bufferLength = 6;
}

if (rtM->Timing.TaskCounters.TID[1] == 0) {
rtDW.Buffer1_bufferLength -= 3;
if (rtDW.Buffer1_bufferLength < 0) {
rtDW.Buffer1_outBufPtrIdx += rtDW.Buffer1_bufferLength;
if (rtDW.Buffer1_outBufPtrIdx < 0) {
rtDW.Buffer1_outBufPtrIdx += 6;
}

rtDW.Buffer1_bufferLength = 0;
}

uyIdx = 0;
currentOffset = rtDW.Buffer1_outBufPtrIdx;
if (rtDW.Buffer1_outBufPtrIdx < 0) {
currentOffset = rtDW.Buffer1_outBufPtrIdx + 6;
}

nSampsAtBot = 6 - currentOffset;
rtb_Add_d = 3;
if (6 - currentOffset <= 3) {
for (i = 0; i < 6 - currentOffset; i++) {
rtb_Buffer1[i] = rtDW.Buffer1_CircBuf[currentOffset + i];
}

uyIdx = 6 - currentOffset;
currentOffset = 0;
rtb_Add_d = 3 - nSampsAtBot;
}

for (i = 0; i < rtb_Add_d; i++) {
rtb_Buffer1[uyIdx + i] = rtDW.Buffer1_CircBuf[currentOffset + i];
}

rtDW.Buffer1_outBufPtrIdx = currentOffset + rtb_Add_d;
}

/* End of Buffer: '<S1>/Buffer1' */

/* Buffer: '<S1>/Buffer' incorporates:
* Constant: '<S1>/Constant'
* MultiPortSwitch: '<S1>/Multiport Switch3'
*/
rtb_Add_d = 6;
uyIdx = rtDW.Buffer_inBufPtrIdx;
if (6 - rtDW.Buffer_inBufPtrIdx <= 1) {
for (i = 0; i < 6 - rtDW.Buffer_inBufPtrIdx; i++) {
rtDW.Buffer_CircBuf[rtDW.Buffer_inBufPtrIdx + i] = false;
}

uyIdx = 0;
rtb_Add_d = rtDW.Buffer_inBufPtrIdx;
}

for (i = 0; i < rtb_Add_d - 5; i++) {
rtDW.Buffer_CircBuf[uyIdx + i] = false;
}

rtDW.Buffer_inBufPtrIdx++;
if (rtDW.Buffer_inBufPtrIdx >= 6) {
rtDW.Buffer_inBufPtrIdx -= 6;
}

rtDW.Buffer_bufferLength++;
if (rtDW.Buffer_bufferLength > 6) {
rtDW.Buffer_outBufPtrIdx = (rtDW.Buffer_outBufPtrIdx +
rtDW.Buffer_bufferLength) - 6;
if (rtDW.Buffer_outBufPtrIdx > 6) {
rtDW.Buffer_outBufPtrIdx -= 6;
}

rtDW.Buffer_bufferLength = 6;
}

if (rtM->Timing.TaskCounters.TID[1] == 0) {
rtDW.Buffer_bufferLength -= 3;
if (rtDW.Buffer_bufferLength < 0) {
rtDW.Buffer_outBufPtrIdx += rtDW.Buffer_bufferLength;
if (rtDW.Buffer_outBufPtrIdx < 0) {
rtDW.Buffer_outBufPtrIdx += 6;
}

rtDW.Buffer_bufferLength = 0;
}

uyIdx = 0;
currentOffset = rtDW.Buffer_outBufPtrIdx;
if (rtDW.Buffer_outBufPtrIdx < 0) {
currentOffset = rtDW.Buffer_outBufPtrIdx + 6;
}

nSampsAtBot = 6 - currentOffset;
rtb_Add_d = 3;
if (6 - currentOffset <= 3) {
for (i = 0; i < 6 - currentOffset; i++) {
rtb_Buffer[i] = rtDW.Buffer_CircBuf[currentOffset + i];
}

uyIdx = 6 - currentOffset;
currentOffset = 0;
rtb_Add_d = 3 - nSampsAtBot;
}

for (i = 0; i < rtb_Add_d; i++) {
rtb_Buffer[uyIdx + i] = rtDW.Buffer_CircBuf[currentOffset + i];
}

rtDW.Buffer_outBufPtrIdx = currentOffset + rtb_Add_d;

/* SignalConversion: '<S1>/TmpSignal ConversionAtDelayInport1' */
rtb_TmpSignalConversionAtDelayI[0] = rtb_Buffer2[0];
rtb_TmpSignalConversionAtDelayI[3] = rtb_Buffer1[0];
rtb_TmpSignalConversionAtDelayI[6] = rtb_Buffer[0];
rtb_TmpSignalConversionAtDelayI[1] = rtb_Buffer2[1];
rtb_TmpSignalConversionAtDelayI[4] = rtb_Buffer1[1];
rtb_TmpSignalConversionAtDelayI[7] = rtb_Buffer[1];
rtb_TmpSignalConversionAtDelayI[2] = rtb_Buffer2[2];
rtb_TmpSignalConversionAtDelayI[5] = rtb_Buffer1[2];
rtb_TmpSignalConversionAtDelayI[8] = rtb_Buffer[2];
for (i = 0; i < 9; i++) {
/* Outport: '<Root>/PressFlags' incorporates:
* Logic: '<S1>/Logical Operator2'
*/
rtY.PressFlags[i] = (rtb_RelationalOperator[i] && rtb_Delay[i]);

/* Outport: '<Root>/ReleasFlags' incorporates:
* Logic: '<S1>/Logical Operator3'
* Logic: '<S1>/Logical Operator4'
*/
rtY.ReleasFlags[i] = (rtb_RelationalOperator[i] && (!rtb_Delay[i]));

/* Switch: '<S1>/Switch' incorporates:
* Constant: '<S1>/Constant4'
* Logic: '<S1>/Logical Operator'
*/
if ((boolean_T)(rtb_Delay[i] ^ rtb_TmpSignalConversionAtDelayI[i])) {
rtb_Switch[i] = rtb_Add[i];
} else {
rtb_Switch[i] = 0;
}

/* End of Switch: '<S1>/Switch' */
}

for (i = 0; i < 9; i++) {
/* Update for Delay: '<S1>/Delay1' */
rtDW.Delay1_DSTATE[i] = rtb_Switch[i];

/* Update for Delay: '<S1>/Delay' */
rtDW.Delay_DSTATE[i] = rtb_TmpSignalConversionAtDelayI[i];
}
}

/* End of Buffer: '<S1>/Buffer' */

/* Sum: '<S4>/FixPt Sum1' incorporates:
* Constant: '<S4>/FixPt Constant'
* UnitDelay: '<S3>/Output'
*/
rtb_FixPtSum1 = (uint8_T)(rtDW.Output_DSTATE + 1U);

/* Switch: '<S5>/FixPt Switch' */
if (rtb_FixPtSum1 > 2) {
/* Update for UnitDelay: '<S3>/Output' incorporates:
* Constant: '<S5>/Constant'
*/
rtDW.Output_DSTATE = 0U;
} else {
/* Update for UnitDelay: '<S3>/Output' */
rtDW.Output_DSTATE = rtb_FixPtSum1;
}

/* End of Switch: '<S5>/FixPt Switch' */
rate_scheduler();
}

/* Model initialize function */
void KeyboardScanModule_initialize(void)
{
{
int32_T i;

/* InitializeConditions for Delay: '<S1>/Delay1' */
for (i = 0; i < 9; i++) {
rtDW.Delay1_DSTATE[i] = 1;
}

/* End of InitializeConditions for Delay: '<S1>/Delay1' */

/* InitializeConditions for Buffer: '<S1>/Buffer2' */
rtDW.Buffer2_inBufPtrIdx = 3;
rtDW.Buffer2_bufferLength = 3;

/* InitializeConditions for Buffer: '<S1>/Buffer1' */
rtDW.Buffer1_inBufPtrIdx = 3;
rtDW.Buffer1_bufferLength = 3;

/* InitializeConditions for Buffer: '<S1>/Buffer' */
rtDW.Buffer_inBufPtrIdx = 3;
rtDW.Buffer_bufferLength = 3;
}
}

/*
* File trailer for generated code.
*
* [EOF]
*/

Minimum applicable load (reference value) 10 μA at 1 VDC (resistive load)