_N0x/EmbeddedSystems
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added basic CLI functionality to get button state and switch LEDs via serial interface

Browse Source
This commit is contained in:
_N0x 2021-12-04 23:12:36 +01:00
parent 4021359230
commit 4173c08c95
4 changed files with 371 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

331
EmbeddedSystemsTHM/CLI.c Normal file
View File

@ -0,0 +1,331 @@
//================================================================================================================================
// Includes
//================================================================================================================================
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>
#include "string.h"
#include "CLI.h"
#include "Taster.h"
#include "Timer.h"
#include "Led.h"
//================================================================================================================================
// defines
//================================================================================================================================
#define COUNT_COMMANDS ( sizeof(command) / sizeof(command[0]) )
#define CHAR_DEL 0x7F
#define CHAR_BACKSPACE 0x08
#define CHAR_CR 0x0D
#define CHAR_LF 0x0A
#define CHAR_ESC 0x1B
#define NEXT_LINE (char*)"\r\n"
#define CURSOR (char*)">>"
//================================================================================================================================
// Lokale Variablen
//================================================================================================================================
uint16_t g_startMS;
static char data[200]; // Zwischenspeicher für die Befehlsdecodierung
static char rs232_buffer[50];
static uint8_t pointer=0; // Zeiger zu obiger Variable
static void (*callback_function)(char _data) = NULL; // Funktionszeiger auf eine Funktion, welche die Daten entgegen nimmt,
// und auf der Ausgabeschnittstelle ausgibt.
//================================================================================================================================
// Lokale Functionen
//================================================================================================================================
static void run_cmd(char *_data);
static char* get_next(char *_data);
static char to_uppercase (char _data);
static void print_char (char _data);
static void print_string (char* _data);
// Funktionen für Befehlsdecoder
static void cmd_help(const char* _data);
static void cmd_taster(const char* _data);
static void cmd_led_on(const char* _data);
static void cmd_led_off(const char* _data);
static void cmd_alert(const char* _data);
//================================================================================================================================
// command-Tabelle
//================================================================================================================================
const struct {
const char cmd[20];
void (*funktion)(const char* _data);
const char info[40];
} command[] PROGMEM = {
{"HELP", &cmd_help, "Display this Help Menu"},
{"BUTTON", &cmd_taster, "Current State of the Buttons"},
{"LED_ON $LED", &cmd_led_on, "Turn on the LED on position $LED"},
{"LED_OFF $LED", &cmd_led_off, "Turn off the LED on position $LED"},
{"ALERT", &cmd_alert, "RING THE ALTER!!!"},
};
//================================================================================================================================
// Funktion: line_interpreter_init
// Initialisierung des Line-Interpreters.
// Parameter: _ptr: Zeiger auf die Funktion, welche die einzelne Zeichen auf der Konsole ausgeben kann.
// Rückgabewert: keine
//================================================================================================================================
void line_interpreter_init(void (*_ptr)(char _data)){
callback_function = _ptr;
}
//================================================================================================================================
// Funktion: line_interpreter_get_data
// Dieser Funktion werden die Daten von der RS232 Schnittstelle übergeben. In dieser Funktion werden die Empfangen
// Zeichen zu einer Zeichenkette zusammengefügt, und wenn die ein Carryage-Return empfangen wurde, wird die
// Zeichenkette an den Decoder übergeben.
// Parameter: _char: Empfangenes Zeichen
// Rückgabewert: keine
//================================================================================================================================
void line_interpreter_get_data(char _char){
switch (_char){
case CHAR_BACKSPACE:
case CHAR_DEL:
if (pointer > 0){
pointer--; // Zeichen aus Zeichenkette entfernen
print_char (CHAR_BACKSPACE);
print_char (' ');
print_char (CHAR_BACKSPACE);
}
break;
case CHAR_CR: // Enter wurde gedrückt,
data[pointer] = 0; // Terminate String;
print_string(NEXT_LINE);
if (pointer>0){ // Wenn mindestens ein Zeichen empfangen wurde dann
run_cmd (data); // Empfangene Zeichenkette Ausweten
pointer = 0;
}
print_string (CURSOR);
break;
default: // Normales Zeichen empfangen.
_char = to_uppercase(_char); // Kleinbuchstaben zu Großbuchstaben wandeln
print_char(_char); // Empfangenes Zeichen Ausgeben
data[pointer++] = _char; // Empfangenes Zeichen in Zwischenspeicher speichern.
break;
}//end switch
}
//================================================================================================================================
// Funktion: Ausfuehren
// Diese Funktion überprüft das erste Wort in der Zeichenkette mit der Command-Tabelle und wenn es eine Über-
// einstimmung gibt, wird die entsprechende Funktion aufgerufen.
// Parameter: _string: Auszuwertende Zeichenkette
// Rückgabewert: keine
//================================================================================================================================
static void run_cmd (char *_string){
char *temp = 0;
uint8_t i;
void (*temp_func)(char* const _string);
temp = get_next(data);
for (i=0; i<COUNT_COMMANDS; i++){
if (strcmp_P(_string, command[i].cmd)==0){
memcpy_P(&temp_func, &command[i].funktion, sizeof (temp_func));
temp_func(temp);
break;
}
}
if (i==COUNT_COMMANDS){
sprintf_P (rs232_buffer, PSTR("COMMAND ERROR\r\n\r\n"));
print_string(rs232_buffer);
}
}
//================================================================================================================================
// Funktion: get_next
// Diese Funktion separiert den übergebenen String.
// Parameter: _data: Auszuwertende Zeichenkette
// Rückgabewert: keine
//================================================================================================================================
static char* get_next(char *_data){
char *temp = _data;
while (*temp != 0){
if (*temp==' '){
*temp = 0;
temp++;
break;
} else{
temp++;
}
}
return temp;
}
//================================================================================================================================
// Funktion: Grossbuchstaben
// Diese Funktion wandelt Kleinbuchstaben in Großbuchstaben.
// Parameter: _char: Auszuwertendes Zeichen
// Rückgabewert: Das eingegebene Zeichen als Großbuchstabe.
//================================================================================================================================
static char to_uppercase (char _char){
if ( (_char>='a') && (_char<='x') ){
_char -= 'a' - 'A';
}
return _char;
}
//================================================================================================================================
// Funktion: print_char
// Ausgabe eines Zeichens auf der Konsole.
// Parameter: _data: Zeichen, welches an die Callbackfunktion übergeben werden soll.
// Rückgabewert: keine
//================================================================================================================================
static void print_char (char _data){
if (callback_function != NULL){
callback_function(_data);
}
}
//================================================================================================================================
// Funktion: print_string
// Ausgabe eines Strings auf der Konsole.
// Parameter: _data: Zeichenkette
// Rückgabewert: keine
//================================================================================================================================
static void print_string (char* _data){
for(uint8_t i=0; i<200; i++) {
if(_data[i] == 0){
break;
}
print_char(_data[i]);
}
}
//================================================================================================================================
// Funktion: cmd_temp
// Hilfe Funktion. Gibt die Hilfe Tabelle aus.
// Parameter: _data: Zeichenkette mit Parametern des Befehls
// Rückgabewert: keine
//================================================================================================================================
static void cmd_help(const char* _data){
for (uint8_t i=0; i<COUNT_COMMANDS; i++){
strcpy_P(rs232_buffer, command[i].cmd);
print_string(rs232_buffer);
print_string((char*)" ");
strcpy_P(rs232_buffer, command[i].info);
print_string(rs232_buffer);
print_string(NEXT_LINE);
}
}
//================================================================================================================================
// Funktion: cmd_taster
// Kann verwendet werden, um den aktuellen Status der Taster abzufragen
// Parameter: _data: Zeichenkette mit Parametern des Befehls
// Rückgabewert: keine
//================================================================================================================================
static void cmd_taster(const char* _data){
print_string(Taster1_get() ? "1" : "0");
print_string(NEXT_LINE);
print_string(Taster2_get() ? "1" : "0");
print_string(NEXT_LINE);
print_string(Taster3_get() ? "1" : "0");
print_string(NEXT_LINE);
print_string(Taster4_get() ? "1" : "0");
print_string(NEXT_LINE);
}
//================================================================================================================================
// Funktion: cmd_led_on
// Kann verwendet werden, um eine LED einzuschalten
// Parameter: _data: Zeichenkette mit Parametern des Befehls.
// Hier: Die ID der LED, welche eingeschaltet werden soll
// Rückgabewert: keine
//================================================================================================================================
static void cmd_led_on(const char* _data){
switch(_data[0]){
case '1': Led1_On(); break;
case '2': Led2_On(); break;
case '3': Led3_On(); break;
case '4': Led4_On(); break;
case '5': Led5_On(); break;
case '6': Led6_On(); break;
case '7': Led7_On(); break;
case '8': Led8_On(); break;
default:
print_string("Led could not be found.");
print_string(NEXT_LINE);
}
}
//================================================================================================================================
// Funktion: cmd_led_off
// Kann verwendet werden, um eine LED auszuschalten
// Parameter: _data: Zeichenkette mit Parametern des Befehls.
// Hier: Die ID der LED, welche ausgeschaltet werden soll
// Rückgabewert: keine
//================================================================================================================================
static void cmd_led_off(const char* _data){
switch(_data[0]){
case '1': Led1_Off(); break;
case '2': Led2_Off(); break;
case '3': Led3_Off(); break;
case '4': Led4_Off(); break;
case '5': Led5_Off(); break;
case '6': Led6_Off(); break;
case '7': Led7_Off(); break;
case '8': Led8_Off(); break;
default:
print_string("LED could not be found.");
print_string(NEXT_LINE);
}
}
//================================================================================================================================
// Funktion: cmd_alert
// Lässt die Roten LEDs blinken und gibt einen Alarm text aus.
// Parameter: _data: Zeichenkette mit Parametern des Befehls.
// Rückgabewert: keine
//================================================================================================================================
static void cmd_alert(const char* _data){
uint8_t isOn = 0;
while (1)
{
if(Timer_getTick() - g_startMS >= 250){
g_startMS = Timer_getTick();
print_string("ALERT!!!");
if(!isOn){
isOn = 1;
Led6_On();
Led7_On();
Led8_On();
} else {
isOn = 0;
Led6_Off();
Led7_Off();
Led8_Off();
}
}
}
}

