void ascii(char c) {
P1DIR |= BIT1;
uint8_t number_code[] = {
// 0b11111100, 0b01111100, 0b00111100, 0b00011100, 0b00001100, 0b00000100,
// 0b10000100, 0b11000100, 0b11100100, 0b11110100 // 0-9
0xfc, 0x7c, 0x3c, 0x1c, 0xc, 0x4, 0x84, 0xc4, 0xe4, 0xf4
};
uint8_t alphabet_code[] = {
// 0b01100000, 0b10001000, 0b10101000, 0b10010000, 0b01000000, 0b00101000,
// 0b11010000, 0b00001000, 0b00100000, 0b01111000, 0b10110000, 0b01001000,
// 0b11100000, 0b10100000, 0b11110000, 0b01101000, 0b11011000, 0b01010000,
// 0b00010000, 0b11000000, 0b00110000, 0b00011000, 0b01110000, 0b10011000,
// 0b10111000, 0b11001000 // A-Z
0x60, 0x88, 0xa8, 0x90, 0x40, 0x28, 0xd0, 0x8, 0x20, 0x78, 0xb0, 0x48, 0xe0, 0xa0, 0xf0, 0x68, 0xd8, 0x50, 0x10, 0xc0, 0x30, 0x18, 0x70, 0x98, 0xb8, 0xc8
};
if (c >= '0' && c <= '9') {
morse(number_code[c- '0']);
} else if (c >= 'a' && c <= 'z') {
morse(alphabet_code[c - 'a']);
} else if (c == ' ') {
space(7);
} else {
morse(done);
}
}
int adiv5_swdp_scan(void)
{
uint8_t ack;
target_list_free();
ADIv5_DP_t *dp = (void*)calloc(1, sizeof(*dp));
swdptap_init();
/* Read the SW-DP IDCODE register to syncronise */
/* This could be done with adiv_swdp_low_access(), but this doesn't
* allow the ack to be checked here. */
swdptap_seq_out(0xA5, 8);
ack = swdptap_seq_in(3);
if((ack != SWDP_ACK_OK) || swdptap_seq_in_parity(&dp->idcode, 32)) {
DEBUG("\n");
morse("NO TARGETS.", 1);
free(dp);
return -1;
}
dp->dp_read = adiv5_swdp_read;
dp->error = adiv5_swdp_error;
dp->low_access = adiv5_swdp_low_access;
dp->abort = adiv5_swdp_abort;
adiv5_swdp_error(dp);
adiv5_dp_init(dp);
if(!target_list) morse("NO TARGETS.", 1);
else morse(NULL, 0);
return target_list?1:0;
}
int main(void)
{
Morse morse(13);
while(true)
{
morse.dot(); morse.dot(); morse.dot();
morse.dash(); morse.dash(); morse.dash();
morse.dot(); morse.dot(); morse.dot();
delay(3000);
}
}
void morse(int longCode, int shortCode, int nth) {
int i, tempX, count, cases[300];
if ( nth == 1) {
//printf("\nBase Case\n");
for (i = 0; i < longCode; i++)
printf("a");
//printf("%c", 45);
for (i = 0; i < shortCode; i++)
printf("b");
//printf("%c", 111);
printf("\n");
return;
}
tempX = longCode+shortCode;
for (i=longCode; i>=0; i--) {
cases[i] = composition( tempX-1, shortCode-1);
tempX--;
//printf("%d\n",cases[i]);
}
/*
printf("\n");
for (i = 0; i <= longCode; i++)
printf("%d ", cases[i]);
printf("\n");
*/
for (count = 0; count <= longCode; count++) {
nth -= cases[count];
//printf("%d ", nth);
if (nth <= 0) {
nth += cases[count];
break;
}
}
//printf("%d %d\n\n", count, nth);
for (i = 0; i < longCode - count; i++)
printf("a");
//printf("%c", 45);
printf("b");
//printf("%c", 111);
morse(longCode-i, shortCode-1, nth);
}
int main () {
int numcases, longCode, shortCode, nth;
int i, tempX, count, cases[100];
scanf("%d", &numcases);
while(numcases--) {
scanf("%d %d %d", &longCode, &shortCode, &nth);
//printf("%d %d %d %d\n", numcases, longCode, shortCode, nth);
morse(longCode, shortCode, nth);
}
return 0;
}
int main()
{
create_connect();
enable_servo(ccport);
create_full();
start_morse();
morse("Botball", 1);
/* motor(1,100);
motor(0,-100);
motor(1,0);
msleep(5000);
motor(3,100);
wait_for_morse();
motor(0,0);
motor(3,0);
*/
create_disconnect();
}
void translate_morse(char *in,char*out)
{
int i,j,k=0;
char morseaux[8];
for(i=0;i<strlen(in)-2;i++)
for(i=0;i<strlen(in)-2;i++)
{
morse(in[i],morseaux);
for(j=0;j<strlen(morseaux);j++)
{
out[k] = morseaux[j];
k++;
}
out[k]= '#';
k++;
}
out[k] = '\0';
}
int
main(int argc, char **argv)
{
int ch, lflags;
char *p, *codeset;
while ((ch = getopt(argc, argv, GETOPTOPTS)) != -1)
switch ((char) ch) {
case 'c':
cpm = atoi(optarg);
break;
case 'd':
device = optarg;
break;
case 'e':
eflag = 1;
setvbuf(stdout, 0, _IONBF, 0);
break;
case 'f':
freq = atoi(optarg);
break;
case 'l':
lflag = 1;
break;
#ifdef SPEAKER
case 'p':
pflag = 1;
break;
#endif
case 's':
sflag = 1;
break;
case 'w':
wpm = atoi(optarg);
break;
case '?':
default:
fputs(USAGE, stderr);
exit(1);
}
if (sflag && lflag) {
fputs("morse: only one of -l and -s allowed\n", stderr);
exit(1);
}
if ((pflag || device) && (sflag || lflag)) {
fputs("morse: only one of -p, -d and -l, -s allowed\n", stderr);
exit(1);
}
if (cpm == 0)
cpm = wpm;
if ((pflag || device) && ((wpm < 1) || (wpm > 60) || (cpm < 1) || (cpm > 60))) {
fputs("morse: insane speed\n", stderr);
exit(1);
}
if ((pflag || device) && (freq == 0))
freq = FREQUENCY;
#ifdef SPEAKER
if (pflag) {
if ((spkr = open(SPEAKER, O_WRONLY, 0)) == -1) {
perror(SPEAKER);
exit(1);
}
} else
#endif
if (device) {
if ((line = open(device, O_WRONLY | O_NONBLOCK)) == -1) {
perror("open tty line");
exit(1);
}
if (tcgetattr(line, &otty) == -1) {
perror("tcgetattr() failed");
exit(1);
}
ntty = otty;
ntty.c_cflag |= CLOCAL;
tcsetattr(line, TCSANOW, &ntty);
lflags = fcntl(line, F_GETFL);
lflags &= ~O_NONBLOCK;
fcntl(line, F_SETFL, &lflags);
ioctl(line, TIOCMGET, &lflags);
lflags &= ~TIOCM_RTS;
olflags = lflags;
ioctl(line, TIOCMSET, &lflags);
(void)signal(SIGHUP, sighandler);
(void)signal(SIGINT, sighandler);
(void)signal(SIGQUIT, sighandler);
(void)signal(SIGTERM, sighandler);
}
if (pflag || device) {
dot_clock = wpm / 2.4; /* dots/sec */
dot_clock = 1 / dot_clock; /* duration of a dot */
dot_clock = dot_clock / 2; /* dot_clock runs at twice */
/* the dot rate */
dot_clock = dot_clock * 100; /* scale for ioctl */
cdot_clock = cpm / 2.4; /* dots/sec */
cdot_clock = 1 / cdot_clock; /* duration of a dot */
cdot_clock = cdot_clock / 2; /* dot_clock runs at twice */
/* the dot rate */
cdot_clock = cdot_clock * 100; /* scale for ioctl */
}
argc -= optind;
argv += optind;
if (setlocale(LC_CTYPE, "") != NULL &&
*(codeset = nl_langinfo(CODESET)) != '\0') {
if (strcmp(codeset, "KOI8-R") == 0)
hightab = koi8rtab;
else if (strcmp(codeset, "ISO8859-1") == 0 ||
strcmp(codeset, "ISO8859-15") == 0)
hightab = iso8859_1tab;
else if (strcmp(codeset, "ISO8859-7") == 0)
hightab = iso8859_7tab;
}
if (lflag)
printf("m");
if (*argv) {
do {
for (p = *argv; *p; ++p) {
if (eflag)
putchar(*p);
morse(*p);
}
if (eflag)
putchar(' ');
morse(' ');
} while (*++argv);
} else {
while ((ch = getchar()) != EOF) {
if (eflag)
putchar(ch);
morse(ch);
}
}
if (device)
tcsetattr(line, TCSANOW, &otty);
exit(0);
}
void loop() {
morse("sos", 255, 0, 0); // red 'sos'
morse("arduino", 100, 255, 100); // light green 'arduino'
}
int main(int argc, char **argv)
{
int ret, n;
unsigned char drive = 8;
CBM_FILE f;
char buffer[80];
char *devicetype_str;
const char *drivername;
enum cbm_device_type_e devicetype;
int checklines = 0;
int checkiohook = 0;
if (argc>1)
{
int i;
for (i=0; i < argc; i++)
{
switch (argv[i][0])
{
case '-':
checklines = 1;
break;
case '+':
checkiohook = 1;
break;
default:
drive = atoi(argv[i]);
}
}
}
printf("VDDTEST " __DATE__ " " __TIME__ ", using drive %u\n", drive);
if (vdd_init())
{
printf("Could not initialize the VDD, aborting!\n");
exit(1);
}
drivername = cbm_get_driver_name(0);
printf("cbm_get_driver_name() returned %s.\n", drivername);
ret = cbm_driver_open(&f, 0);
if (ret)
{
printf("cbm_driver_open FAILED!\n");
exit(1);
}
printf("cbm_driver_open success!\n\n");
n = cbm_reset(f);
printf("cbm_reset %s\n", n==0 ? "success" : "FAILED");
if (checklines)
{
changelines(f);
}
n = cbm_device_status(f, drive, buffer, sizeof(buffer));
printf("cbm_device_status returned: %u\n%s\n\n", n, buffer);
n = cbm_open(f, drive, 15, "I0", 0);
printf("cbm_open %u,15,\"I0\" %s!\n", drive, n == 0 ? "success" : "FAILED");
n = cbm_close(f, drive, 15);
printf("cbm_close %s!\n", n == 0 ? "success" : "FAILED");
n = own_device_status(f, drive, buffer, sizeof(buffer));
printf("own_device_status returned: %u\n%s\n\n", n, buffer);
n = cbm_identify(f, drive, &devicetype, &devicetype_str);
printf("cbm_identify %s!\n", n==0 ? "success" : "FAILED");
printf("cbm_identify returned: %u - '%s'.\n\n", (unsigned int) devicetype,
devicetype_str);
n = cbm_exec_command(f, drive, "S0:OPENCBM.VDD", 0);
printf("cbm_exec_command(scratch) %s!\n", n==0 ? "success" : "FAILED");
writefile(f, drive, "OPENCBM.VDD,S,W");
readfile(f, drive, "OPENCBM.VDD,S,R");
morse(f, drive);
if (checkiohook)
{
unsigned int base = 0x0fc0;
printf("trying to install iohook at 0x%08x ", base);
if (vdd_install_iohook(f, base, 1))
{
int i;
printf("success\n");
for (i=0; i<15; i++)
{
outportb(base + 2, i);
sleep(1);
}
printf("trying to uninstall iohook ");
if (vdd_uninstall_iohook(f))
{
printf("success\n");
}
else
{
printf("FAILED\n");
}
}
else
{
printf("FAILED\n");
}
}
cbm_driver_close(f);
printf("cbm_driver_close success!\n");
return 0;
}
int gdb_main_loop(struct target_controller *tc, bool in_syscall)
{
int size;
bool single_step = false;
/* GDB protocol main loop */
while(1) {
SET_IDLE_STATE(1);
size = gdb_getpacket(pbuf, BUF_SIZE);
SET_IDLE_STATE(0);
switch(pbuf[0]) {
/* Implementation of these is mandatory! */
case 'g': { /* 'g': Read general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
target_regs_read(cur_target, arm_regs);
gdb_putpacket(hexify(pbuf, arm_regs, sizeof(arm_regs)),
sizeof(arm_regs) * 2);
break;
}
case 'm': { /* 'm addr,len': Read len bytes from addr */
uint32_t addr, len;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "m%" SCNx32 ",%" SCNx32, &addr, &len);
if (len > sizeof(pbuf) / 2) {
gdb_putpacketz("E02");
break;
}
DEBUG("m packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
if (target_mem_read(cur_target, mem, addr, len))
gdb_putpacketz("E01");
else
gdb_putpacket(hexify(pbuf, mem, len), len*2);
break;
}
case 'G': { /* 'G XX': Write general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
unhexify(arm_regs, &pbuf[1], sizeof(arm_regs));
target_regs_write(cur_target, arm_regs);
gdb_putpacketz("OK");
break;
}
case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
uint32_t addr, len;
int hex;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "M%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &hex);
if (len > (unsigned)(size - hex) / 2) {
gdb_putpacketz("E02");
break;
}
DEBUG("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
unhexify(mem, pbuf + hex, len);
if (target_mem_write(cur_target, addr, mem, len))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 's': /* 's [addr]': Single step [start at addr] */
single_step = true;
/* fall through */
case 'c': /* 'c [addr]': Continue [at addr] */
if(!cur_target) {
gdb_putpacketz("X1D");
break;
}
target_halt_resume(cur_target, single_step);
SET_RUN_STATE(1);
single_step = false;
/* fall through */
case '?': { /* '?': Request reason for target halt */
/* This packet isn't documented as being mandatory,
* but GDB doesn't work without it. */
target_addr watch;
enum target_halt_reason reason;
if(!cur_target) {
/* Report "target exited" if no target */
gdb_putpacketz("W00");
break;
}
/* Wait for target halt */
while(!(reason = target_halt_poll(cur_target, &watch))) {
unsigned char c = gdb_if_getchar_to(0);
if((c == '\x03') || (c == '\x04')) {
target_halt_request(cur_target);
}
}
SET_RUN_STATE(0);
/* Translate reason to GDB signal */
switch (reason) {
case TARGET_HALT_ERROR:
gdb_putpacket_f("X%02X", GDB_SIGLOST);
morse("TARGET LOST.", true);
break;
case TARGET_HALT_REQUEST:
gdb_putpacket_f("T%02X", GDB_SIGINT);
break;
case TARGET_HALT_WATCHPOINT:
gdb_putpacket_f("T%02Xwatch:%08X;", GDB_SIGTRAP, watch);
break;
case TARGET_HALT_FAULT:
gdb_putpacket_f("T%02X", GDB_SIGSEGV);
break;
default:
gdb_putpacket_f("T%02X", GDB_SIGTRAP);
}
break;
}
case 'F': /* Semihosting call finished */
if (in_syscall) {
return hostio_reply(tc, pbuf, size);
} else {
DEBUG("*** F packet when not in syscall! '%s'\n", pbuf);
gdb_putpacketz("");
}
break;
/* Optional GDB packet support */
case '!': /* Enable Extended GDB Protocol. */
/* This doesn't do anything, we support the extended
* protocol anyway, but GDB will never send us a 'R'
* packet unless we answer 'OK' here.
*/
gdb_putpacketz("OK");
break;
case 0x04:
case 'D': /* GDB 'detach' command. */
if(cur_target)
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
gdb_putpacketz("OK");
break;
case 'k': /* Kill the target */
if(cur_target) {
target_reset(cur_target);
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
}
break;
case 'r': /* Reset the target system */
case 'R': /* Restart the target program */
if(cur_target)
target_reset(cur_target);
else if(last_target) {
cur_target = target_attach(last_target,
&gdb_controller);
target_reset(cur_target);
}
break;
case 'X': { /* 'X addr,len:XX': Write binary data to addr */
uint32_t addr, len;
int bin;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "X%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &bin);
if (len > (unsigned)(size - bin)) {
gdb_putpacketz("E02");
break;
}
DEBUG("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
if (target_mem_write(cur_target, addr, pbuf+bin, len))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 'q': /* General query packet */
handle_q_packet(pbuf, size);
break;
case 'v': /* General query packet */
handle_v_packet(pbuf, size);
break;
/* These packet implement hardware break-/watchpoints */
case 'Z': /* Z type,addr,len: Set breakpoint packet */
case 'z': /* z type,addr,len: Clear breakpoint packet */
ERROR_IF_NO_TARGET();
handle_z_packet(pbuf, size);
break;
default: /* Packet not implemented */
DEBUG("*** Unsupported packet: %s\n", pbuf);
gdb_putpacketz("");
}
}
}
DWORD makeFrame(int type, unsigned char *data)
{
int ret,i,j,k;
struct Frame *f;
unsigned char *in_morse;
unsigned short crc;
//la cabecera sera igual para todos
char head[5] = {DLE,SYN,DLE,SYN,DLE};
in_morse = (unsigned char*) malloc(sizeof(unsigned char)*8);
f = (struct Frame*) malloc(sizeof(Frame));
f->length = 0;
//ponemos la cabecera que sera igual para todos indistintamente
for(i=0;i<5;i++)
{
f->body[i]= head[i];
f->length++;
}
switch(type)//dependiendo del tipo de trama...
{
case enqFrame://ENQ
f->body[i] = ENQ;
i++;
f->length++;
f->type = enqFrame;
break;
case ackFrame://ACK
f->body[i] = ACK;
i++;
f->length++;
f->type = ackFrame;
break;
case eotFrame://EOT
f->body[i] = EOT;
i++;
f->length++;
f->type = eotFrame;
break;
case dataFrame://DATA
f->body[i] = SOH;//inicio cabecera de datos
i++;
f->length++;
if(nSecuenceNext == 0)//numero de sencuencia
{
f->body[i] = '0';
}
else
{
f->body[i] = '1';
}
f->nSecuence = nSecuenceNext;
i++;
f->length++;
f->body[i] = DLE;//DLE
i++;
f->length++;
f->body[i] = STX;//inicio de datos
i++;
f->length++;
for(j=0;j< strlen(data);j++)//datos de la trama
{
f->body[i] = data[j];
if(data[j] == DLE)//si aparece DLE en el texto, este mismo se duplica
{
f->body[i+1] = DLE;
i++;
f->length++;
}
i++;
f->length++;
}
f->body[i] = DLE;//DLE anterior a ETX
i++;
f->length++;
f->body[i] = ETX;//fin de datos
i++;
f->length++;
//codigo de control de errores CRC
strcat(data,"\0");
crc =icrc(0,(unsigned char *)data,strlen(data), 255, -1);
f->body[i]=LOBYTE(crc);
f->body[i+1]=HIBYTE(crc);
f->length = f->length +2;
f->type = dataFrame;
break;
case morseFrame:
f->body[i] = SOH;//inicio cabecera de datos
i++;
f->length++;
if(nSecuenceWait == 0)//numero de sencuencia
{
f->body[i] = '0';
}
else
{
f->body[i] = '1';
}
f->nSecuence = nSecuenceWait;
i++;
f->length++;
f->body[i] = DLE;//DLE
i++;
f->length++;
f->body[i] = STX;//inicio de datos
i++;
f->length++;
//datos en morse
for(j=0;j<(strlen(data));j++)
{
morse(data[j],in_morse);//llama la funcion que traduce a morse
for(k=0;k<strlen(in_morse);k++)
{
f->body[i] = in_morse[k];
if(data[j] == DLE)//si aparece DLE en el texto, este mismo se duplica
{
f->body[i+1] = DLE;
i++;
f->length++;
}
i++;
f->length++;
}
//caracter de separacion entre cada palabra de morse
f->body[i] = '#';
i++;
f->length++;
}
f->body[i] = DLE;//DLE anterior a ETX
i++;
f->length++;
f->body[i] = ETX;//fin de datos
i++;
f->length++;
//codigo de control de errores CRC
catchData(f);
crc =icrc(0,(unsigned char *)f->data,strlen(f->data), 255, -1);
f->body[i]=LOBYTE(crc);
f->body[i+1]=HIBYTE(crc);
f->length = f->length +2;
f->type = dataFrame;
break;
}
//trama creada, procedemos a enviarla
ret = sendFrame(*f);
return ret;//devolvemos lo que nos devuelve la funcion de enviar la trama
}
