Версия для печати темы

/*
* 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)

// MSP430, S_M_V
// -------- keyb ---------
#define S_PORT_KEYB_IN P6IN
#define S_PORT_KEYB_OUT P6OUT
// P6.0 . . . P6.3 - входные линии матрицы, подтянуты через 100к на GND
// P6.4 . . . P6.7 - выходные линии матрицы (опрос линии установкой в 1)

static char key_wr = 0, key_rd = 0, keyCodeScan_old = 0;
char keyCodeScan = 0, KeyCode = 0;
char KeyCodeRep = 0; // запомнить код удерживаемой клавиши
char f_repeat = 0; // флаг удержания нажатия

t16_sint time_repeat; // таймаут удержания клавиши, после которого работает автоповтор

// процедура сканирования клавиатуры (аппаратный опрос линий)
// void OS::system_timer_user_hook()
// Периодически вызывается в тиках OS или в обработчике таймера
void KEY_Scan_R(void)
{
static char F_Press_now = 0, F_Press_old = 0, KKeyCode = 0;
// ================== KEY ===================================
SOUND_OFF;

keyCodeScan_old = keyCodeScan; // проверка изменения коорд. нажатия
F_Press_old = F_Press_now; // контроль событий нажатия-отжатия

key_rd = S_PORT_KEYB_IN & 0x0F; // Read keyLines 0...3 (InData) from PORT
keyCodeScan = (key_wr << 4) & 0xF0; // номер скан-линии 0 1 2 3 (row)
keyCodeScan |= key_rd & 0x0F; // считанные столбцы (col)

if( keyCodeScan & 0x0F ) // нажата как минимум 1 клавиша
{ // нажата ли любая кнопка ? 0F маска - читаем из порта только "приемные" линии
F_Press_now = 1;
if( keyCodeScan != keyCodeScan_old ) // изменен скан-код ?
{ // первый вход по нажатию клавиши
time_repeat = 0; // сбросить таймаут
f_repeat = 0;

}
else // повторные входы по нажатой клавише
{
if( f_repeat == 0 ) // пока нет события "удержание", ++ таймера
{
if( time_repeat > 62 ) //4 // 62 цикла по 16 мс - около 1с
{
time_repeat = 0; // сбросить таймаут
f_repeat = 1;
}
else
time_repeat++;

}
}

}
else // клавиша не нажата
{
F_Press_now = 0; // холостой проход - без нажатий
}

// ---------- выдать скан-линию для следующего цикла --------
if( !F_Press_now ) // продолжаем сканировать линии - тк нет нажатия
{ // далее только если не нажата кнопка
if( key_wr == 3 )
key_wr = 0;
else
key_wr++; // счетчик скан-линий ++
// ----------------------
if( key_wr == 3 ) S_PORT_KEYB_OUT = 0x80; // A B C D выбор столбца D0 D1 D2 D3
if( key_wr == 2 ) S_PORT_KEYB_OUT = 0x40; // 3 6 9 #
if( key_wr == 1 ) S_PORT_KEYB_OUT = 0x20; // 2 5 8 0
if( key_wr == 0 ) S_PORT_KEYB_OUT = 0x10; // 1 4 7 *
}

// заменить switch на перекодировку по ассоц.массиву
// ------- скан для матрицы 4x4 ---------------------
// перекодировка в KKeyCode - для PCB F5438A с подключением на мембр. кл-ру 4x4
// кабелем 9-w и HDR'10 на PCB
switch( keyCodeScan )
{
// key_wr == 0 1 4 7 *
case (0x00 | 0x01): KKeyCode = 0x31; break; // 1
case (0x00 | 0x02): KKeyCode = 0x34; break; // 4
case (0x00 | 0x04): KKeyCode = 0x37; break; // 7
case (0x00 | 0x08): KKeyCode = 0x2E; break; // * ekeyPoint
// ----------------
// key_wr == 1 2 5 8 0
case (0x10 | 0x01): KKeyCode = 0x32; break; // 2
case (0x10 | 0x02): KKeyCode = 0x35; break; // 5
case (0x10 | 0x04): KKeyCode = 0x38; break; // 8
case (0x10 | 0x08): KKeyCode = 0x30; break; // 0
// ----------------
// key_wr == 2 3 6 9 #
case (0x20 | 0x01): KKeyCode = 0x33; break; // 3
case (0x20 | 0x02): KKeyCode = 0x36; break; // 6
case (0x20 | 0x04): KKeyCode = 0x39; break; // 9
case (0x20 | 0x08): KKeyCode = 0x04; break; // # ekeyEnter
// ----------------
// key_wr == 3 A B C D
case (0x30 | 0x01): KKeyCode = 0x01; break; // A F1
case (0x30 | 0x02): KKeyCode = 0x02; break; // B F2
case (0x30 | 0x04): KKeyCode = 0x03; break; // C F3
case (0x30 | 0x08): KKeyCode = 0x05; break; // D F4

default: KKeyCode = 0x00; break; // ekeyNO
}

KeyCode = KKeyCode;
// ================= /KEY ===================================

if( F_Press_old && !F_Press_now ) // KEY_OFF
{ // обработка отжатия
time_repeat = 0;

if ( f_repeat == 2 ) // если был режим "отпуск-удержания" (2)
{
KEY_push( (t16_sint) (KeyCodeRep | 0x4000) ); // (стоп удержания) маска 0x40
//KEY_pushBf( (t16_sint) ( 0x99 | 0x4000) );

f_repeat = 0;

}
}

if( !F_Press_old && F_Press_now ) // KEY_ON
{ // обработка нажатия

SOUND_ON;

KEY_push( (t16_sint) KKeyCode ); // тк буфер 16-битный

}

if( F_Press_old && F_Press_now ) // KEY_ON_ON_ON
{ // обработка удержания

if( f_repeat == 1 )
{
f_repeat = 2; // положить в буфер код "удержания", переключиться в след. цикле на
// ожидание "отпуск-удержания" (режим 2)

KEY_push( (t16_sint) (KKeyCode | 0x8000) ); // (старт удержания) маска 0x80

// --------- системный ресет --------------------
if( KKeyCode == 0x31 ) // Reset на удержание клавиши <1>
{
SLEEP(100);
WDTCTL = WDTPW | WDTHOLD;
asm ("push &0xfffe");
asm ("ret");
}
// -------- /системный ресет --------------------

KeyCodeRep = KeyCode; // сохранить для выдачи кода отжатия
}
}

}// KEY_Scan(void)