10
EmbeddedSystemsTHM/EmbeddedSystemsTHM.cproj
View File

@ -151,6 +151,12 @@
</ToolchainSettings>
</PropertyGroup>
<ItemGroup>
<Compile Include="cli.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="cli.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="Led.c">
<SubType>compile</SubType>
</Compile>
@ -184,10 +190,10 @@
<Compile Include="Timer.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="UART.c">
<Compile Include="uart.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="UART.h">
<Compile Include="uart.h">
<SubType>compile</SubType>
</Compile>
</ItemGroup>

8
EmbeddedSystemsTHM/cli.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef CLI_H_
#define CLI_H_
extern void line_interpreter_init(void (*_ptr)(char _data));
extern void line_interpreter_get_data(char _d);
#endif /* CLI_H_ */

34
EmbeddedSystemsTHM/main.c
View File

@ -11,6 +11,7 @@
#include "Tasks.h"
#include "StopLight.h"
#include "UART.h"
#include "CLI.h"
#include <avr/interrupt.h>
#define F_CPU 1000000
#include <util/delay.h>
@ -18,34 +19,43 @@
/* function declarations */
void buttonTest (void);
uint16_t g_startMS;
/* functions */
int
main (void)
{
sei();
/* Initialize the LEDs, Buttons, etc. */
//Led_init();
//Taster_init();
//Timer_init();
//initTasks();
//uart_init();
uart_init_isr();
Timer_init();
Taster_init();
Led_init();
uart_init();
line_interpreter_init(uart_send_byte);
uart_send_string("Welcome to the ATmega1284P CLI. Type HELP to display all options.\r\n");
while (1)
{
/* UART Standalone Test */
/*
if(uart_data_available()){
char data[500];
data[0] = uart_get_data();
uart_send_isr(data);
}
*/
if(uart_data_available()){
line_interpreter_get_data(uart_get_data());
}
//buttonTest();
//runningLight();
//blinkLedWithTimer();
//runStopLightTask1();
//runStopLightTask2();
//uart_send ("Hello World\n");
uart_send_isr ("Hello World\n");
//uart_send ("uart_send: Hello World\n");
}
}