void main(void) {
byte len, i;
char msg[1];
int value;
initSquareWear();
setModeOutput(pinC7);
latC7 = 0;
openUSBSerial(); // open USB serial port
putrsUSBSerial("Type a single digit number:\r\n");
while(1) {
len=getUSBSerial(msg, 1); // get one character from USB serial
if(len!=0 && msg[0]>='0' && msg[0]<='9') {
value = msg[0]-'0'; // extract value
if (value<10) {
putrsUSBSerial("On for ");
putnUSBSerial(msg, 1);
putrsUSBSerial(" seconds.\r\n");
latC7 = 1;
delaySeconds(value);
latC7 = 0;
}
}
pollUSBSerial();
}
}
// This function is called over and over in an infinite loop.
void loop(void) {
if (HIGH == digitalRead(LED1)) {
digitalWrite(LED1, LOW);
digitalWrite(LED2, HIGH);
} else {
digitalWrite(LED1, HIGH);
digitalWrite(LED2, LOW);
}
delaySeconds(1);
}
void main(void) {
char msg[6];
int counter=0;
initSquareWear();
// open USART, default baud rate 57600 (defined in SquareWear.h)
openUSART();
putrsUSART("Begin.\r\n"); // write a constant string
while(1) {
itoa(counter, msg);
putsUSART(msg); // write a string
putrsUSART("\r\n");
latC7 = !latC7;
delaySeconds(1);
counter++;
}
}
void main(void)
{
int32 count = 0;
printf("Written by David Manouchehri\n\r");
while(1)
{
signed int i;
for (i = 7; i >= 0; i--)
{
printf("i is %d\n\r", i);
binaryLEDs(i);
delaySeconds(2);
}
//Routine stuff
printf("Number of runs: %ld\n\r", count);
count++;
//delaySeconds(1);
}
}
void main(void) {
char msg[1];
int value;
initSquareWear();
latC7 = 0;
openUSART();
putrsUSART("Type a single digit number:\r\n");
while(1) {
getsUSART(msg, 1);
if(msg[0]>='0' && msg[0]<='9') {
value = msg[0]-'0';
if (value<10) {
putrsUSART("On for ");
WriteUSART(msg[0]);
putrsUSART(" seconds.\r\n");
latC7 = 1;
delaySeconds(value);
latC7 = 0;
}
}
}
}
/**
* Pause the task for a specified time.
*
* Pause the execution of the program for a specified period of time given in
* seconds.
* Motors will continue to run at their last assigned values, and sensors will
* continue to
* update. Only the task containing the wait will pause until the wait time is
* expired.
*
* @param seconds Length of time to pause, in seconds.
*/
void Wait(double seconds) {
if (seconds < 0.0) return;
delaySeconds(seconds);
}
void main(void)
{
int32 count = 0;
unsigned long int reading, average, total;
float readingVolts;
unsigned long int history[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
printf("Written by David Manouchehri\n\r");
setup_adc_ports(RA0_ANALOG);
setup_adc(ADC_CLOCK_INTERNAL);
set_adc_channel(0);
delay_us(10);
while(1)
{
reading = read_adc();
readingVolts = (reading * 5.0)/255;
delay_us(10);
//printf("Reading is %lu = %4.2f Volts (float)\r\n", reading, readingVolts);
if(readingVolts >= 3.33)
{
singleLED(0, 1);
singleLED(1, 0);
singleLED(2, 0);
}
else if(readingVolts >= 1.66)
{
singleLED(1, 1);
singleLED(0, 0);
singleLED(2, 0);
}
else
{
singleLED(2, 1);
singleLED(0, 0);
singleLED(1, 0);
}
//history[9] = 1;
for (int i = 0; i < 10; i++)
{
history[i] = history[i + 1];
}
history[9] = reading;
average = 0;
for (int j = 0; j < 10; j++)
{
average += history[j];
unsigned long int tempy = history[j];
//printf(" %lu ", tempy);
}
//printf(" Done\r\n");
delaySeconds(1);
printf(" %lu ", average);
/*singleLED(5, 0);
singleLED(3, 1);
delay_ms(reading);
singleLED(3, 0);
singleLED(4, 1);
delay_ms(reading);
singleLED(4, 0);
singleLED(5, 1);
delay_ms(reading);*/
//delay_ms(100);
//flipLED(0);
//Routine stuff
//printf("Number of runs: %ld\n\r", count);
count++;
//delay_ms(100);
}
}
void MainWindow::processImage()
{
// Checking if we can process something at all.
if (processingMat.empty())
return;
// 1. Localizing centers of holes.
// Circle structuring element.
int size = 44;
cv::Mat circleElement = MatFiguresGenerator::ring(size);
// For localizing centers result.
cv::Mat centersResult;
// Applying erosion with hole ring.
cv::erode(processingMat, centersResult, circleElement);
// Showing result of the operation.
renderMat(centersResult);
delaySeconds(1);
// 2. Creating big octagons to fill holes.
// Octagon structuring element.
size = 39;
cv::Mat octagonElement = MatFiguresGenerator::octagon(size);
// To store result of the op.
cv::Mat octagonsResult;
// Making centers of holes bigger.
cv::dilate(centersResult, octagonsResult, octagonElement);
// Showing result.
renderMat(octagonsResult);
delaySeconds(1);
// 3. Filling holes.
// To store result.
cv::Mat holesHideResult;
// Adding holes' patches.
cv::bitwise_or(processingMat, octagonsResult, holesHideResult);
// Result.
renderMat(holesHideResult);
delaySeconds(1);
// 4. Outer rings.
// Setting radius of the structuring loop.
size = 117;
cv::Mat teethCircleResult;
// Getting loop without teeth.
cv::Mat gearBody = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(size, size), cv::Point(size / 2, size / 2));
cv::morphologyEx(holesHideResult, teethCircleResult, cv::MORPH_OPEN, gearBody);
// To store the biggest loop.
cv::Mat teethOuterResult;
// Enlarging previous loop to include teeth.
cv::Mat samplingRingSpacer = MatFiguresGenerator::ring(5);
cv::dilate(teethCircleResult, teethCircleResult, samplingRingSpacer);
// Enlarging outer loop to include outer part of teeth.
cv::Mat samplingRingWidth = MatFiguresGenerator::ring(5);
cv::dilate(teethCircleResult, teethOuterResult, samplingRingSpacer);
// Excluding smaller loop from the bigger one to get the circle containing teeth.
cv::bitwise_xor(teethOuterResult, teethCircleResult, teethCircleResult);
// Showing.
renderMat(teethCircleResult);
delaySeconds(1);
// 5. Teeth position.
// To store all teeth here.
cv::Mat teethResult;
// Getting an intersection of teeth and covering circle.
cv::bitwise_and(processingMat, teethCircleResult, teethResult);
renderMat(teethResult);
delaySeconds(1);
// 6. Faults detection.
// For result.
cv::Mat faultsResult;
// Optimal detection structure.
size = 6;
cv::Mat tipSpacing = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(size, size), cv::Point(size / 2, size / 2));
cv::dilate(teethResult, faultsResult, tipSpacing);
// Showing.
renderMat(faultsResult);
delaySeconds(1);
// 7. Faults highlighting.
// For final result.
cv::Mat faultsHighlightingResult;
// First action - subtracting.
cv::subtract(teethCircleResult, faultsResult, faultsHighlightingResult);
// Highlighting struct. element.
size = 15;
cv::Mat defectCue = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(size, size), cv::Point(size / 2, size / 2));
cv::dilate(faultsHighlightingResult, faultsHighlightingResult, defectCue);
cv::bitwise_or(faultsHighlightingResult, faultsResult, faultsHighlightingResult);
renderMat(faultsHighlightingResult);
}
