Get help from the best in academic writing.

milestone three!

OverviewIn this lab, you will use TI Code Composer Studio (CCS) to program the TC CC3220x LAUNCHXL to send a Morse code message via the LED using a synchronous state machine. This work will build on the concepts you learned during your activities in the zyBook this week.
During this milestone, you will use CCS to edit, compile, and load code into the CC32xx board. You will then proceed to use it for debugging. Throughout this process, you explore the components of a CCS project and the CCS code generator (system config). You will also be able to learn more about the timer and interrupt drivers.
Goal: Your objective is to blink the green, yellow, and red LEDs in the lower right corner of the board (the corner opposite the USB connector). Design a synchronous state machine that creates a pattern of blinking lights from the LEDs. This pattern should contain a message in Morse code. When a button is pressed, the Morse code message of the blinking LEDs should change.
PromptBegin your work by accessing the Milestone Three Timer Interrupt Lab Guide PDF document. While this document was written for a Windows interface, the tools can be used on Mac or Linux as well. You may also watch the Project Example Video or its transcript Word Document to gain a better understanding of what you are creating. Note that to accomplish the work outlined in the guide, you will need the following:
TI Code Composer Studio (installed)
USB connection between the PC and board
Specifically, you must address the following rubric criteria:
Develop code for all of the specified functionality. The goal of this criteria is for the code to result in the expected functionality (note how this is different from the state machine functionality). This includes functionality of both the state machine and the button change.
Create code that initializes the timer and uses it to drive the state machine.
Create code that uses interrupt to detect button presses. Make sure that the interrupts used to detect button presses have a result that is used by the state machine.
Implement (in code) the state machine functionality described by your documentation. The goal of this criteria is for the code to accurately reflect the state machine documentation, rather than for it to have perfect functionality.
Create state machine documentation to describe the operation that matches the technical specifications. It must match all required functionality. This should be completed as a file and saved as a PDF.
Discuss the lab questions. Address all the questions thoroughly and thoughtfully, with supporting evidence from your work.
Apply coding best practices in formatting, commenting, and functional logic.
Guidelines for SubmissionYou will have four different file submissions for this milestone. Once you have completed your lab work, first zip your workspace and submit the zipped file for grading. Second, submit a maximum 1-minute video of the LEDs blinking Morse code on your board, along with you pushing a button to change the Morse code. You may wish to narrate your video to explain what is happening. If you encounter any difficulties filming the lights on your hardware component, please reach out to your instructor. Third, submit a document containing your answers to the questions from the Milestone Three Timer Interrupt Lab Guide. Finally, submit a state machine diagram completed using and exported in PDF format.

Hi Please check the instruction of the task. I also attached my attempt to do it, however there are

Please check the instruction of the task.

I also attached my attempt to do it, however there are some issues that I need to fix.
The attached zip file contains my attempt of the project, however The project only needs two files which are:
to generate the maze using stack and DFS
to solve the maze generated using DFS

Please check the attached instructions

you can use libraries to help solve this issue

Discussion: Paid Search Marketing

Programming Assignment Help How to boost in-store holiday purchases with paid search.
After reading the article, you are to write two paragraphs (5 sentences = 1 paragraph) about the article.
The paragraphs should include the following:
What did you learn from this article?
What was the most interesting item you took away from the article?
How you use the article information in your projects?
General feedback about this article.

CMSC 430 Project 2

