surtur
a59d8db636
* since we're not working on windows * clear is also defined in curses so renamed our clear
536 lines
14 KiB
C++
536 lines
14 KiB
C++
/* Simple simulator for Kinetis KL25Z MCU
|
|
* Main implementation file.
|
|
* Add this file to your project to be build with your sources.
|
|
* Requires C++11 support.
|
|
*/
|
|
|
|
#include "simul_kl25z.h"
|
|
#include <iostream>
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <time.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <curses.h>
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
// Delay with time in milliseconds
|
|
void delay(unsigned int mseconds)
|
|
{
|
|
clock_t goal = mseconds + clock();
|
|
while (goal > clock() ) ;
|
|
}
|
|
|
|
// simple delay with some default value
|
|
void delay(void)
|
|
{
|
|
delay(500);
|
|
}
|
|
|
|
// clear screen
|
|
void myclear(){
|
|
#if defined(__linux__) || defined(__unix__) || defined(__APPLE__)
|
|
system("clear");
|
|
#endif
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
system("cls");
|
|
#endif
|
|
}
|
|
|
|
// Buffers used by drivers to print to screen
|
|
char gLEDsBuffer[256];
|
|
char gLCDBuffer[256];
|
|
// mutex to protect access to screen
|
|
std::mutex gScreenMutex;
|
|
|
|
void WriteLEDsToScreen(); // in drv_gpio
|
|
void WriteLCDToScreen(); // in drv_lcd
|
|
|
|
void WriteLEDsToBuffer(char* buffer); // in drv_gpio
|
|
void WriteLCDToBuffer(char* buffer); // in drv_lcd
|
|
|
|
/////////////////////////////////////////////////////
|
|
|
|
|
|
static SIM_Peripheral sim_peripheral_object;
|
|
SIM_Peripheral* SIM = &sim_peripheral_object;
|
|
|
|
// Port C module (needed for ADC input on port C)
|
|
static PORT_Peripheral portc_peripheral_object;
|
|
PORT_Peripheral* PORTC = &portc_peripheral_object;
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
// GPIO driver code
|
|
|
|
static bool gInitialized;
|
|
static FRDM_kit_pinmode gPinModes[LAST_PIN];
|
|
static uint8_t gPinOutputValues[LAST_PIN];
|
|
static const char* gLedNames[] = {"LD1", "LD2", "LD3", "RED", "GREEN", "BLUE" };
|
|
|
|
|
|
// Status of input pins
|
|
constexpr int MAX_SWITCHES = 4;
|
|
static bool gSwitchInputs[MAX_SWITCHES];
|
|
// mutex to protect the switch input variable
|
|
std::mutex gMutexSwitches;
|
|
|
|
// Background thread to process key press
|
|
void task1(std::string msg)
|
|
{
|
|
(void)msg;
|
|
while(1) {
|
|
char c = getchar();
|
|
gMutexSwitches.lock();
|
|
switch(c) {
|
|
case '1':
|
|
// toggle input state when key is pressed
|
|
gSwitchInputs[0] = !gSwitchInputs[0];
|
|
break;
|
|
case '2':
|
|
gSwitchInputs[1] = !gSwitchInputs[1];
|
|
break;
|
|
case '3':
|
|
gSwitchInputs[2] = !gSwitchInputs[2];
|
|
break;
|
|
case '4':
|
|
gSwitchInputs[3] = !gSwitchInputs[3];
|
|
break;
|
|
}
|
|
gMutexSwitches.unlock();
|
|
} // while 1
|
|
}
|
|
|
|
// Thread to process screen refresh....
|
|
void taskScreen() {
|
|
while(1) {
|
|
myclear();
|
|
|
|
printf("KL25Z Simulation, version %d.%d\n\n", VERSION_MAJOR, VERSION_MINOR);
|
|
gScreenMutex.lock();
|
|
printf(gLEDsBuffer);
|
|
printf(gLCDBuffer);
|
|
gScreenMutex.unlock();
|
|
// print status of switches
|
|
printf("\n\n%5c%5c%5c%5c",
|
|
gSwitchInputs[0] ? 'X' : '-',
|
|
gSwitchInputs[1] ? 'X' : '-',
|
|
gSwitchInputs[2] ? 'X' : '-',
|
|
gSwitchInputs[3] ? 'X' : '-' );
|
|
printf("\n SW1 SW2 SW3 SW4\n");
|
|
delay(80);
|
|
}
|
|
}
|
|
|
|
|
|
// This will create thread when the program starts...
|
|
std::thread t1(task1, "Hello");
|
|
std::thread t2(taskScreen);
|
|
|
|
/* Initialize the gpio driver for LEDs and push buttons. */
|
|
void GPIO_Initialize(void)
|
|
{
|
|
gInitialized = true;
|
|
for ( int i=0; i<MAX_SWITCHES; i++ )
|
|
gSwitchInputs[i] = false;
|
|
}
|
|
|
|
/* Configure given pin to behave as input or output. */
|
|
void pinMode(FRDM_kit_pin pin, FRDM_kit_pinmode mode )
|
|
{
|
|
if ( !gInitialized ) {
|
|
printf("BSOD - Default ISR :) \nGPIO driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
|
|
switch (pin)
|
|
{
|
|
/* All LEDs are on port B */
|
|
case LD1:
|
|
case LD2:
|
|
case LD3:
|
|
case LED_RED:
|
|
case LED_GREEN:
|
|
case LED_BLUE:
|
|
case SW1:
|
|
case SW2:
|
|
case SW3:
|
|
case SW4:
|
|
gPinModes[(int)pin] = mode;
|
|
break;
|
|
|
|
default:
|
|
printf("Warning: Invalid pin %d in pinMode.\n", pin);
|
|
//while (1) ; /* Error: invalid pin! */
|
|
}
|
|
}
|
|
|
|
/* Set value for given pin. The pin must be configured as output with pinMode first! */
|
|
void pinWrite(FRDM_kit_pin pin, uint8_t value )
|
|
{
|
|
if ( !gInitialized ) {
|
|
printf("BSOD - Default ISR :) \nGPIO driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
switch(pin)
|
|
{
|
|
/* All LEDs are on port B */
|
|
case LD1:
|
|
case LD2:
|
|
case LD3:
|
|
case LED_RED:
|
|
case LED_GREEN:
|
|
case LED_BLUE:
|
|
case SW1:
|
|
case SW2:
|
|
case SW3:
|
|
case SW4:
|
|
if ( gPinModes[(int)pin] == OUTPUT ) {
|
|
// update screen
|
|
gPinOutputValues[(int)pin] = value;
|
|
WriteLEDsToBuffer(gLEDsBuffer);
|
|
//WriteLEDsToScreen();
|
|
|
|
} else {
|
|
// do nothing
|
|
printf("Warning: Pin %d is not an output.\n", pin);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
printf("Warning: Invalid pin %d in pinWrite.\n", pin);
|
|
//while(1) ; /* Error: invalid pin! */
|
|
}
|
|
}
|
|
|
|
/* Read value on given pin. The pin must be configured as input with pinMode first! */
|
|
uint8_t pinRead(FRDM_kit_pin pin)
|
|
{
|
|
if ( !gInitialized ) {
|
|
printf("BSOD - Default ISR :) \nGPIO driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
uint8_t result = LOW;
|
|
if ( gPinModes[(int)pin] == INPUT || gPinModes[(int)pin] == INPUT_PULLUP ) {
|
|
|
|
// Background thread reads the keyboard and sets gSwitchInputs
|
|
gMutexSwitches.lock();
|
|
switch(pin)
|
|
{
|
|
case SW1:
|
|
result = (gSwitchInputs[0]) ? LOW : HIGH;
|
|
break;
|
|
case SW2:
|
|
result = (gSwitchInputs[1]) ? LOW : HIGH;
|
|
break;
|
|
case SW3:
|
|
result = (gSwitchInputs[2]) ? LOW : HIGH;
|
|
break;
|
|
case SW4:
|
|
result = (gSwitchInputs[3]) ? LOW : HIGH;
|
|
break;
|
|
|
|
default:
|
|
printf("Warning: Pin %d not supported for input in simulator.\n", pin);
|
|
break;
|
|
}
|
|
gMutexSwitches.unlock();
|
|
|
|
} else {
|
|
printf("Warning: Pin %d is not an input.\n", pin);
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
// Helpers to print LED state to console
|
|
#define GET_LED_SYMBOL(a) ((a == 0) ? 'X' : '-')
|
|
#define PRINT_LED_FROM_MODE(mode, value) ((mode == OUTPUT) ? GET_LED_SYMBOL(value) : '-')
|
|
|
|
void WriteLEDsToBuffer(char* buffer) {
|
|
|
|
char buff[512];
|
|
gScreenMutex.lock();
|
|
buffer[0] = '\0';
|
|
sprintf(buff, "%5c%5c%5c\t\t%3c%3c%3c\n",
|
|
PRINT_LED_FROM_MODE(gPinModes[0], gPinOutputValues[0]),
|
|
PRINT_LED_FROM_MODE(gPinModes[1], gPinOutputValues[1]),
|
|
PRINT_LED_FROM_MODE(gPinModes[2], gPinOutputValues[2]),
|
|
PRINT_LED_FROM_MODE(gPinModes[3], gPinOutputValues[3]),
|
|
PRINT_LED_FROM_MODE(gPinModes[4], gPinOutputValues[4]),
|
|
PRINT_LED_FROM_MODE(gPinModes[5], gPinOutputValues[5])
|
|
);
|
|
strcat(buffer, buff);
|
|
|
|
sprintf(buff, "%5s%5s%5s\t\t%s/%s/%s\n", gLedNames[0], gLedNames[1], gLedNames[2],
|
|
gLedNames[3], gLedNames[4], gLedNames[5]);
|
|
strcat(buffer, buff);
|
|
gScreenMutex.unlock();
|
|
}
|
|
|
|
void WriteLEDsToScreen() {
|
|
|
|
printf("%5c%5c%5c\t\t%3c%3c%3c\n",
|
|
PRINT_LED_FROM_MODE(gPinModes[0], gPinOutputValues[0]),
|
|
PRINT_LED_FROM_MODE(gPinModes[1], gPinOutputValues[1]),
|
|
PRINT_LED_FROM_MODE(gPinModes[2], gPinOutputValues[2]),
|
|
PRINT_LED_FROM_MODE(gPinModes[3], gPinOutputValues[3]),
|
|
PRINT_LED_FROM_MODE(gPinModes[4], gPinOutputValues[4]),
|
|
PRINT_LED_FROM_MODE(gPinModes[5], gPinOutputValues[5])
|
|
);
|
|
|
|
printf("%5s%5s%5s\t\t%s/%s/%s\n", gLedNames[0], gLedNames[1], gLedNames[2],
|
|
gLedNames[3], gLedNames[4], gLedNames[5]);
|
|
|
|
}
|
|
|
|
// end GPIO driver code
|
|
//////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////
|
|
// ADC code
|
|
|
|
// Simulated ADC values
|
|
static uint16_t adc_values[] = { 10, 30, 60, 100, 110, 120, 130, 140, 150, 170, 200, 230, 255,
|
|
230, 200, 170, 150, 130, 100, 60, 30, 0, 0 };
|
|
static int MAX_ADC_VALUES = sizeof(adc_values)/sizeof(uint16_t);
|
|
|
|
|
|
|
|
|
|
// Define the ADC0 module for use in user program
|
|
static ADC_Peripheral adc_module_object;
|
|
ADC_Peripheral* ADC0 = &adc_module_object;
|
|
|
|
void AdcValueWrite(unsigned int data) {
|
|
(void)data; // just to remove unused param warning
|
|
ADC0->UpdateData();
|
|
}
|
|
|
|
// handler for write to CFG1[0] only to indicate we have valid settings
|
|
void AdcStartConversion(unsigned int data) {
|
|
//std::cout << "Start conversion " << data << '\n';
|
|
|
|
// For our pin - channel 11 check the pin config, for other channels just
|
|
// skip test and simulated that conversion completed. This is needed for
|
|
// calibration etc.
|
|
int channel = (data & ADC_SC1_ADCH_MASK) >> ADC_SC1_ADCH_SHIFT;
|
|
if ( channel == 11 ) {
|
|
if ( ADC0->IsPinConfigValid() )
|
|
ADC0->mConversionStarted = true;
|
|
|
|
} else {
|
|
// conversion must be started for any other channel, also for calibration
|
|
ADC0->mConversionStarted = true;
|
|
}
|
|
|
|
ADC0->UpdateData();
|
|
}
|
|
|
|
void ADC_Peripheral::UpdateData()
|
|
{
|
|
// test if clock is enabled
|
|
if ( (SIM->SCGC6 & SIM_SCGC6_ADC0_MASK) == 0 ) {
|
|
printf("BSOD - Default ISR :) \nADC - clock not enabled!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
if ( mConversionStarted ) {
|
|
// get next value for ADC if channel is 11
|
|
if ( (SC1[0] & 0x1F) == ADC_SC1_ADCH(11) ) {
|
|
// rozliseni
|
|
int mode = (CFG1 & ADC_CFG1_MODE_MASK) >> ADC_CFG1_MODE_SHIFT;
|
|
int shift = 0;
|
|
switch ( mode) {
|
|
case 0: // 8 bit
|
|
shift = 0;
|
|
PRINT_DGMSG("ADC resolution is 8 bit.");
|
|
break;
|
|
case 1: // 12 bit
|
|
shift = 4;
|
|
PRINT_DGMSG("ADC resolution is 12 bit.");
|
|
break;
|
|
case 2: // 10 bit
|
|
shift = 2;
|
|
PRINT_DGMSG("ADC resolution is 10 bit.");
|
|
break;
|
|
case 3: // 16 bit
|
|
shift = 8;
|
|
PRINT_DGMSG("ADC resolution is 16 bit.");
|
|
break;
|
|
}
|
|
|
|
R[0].data = adc_values[mCurrentDataIndex++] << shift;
|
|
if ( mCurrentDataIndex >= MAX_ADC_VALUES )
|
|
mCurrentDataIndex = 0;
|
|
}
|
|
|
|
SC1[0].data |= ADC_SC1_COCO_MASK; // set conversion complete flag
|
|
mConversionStarted = false;
|
|
}
|
|
}
|
|
|
|
|
|
// end ADC driver code
|
|
//////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// LCD driver code
|
|
static bool gLcdInitialized;
|
|
|
|
static char gDispData[4][21];
|
|
static int gRow, gColumn;
|
|
|
|
void WriteLCDToScreen() {
|
|
//clear();
|
|
printf("\n\nLCD-----------------\n");
|
|
//printf("123456789ABCDEFGHIJK\n");
|
|
for ( int i=0; i<4; i++ )
|
|
printf("%s\n", gDispData[i]);
|
|
printf("---------------------\n");
|
|
}
|
|
|
|
void WriteLCDToBuffer(char* buffer) {
|
|
//clear();
|
|
char buff[512];
|
|
gScreenMutex.lock();
|
|
buffer[0] = '\0';
|
|
sprintf(buff, "\n\nLCD-----------------\n");
|
|
strcat(buffer, buff);
|
|
//printf("123456789ABCDEFGHIJK\n");
|
|
for ( int i=0; i<4; i++ ) {
|
|
sprintf(buff, "%s\n", gDispData[i]);
|
|
strcat(buffer, buff);
|
|
}
|
|
|
|
sprintf(buff, "---------------------\n");
|
|
strcat(buffer, buff);
|
|
gScreenMutex.unlock();
|
|
}
|
|
|
|
/* initialize display */
|
|
void LCD_initialize(void)
|
|
{
|
|
gLcdInitialized = true;
|
|
gRow = 0; // 1 - 4
|
|
gColumn = 0; // 1 - 20
|
|
}
|
|
|
|
|
|
void LCD_set_cursor(uint8_t line, uint8_t column) {
|
|
if ( line > 0 && line < 5)
|
|
gRow = line - 1;
|
|
if ( column > 0 && column < 21 )
|
|
gColumn = column - 1;
|
|
}
|
|
|
|
void LCD_putch(char c) {
|
|
if ( !gLcdInitialized ) {
|
|
printf("BSOD - Default ISR :) \nLCD driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
if ( gColumn > 19 ) {
|
|
printf("Warning: LCD writing beyond last column!\n");
|
|
return;
|
|
}
|
|
|
|
if ( gRow > 3 ) {
|
|
printf("Warning: LCD writing below last line!\n");
|
|
return;
|
|
}
|
|
|
|
gDispData[gRow][gColumn] = c;
|
|
gColumn++;
|
|
if ( gColumn > 19 )
|
|
gColumn = 0;
|
|
|
|
// update screen
|
|
WriteLCDToBuffer(gLCDBuffer);
|
|
}
|
|
|
|
|
|
void LCD_puts(const char* str) {
|
|
if ( !gLcdInitialized ) {
|
|
printf("BSOD - Default ISR :) \nLCD driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
char* p = gDispData[gRow];
|
|
int len = 20 - gColumn;
|
|
if ( len > 0) {
|
|
strncpy(p + gColumn, str, len);
|
|
gDispData[gRow][gColumn+len] = '\0';
|
|
gColumn += strlen(str);
|
|
} else {
|
|
printf("Warning: LCD writing beyond last column!\n");
|
|
return;
|
|
}
|
|
|
|
WriteLCDToBuffer(gLCDBuffer);
|
|
}
|
|
|
|
|
|
void LCD_clear(void) {
|
|
if ( !gLcdInitialized ) {
|
|
printf("BSOD - Default ISR :) \nLCD driver not initialized!\n");
|
|
while (1) ;
|
|
}
|
|
|
|
gRow = 0; // 1 - 4
|
|
gColumn = 0;
|
|
|
|
for ( int i = 0; i<4; i++ ) {
|
|
for ( int j = 0; j<20; j++) {
|
|
gDispData[i][j] = ' ';
|
|
}
|
|
}
|
|
|
|
WriteLCDToBuffer(gLCDBuffer);
|
|
}
|
|
|
|
|
|
void LCD_backlight_on(void) {
|
|
printf("Warning: LCD_backlight_on not implemented.\n");
|
|
}
|
|
|
|
|
|
void LCD_backlight_off(void) {
|
|
printf("Warning: LCD_backlight_off not implemented.\n");
|
|
}
|
|
|
|
// end LCD driver code
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// SYSTICK driver code
|
|
// Simulate systick driver functions
|
|
// Functions implemented in simul_kl25z.cpp
|
|
void SYSTICK_initialize(void)
|
|
{
|
|
// do nothing
|
|
}
|
|
uint32_t SYSTICK_millis(void)
|
|
{
|
|
return (uint32_t)clock();
|
|
}
|
|
|
|
uint32_t SYSTICK_micros(void)
|
|
{
|
|
return SYSTICK_millis() * 1000;
|
|
}
|
|
|
|
void SYSTICK_delay_ms(uint32_t millis)
|
|
{
|
|
delay(millis);
|
|
}
|
|
|
|
// end SYSTICK driver code
|
|
//////////////////////////////////////////////////////////////////
|