virtual void execute(cmd_context & ctx) {
ctx.regular_stream() << "\"";
if (m_cmds.empty()) {
vector<named_cmd> cmds;
cmd_context::cmd_iterator it = ctx.begin_cmds();
cmd_context::cmd_iterator end = ctx.end_cmds();
for (; it != end; ++it) {
cmds.push_back(named_cmd((*it).m_key, (*it).m_value));
}
// named_cmd_lt is not a total order for commands, but this is irrelevant for Linux x Windows behavior
std::sort(cmds.begin(), cmds.end(), named_cmd_lt());
vector<named_cmd>::const_iterator it2 = cmds.begin();
vector<named_cmd>::const_iterator end2 = cmds.end();
for (; it2 != end2; ++it2) {
display_cmd(ctx, it2->first, it2->second);
}
}
else {
svector<symbol>::const_iterator it = m_cmds.begin();
svector<symbol>::const_iterator end = m_cmds.end();
for (; it != end; ++it) {
cmd * c = ctx.find_cmd(*it);
SASSERT(c);
display_cmd(ctx, *it, c);
}
}
ctx.regular_stream() << "\"\n";
}
/*!
* Init Display
*/
void display_init(void){
shift_init();
DISPLAY_DDR |= DISPLAY_OUT; // Ausgänge
DISPLAY_DDR &= ~DISPLAY_IN; // Eingänge
delay(30); // Display steht erst 10ms nach dem Booten bereit
// Register in 8-Bit-Modus 3x Übertragen, dazwischen warten
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
display_cmd(0x0f); //Display On, Cursor On, Cursor Blink
display_cmd(DISPLAY_CLEAR); // Display l�schen, Cursor Home
display_data('i');
}
/*!
* Positioniert den Cursor
* @param row Zeile
* @param column Spalte
*/
void display_cursor (int row, int column) {
switch (row) {
case 1:
display_cmd (0x80 + column - 1);
break;
case 2:
display_cmd (0xc0 + column - 1);
break;
case 3:
display_cmd (0x94 + column - 1);
break;
case 4:
display_cmd (0xd4 + column - 1);
break;
default: break;
}
}
/*!
* Initialisiert das Display
*/
void display_init(void)
{
commandMQ = msgQueueAdd();
dataMQ = msgQueueAdd();
shift_init();
DISPLAY_DDR |= DISPLAY_OUT; // Ausgaenge
DISPLAY_DDR = (BK_U8B) (DISPLAY_DDR & ~DISPLAY_IN); // Eingaenge
_delay_ms(12); // Display steht erst 10ms nach dem Booten bereit hier kann nicht die ctbotKernel wait funktion genutzt werden da die interrupts erst später aktiviert werden und somit die wait funktion noch nicht funktioniert
/* Register in 8-Bit-Modus 3x uebertragen, dazwischen warten */
BK_U8B i;
for (i = 3; i > 0; --i)
{
shift_data_out(0x38, SHIFT_LATCH, SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT = DPC;
_delay_ms(5);
}
display_cmd(DISPLAY_MODE); // Display an und Cursor-Modus setzen
display_cmd(DISPLAY_CLEAR); // Display loeschen, Cursor Home
}
/*!
* Positioniert den Cursor
* @param row Zeile
* @param column Spalte
*/
void display_cursor(BK_U16B row, BK_U16B column)
{
const BK_U8B r = (BK_U8B) (row - 1);
const BK_U8B c = (BK_U8B) (column - 1);
switch (r)
{
case 0:
display_cmd((BK_U8B) (0x80 + c));
break;
case 1:
display_cmd((BK_U8B) (0xc0 + c));
break;
case 2:
display_cmd((BK_U8B) (0x94 + c));
break;
case 3:
display_cmd((BK_U8B) (0xd4 + c));
break;
default:
break;
}
}
void execute(cmd_context & ctx) override {
ctx.regular_stream() << "\"";
if (m_cmds.empty()) {
vector<named_cmd> cmds;
cmd_context::cmd_iterator it = ctx.begin_cmds();
cmd_context::cmd_iterator end = ctx.end_cmds();
for (; it != end; ++it) {
cmds.push_back(named_cmd((*it).m_key, (*it).m_value));
}
// named_cmd_lt is not a total order for commands, but this is irrelevant for Linux x Windows behavior
std::sort(cmds.begin(), cmds.end(), named_cmd_lt());
for (named_cmd const& nc : cmds) {
display_cmd(ctx, nc.first, nc.second);
}
}
else {
for (symbol const& s : m_cmds) {
cmd * c = ctx.find_cmd(s);
SASSERT(c);
display_cmd(ctx, s, c);
}
}
ctx.regular_stream() << "\"\n";
}
void displayThread(void *args)
{
BK_U8B *command;
BK_S8B *data;
BK_U8B len;
while(1)
{
if(msgQueueMsgReadNoWait(commandMQ,&command,&len))
{
if(len == 1)
{
display_cmd(*command);
}
BK_free(command);
}
if(msgQueueMsgReadNoWait(dataMQ,&data,&len))
{
if(len > 2)
{
if(*data != -1)
{
display_cursor(data[0],data[1]);
data ++;
len -=2;
}
data++;
while(len > 0)
{
display_data(*data);
len--;
data++;
}
}
}
done();
}
}
void scheduler(void)
{
BK_U8B i;
static BK_U8B idelFlag=1;
if(CTBK_curThread != NULL)
{
//Nachschauen ob der status des aktuellen Threads auf T_FRUN steht und damit der Thread nicht unterbrochen werden kann.
if(CTBK_curThread->status == T_FRUN)
{
//������berpr������fen ob der Thread mehr wie 3 Zeitslots im T_FRUN Status ist.
if(CTBK_curThread->fRunUsed >3)
{
CTBK_curThread->status = T_BRK;//Thread in status broken setzen da sonst der Scheduler zu lange blockiert wird.
}
else
{
CTBK_curThread->fRunUsed++;//fRunUsed inkrementieren damit ������berpr������ft werden kann ob ein Thread den Scheduler dauerhaft blockiert.
return;
}
}
}
if(idelFlag == 1)
{
BK_idelSP = BK_curThreadSP;
idelFlag = 0;
}
if(CTBK_curThread != NULL)
{
CTBK_curThread->saveStackPointer = BK_curThreadSP;
if(CTBK_curThread->saveStackPointer < CTBK_curThread->stackFrame) //Pr������fen ob Stackframe unterschritten wurde.
{
display_cmd(DISPLAY_CLEAR);
display_error_printf("ERROR: Stackframe ueberlaufen von Thread");// %i",curThread->id);
BK_curThreadSP = BK_isrSP;//Zur������ck zur main.
return;
}
if(CTBK_curThread->status == T_END)
{
threadListDel(&BK_threads[CTBK_curThread->prio-1],CTBK_curThread->id);
}
}
CTBK_curThread = NULL;
checkNewThreads();//������berpr������fen ob neue Threads angelegt wurden.
checkSemaphoren();//������berprufen ob Semaphoren freigegeben wurden die Threads blockieren.
if(BK_fromDone == FALSE)
{
timeing();
}
else
{
BK_fromDone = FALSE;
}
for(i = 0; i < 8 ;i++)
{
if((CTBK_curThread = threadListAktThdShiftEnd(&BK_threads[calcPrio()-1]))!=NULL)//Errechnet die neue Priorit������t und w������hlt den n������chsten Thread mit Status T_RUN der errechneten Priorit������t aus.)
{
break;
}
}
if(CTBK_curThread == NULL) //Wenn curThrad jetzt NULL ist sind alle Threads im T_SLE modus d.h. der idelthread muss aktiviert werden.
{
BK_curThreadSP = BK_idelSP;
CTBK_curThread = NULL;
idelFlag = 1;
}
else
{
BK_curThreadSP = CTBK_curThread->saveStackPointer;
}
}
static void refresh_cmd_win(void)
{
display_cmd(cmd_cmd, cmd_len, cmd_cursor_pos);
}
/*!
* Löscht das ganze Display
*/
void display_clear(void){
display_cmd(DISPLAY_CLEAR); // Display l�schen, Cursor Home
}