Could someone help me fix the code below in cgywin64 to correct the errors in bold at the bottom Below is the description of the question, followed by the codes, and the errors in bold. Thank you so much for the help. Please modify the given code instead of making a new one.
The question involves modifying the syntactic analyzer for the attached compiler by adding to the existing grammar. The full grammar of the language is shown below. The highlighted portions of the grammar show what you must either modify or add to the existing grammar.
function_header {variable} body
IDENTIFIER : type IS statement
parameters: parameter {, parameter}
body: BEGIN statement END ;
expression ; |
REDUCE operator {statement} ENDREDUCE ; |
IF expression THEN statement ELSE statement ENDIF ; |
CASE expression IS {case} OTHERS ARROW statement ENDCASE ;
operator: ADDOP | MULOP
case: WHEN INT_LITERAL ARROW statement
( expression ) |
expression binary_operator expression |
NOTOP expression |
binary_operator: ADDOP | MULOP | REMOP | EXPOP | RELOP | ANDOP |OROP
In the above grammar, the red symbols are nonterminals, the blue symbols are terminals and the black punctuation are EBNF metasymbols. The braces denote repetition 0 or more times and the brackets denote optional. You must rewrite the grammar to eliminate the EBNF brace and bracket metasymbols and to incorporate the significance of parentheses, operator precedence and associativity for all operators. Among arithmetic operators the exponentiation operator has highest precedence following by the multiplying operators and then the adding operators. All relational operators have the same precedence. Among the binary logical operators, and has higher precedence than or. Of the categories of operators, the unary logical operator has highest precedence, the arithmetic operators have next highest precedence, followed by the relational operators and finally the binary logical operators. All operators except the exponentiation operator are left associative. The directives to specify precedence and associativity, such as %prec and %left, may not be used Your parser should be able to correctly parse any syntactically correct program without any problem. You must modify the syntactic analyzer to detect and recover from additional syntax errors using the semicolon as the synchronization token. To accomplish detecting additional errors an error production must be added to the function header, another to the variable declaration and a final one to the when clause of the case statement. Your bison input file should not produce any shift/reduce or reduce/reduce errors. Eliminating them can be difficult so the best strategy is not introduce any. That is best achieved by making small incremental additions to the grammar and ensuring that no addition introduces any such errors. An example of compilation listing output containing syntax errors is shown below:
1 — Multiple errors
3 function main a integer returns real; Syntax Error, Unexpected INTEGER, expecting ‘:’
4 b: integer is * 2; Syntax Error, Unexpected MULOP
5 c: real is 6.0;
6 begin
7 if a > c then
8 b 3.0; Syntax Error, Unexpected REAL_LITERAL, expecting ‘;’
9 else
10 b = 4.;
11 endif;
12 ; Syntax Error, Unexpected ‘;’, expecting END
Lexical Errors 0
Syntax Errors 4
Semantic Errors 0
// This file contains the bodies of the functions that produces the compilation// listing
#include #include
using namespace std;
#include “listing.h”
static int lineNumber;static string error = “”;static int totalErrors = 0;
static void displayErrors();
void firstLine(){lineNumber = 1;printf(“nM “,lineNumber);}
void nextLine(){displayErrors();lineNumber ;printf(“M “,lineNumber);}
int lastLine(){printf(“r”);displayErrors();printf(” n”);return totalErrors;} void appendError(ErrorCategories errorCategory, string message){string messages[] = { “Lexical Error, Invalid Character “, “”, “Semantic Error, “, “Semantic Error, Duplicate Identifier: “, “Semantic Error, Undeclared ” };
error = messages[errorCategory] message;totalErrors ;}
void displayErrors(){if (error != “”) printf(“%sn”, error.c_str());error = “”;}listing.h:
// This file contains the function prototypes for the functions that produce the // compilation listing
void firstLine();void nextLine();int lastLine();void appendError(ErrorCategories errorCategory, string message);
compile: scanner.o parser.o listing.og -o compile scanner.o parser.o listing.oscanner.o: scanner.c listing.h tokens.hg -c scanner.c
scanner.c: scanner.lflex scanner.lmv lex.yy.c scanner.c
parser.o: parser.c listing.h g -c parser.c
parser.c tokens.h: parser.ybison -d -v parser.ymv parser.ccp tokens.h
listing.o: listing.hg -c
using namespace std;
#include “listing.h”
int yylex();void yyerror(const char* message);
?fine parse.error verbose
function:function_header different_parameter body ;function_header:
FUNCTION IDENTIFIER diff_parameter RETURNS type ‘;’ ;different_parameter:different_parameter variable |;
variable:IDENTIFIER ‘:’ type IS statement_ ;
diff_parameter:diff_parameter RETURNS type ‘,’ |parameter ;
parameter:IDENTIFIER ‘:’ type |;
body:BEGIN_ statement_ END ‘;’ ;
statement_:statement ‘;’ |error ‘;’ ;statement:expression |REDUCE operator reductions ENDREDUCE |IF expression THEN statement_ ELSE statement_ ENDIF |CASE expression IS various_cases OTHERS ARROW statement_ ENDCASE ;reductions:reductions statement_ |;various_cases:various_cases case |;case: WHEN INT_LITERAL ARROW statement_ ;
expression:expression ANDOP relation |expression2;expression2:expression OROP relation |relation;relation:relation RELOP term |term;term:term ADDOP factor |factor ;factor:factor MULOP primary |factor REMOP |exponent ;exponent:factor EXPOP notion |notion;notion:notion NOT primary |primary;primary:'(‘ expression ‘)’ |INT_LITERAL | REAL_LITERAL | BOOL_LITERAL |IDENTIFIER ;%%void yyerror(const char* message){appendError(SYNTAX, message);}int main(int argc, char *argv[]){firstLine();yyparse();lastLine();return 0;}
/* This file contains flex input file */
%{#include #include
using namespace std;
#include “listing.h”#include “tokens.h”
%option noyywrap
ws [ tr] comment (“//”|”–“).*nid [A-Za-z](_?[A-Za-z0-9])*real {digit} .{digit}*([Ee][ -]?{digit} )?line [n]digit [0-9]int {digit} punc [(),:;]%%
{ws} { ECHO; }{comment} { ECHO; nextLine();}{line} { ECHO; nextLine();}” ” { ECHO; return(ADDOP); }”*” { ECHO; return(MULOP); }”=>” { ECHO; return(ARROW); }”” { ECHO; return(RELOP); }”>=” { ECHO; return(RELOP); }”<=" { ECHO; return(RELOP); }"-" { ECHO; return(ADDOP); }"/" { ECHO; return(MULOP); }"**" { ECHO; return(EXPOP); }"." { ECHO; return(MULOP); }rem { ECHO; return(REMOP); }or { ECHO; return(OROP); }not { ECHO; return(NOTOP); }case { ECHO; return(CASE); }else { ECHO; return(ELSE); }endcase { ECHO; return(ENDCASE); }others { ECHO; return(OTHERS); }endif { ECHO; return(ENDIF); }if { ECHO; return(IF); }real { ECHO; return(REAL); }then { ECHO; return(THEN); }when { ECHO; return(WHEN); }begin { ECHO; return(BEGIN_); }boolean { ECHO; return(BOOLEAN); }end { ECHO; return(END); }endreduce { ECHO; return(ENDREDUCE); }function { ECHO; return(FUNCTION); }integer { ECHO; return(INTEGER); }is { ECHO; return(IS); }reduce { ECHO; return (REDUCE); }returns { ECHO; return(RETURNS); }and { ECHO; return(ANDOP); }true { ECHO; return(BOOL_LITERAL); }false { ECHO; return(BOOL_LITERAL); }{id} { ECHO; return(IDENTIFIER);}{real} {ECHO; return(REAL_LITERAL);}{int} { ECHO; return(INT_LITERAL); }{punc} { ECHO; return(yytext[0]); }. { ECHO; appendError(LEXICAL, yytext); }%%tokens.h:
/* A Bison parser, made by GNU Bison 3.8.2. */
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program. If not, see . */
/* As a special exception, you may make a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn’t itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception.
This special exception was added by the Free Software Foundation in version 2.2 of Bison. */
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, especially those whose name start with YY_ or yy_. They are private implementation details that can be changed or removed. */
#ifndef YY_YY_PARSER_TAB_H_INCLUDED# define YY_YY_PARSER_TAB_H_INCLUDED/* Debug traces. */#ifndef YYDEBUG# define YYDEBUG 0#endif#if YYDEBUGextern int yydebug;#endif
/* Token kinds. */#ifndef YYTOKENTYPE# define YYTOKENTYPE enum yytokentype { YYEMPTY = -2, YYEOF = 0, /* “end of file” */ YYerror = 256, /* error */ YYUNDEF = 257, /* “invalid token” */ IDENTIFIER = 258, /* IDENTIFIER */ INT_LITERAL = 259, /* INT_LITERAL */ REAL_LITERAL = 260, /* REAL_LITERAL */ BOOL_LITERAL = 261, /* BOOL_LITERAL */ ADDOP = 262, /* ADDOP */ MULOP = 263, /* MULOP */ RELOP = 264, /* RELOP */ OROP = 265, /* OROP */ ANDOP = 266, /* ANDOP */ EXPOP = 267, /* EXPOP */ REMOP = 268, /* REMOP */ BEGIN_ = 269, /* BEGIN_ */ BOOLEAN = 270, /* BOOLEAN */ END = 271, /* END */ ENDREDUCE = 272, /* ENDREDUCE */ FUNCTION = 273, /* FUNCTION */ INTEGER = 274, /* INTEGER */ IS = 275, /* IS */ REDUCE = 276, /* REDUCE */ RETURNS = 277, /* RETURNS */ CASE = 278, /* CASE */ ELSE = 279, /* ELSE */ ARROW = 280, /* ARROW */ ENDCASE = 281, /* ENDCASE */ ENDIF = 282, /* ENDIF */ IF = 283, /* IF */ OTHERS = 284, /* OTHERS */ REAL = 285, /* REAL */ THEN = 286, /* THEN */ WHEN = 287, /* WHEN */ NOT = 288, /* NOT */ NOTOP = 289 }; typedef enum yytokentype yytoken_kind_t;#endif
/* Value type. */#if ! defined YYSTYPE

error: Content is protected !!