/*---------------------------------------------------------------------------*/
void
felicia_spi_init(void)
{
/* Initialize ring buffers for RX and TX data */
ringbuf_init(&spi_rx_buf, rxbuf_data, sizeof(rxbuf_data));
ringbuf_init(&spi_tx_buf, txbuf_data, sizeof(txbuf_data));
/* Configre SSI interface and init TX FIFO */
ssi_reconfigure(1);
/* Set the mux correctly to connect the SSI pins to the correct GPIO pins */
/* set input pin with ioc */
REG(IOC_CLK_SSIIN_SSI0) = ioc_input_sel(SPI_CLK_PORT, SPI_CLK_PIN);
REG(IOC_SSIFSSIN_SSI0) = ioc_input_sel(SPI_SEL_PORT, SPI_SEL_PIN);
REG(IOC_SSIRXD_SSI0) = ioc_input_sel(SPI_MOSI_PORT, SPI_MOSI_PIN);
/* set output pin */
ioc_set_sel(SPI_MISO_PORT, SPI_MISO_PIN, IOC_PXX_SEL_SSI0_TXD);
/* Set pins as input and MISo as output */
GPIO_SET_INPUT(SPI_CLK_PORT_BASE, SPI_CLK_PIN_MASK);
GPIO_SET_INPUT(SPI_MOSI_PORT_BASE, SPI_MOSI_PIN_MASK);
GPIO_SET_INPUT(SPI_SEL_PORT_BASE, SPI_SEL_PIN_MASK); /* it seems that setting SEL as input is not necessary */
GPIO_SET_OUTPUT(SPI_MISO_PORT_BASE, SPI_MISO_PIN_MASK);
/* Put all the SSI gpios into peripheral mode */
GPIO_PERIPHERAL_CONTROL(SPI_CLK_PORT_BASE, SPI_CLK_PIN_MASK);
GPIO_PERIPHERAL_CONTROL(SPI_MOSI_PORT_BASE, SPI_MOSI_PIN_MASK);
GPIO_PERIPHERAL_CONTROL(SPI_MISO_PORT_BASE, SPI_MISO_PIN_MASK);
GPIO_PERIPHERAL_CONTROL(SPI_SEL_PORT_BASE, SPI_SEL_PIN_MASK); /* it seems that setting SEL: as peripheral controlled is not necessary */
/* Disable any pull ups or the like */
ioc_set_over(SPI_CLK_PORT, SPI_CLK_PIN, IOC_OVERRIDE_DIS);
ioc_set_over(SPI_MOSI_PORT, SPI_MOSI_PIN, IOC_OVERRIDE_DIS);
ioc_set_over(SPI_MISO_PORT, SPI_MISO_PIN, IOC_OVERRIDE_DIS);
ioc_set_over(SPI_SEL_PORT, SPI_SEL_PIN, IOC_OVERRIDE_PDE); /* it seems that configuring pull-ups/downs on SEL is not necessary */
/* Configure output INT pin (from Felicia to Host */
GPIO_SET_OUTPUT(SPI_INT_PORT_BASE, SPI_INT_PIN_MASK);
GPIO_CLR_PIN(SPI_INT_PORT_BASE, SPI_INT_PIN_MASK);
/* Configure CS pin and detection for both edges on that pin */
GPIO_SOFTWARE_CONTROL(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK);
GPIO_SET_INPUT(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK);
GPIO_DETECT_EDGE(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK);
GPIO_TRIGGER_BOTH_EDGES(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK);
GPIO_ENABLE_INTERRUPT(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK);
ioc_set_over(SPI_CS_PORT, SPI_CS_PIN, IOC_OVERRIDE_PUE);
/* Enable interrupt form CS pin */
nvic_interrupt_enable(NVIC_INT_GPIO_PORT_B);
gpio_register_callback(cs_isr, SPI_CS_PORT, SPI_CS_PIN);
}
int main(void) {
OSC_init();
TRISA = 0b00000000;
TRISB = 0b00000011;
TRISC = 0b10000000;
ANCON0 = 0b11111111;
ANCON1 = 0b00011111;
INTCON2bits.RBPU = 0; // Pull-up enable
timer0_init(3);
UART_init();
uint8_t txbuf[100];
ringbuf_init(&tx_buf, txbuf, sizeof (txbuf));
INTCONbits.GIE = 1;
while (1) {
static int16_t prev_e;
if (encoder != prev_e) {
prev_e = encoder;
if (encoder < 0) {
tx_send('-');
tx_sendn(-encoder, 5);
tx_send('\n');
} else {
tx_sendn(encoder, 5);
tx_send('\n');
}
}
}
return 0;
}
/**
* Initalize the RS232 port.
*
*/
void
uart0_init(unsigned long ubr)
{
/* RS232 */
UCA0CTL1 |= UCSWRST; /* Hold peripheral in reset state */
UCA0CTL1 |= UCSSEL_2; /* CLK = SMCLK */
UCA0BR0 = 0x45; /* 8MHz/115200 = 69 = 0x45 */
UCA0BR1 = 0x00;
UCA0MCTL = UCBRS_3; /* Modulation UCBRSx = 3 */
P3DIR &= ~0x20; /* P3.5 = USCI_A0 RXD as input */
P3DIR |= 0x10; /* P3.4 = USCI_A0 TXD as output */
P3SEL |= 0x30; /* P3.4,5 = USCI_A0 TXD/RXD */
/*UCA0CTL1 &= ~UCSWRST;*/ /* Initialize USCI state machine */
transmitting = 0;
/* XXX Clear pending interrupts before enable */
IFG2 &= ~UCA0RXIFG;
IFG2 &= ~UCA0TXIFG;
UCA0CTL1 &= ~UCSWRST; /* Initialize USCI state machine **before** enabling interrupts */
IE2 |= UCA0RXIE; /* Enable UCA0 RX interrupt */
/* Enable USCI_A0 TX interrupts (if TX_WITH_INTERRUPT enabled) */
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
IE2 |= UCA0TXIE; /* Enable UCA0 TX interrupt */
#endif /* TX_WITH_INTERRUPT */
}
int32_t uart0_init(uint32_t boudrate)
{
mml_uart_config_t config;
mml_gpio_config_t gpio_config;
ringbuf_init(&gRevFifo[0], gRevBuffer0, sizeof(gRevBuffer0));
ringbuf_init(&gSendFifo[0], gSendBuffer0, sizeof(gSendBuffer0));
// rb_init(&gRevLb[0], gRevBuffer0, sizeof(gRevBuffer0));
// rb_init(&gSendLb[0], gSendBuffer0, sizeof(gSendBuffer0));
// UART0
gpio_config.gpio_function = MML_GPIO_SECODARY_ALT_FUNCTION;
gpio_config.gpio_pad_config = MML_GPIO_PAD_NORMAL;
mml_gpio_init(MML_GPIO_DEV0, 8, 1, gpio_config);
mml_gpio_init(MML_GPIO_DEV0, 9, 1, gpio_config);
config.baudrate = boudrate;
config.data_bits = MML_UART_DATA_TRANSFER_SIZE_8_BITS;
config.flwctrl = MML_UART_HW_FLOW_CTL_DISABLE;
config.parity = MML_UART_PARITY_NONE;
config.parity_mode = MML_UART_PARITY_MODE_ONES;
config.rts_ctl = MML_UART_RTS_IO_LEVEL_LOW;
config.stop_bits = MML_UART_STOPBITS_ONE;
config.handler = (mml_uart_handler_t)uart0_handler;
mml_uart_init(MML_UART_DEV0, config);
/** Disable interruption */
M_MML_UART_INTERRUPT_DISABLE(MML_UART_DEV0);
/** Clear all IRQ ... */
mml_uart_interrupt_clear(MML_UART_DEV0, ( MML_UART_ISR_FRAMIS_MASK |\
MML_UART_ISR_PARIS_MASK |\
MML_UART_ISR_SIGIS_MASK |\
MML_UART_ISR_OVERIS_MASK |\
MML_UART_ISR_FFRXIS_MASK |\
MML_UART_ISR_FFTXOIS_MASK |\
MML_UART_ISR_FFTXHIS_MASK ));
/** ... set wanted interruption(s) */
mml_uart_interrupt_set(MML_UART_DEV0, ( MML_UART_IER_FFTXOIE_MASK |\
MML_UART_IER_FFTXHIE_MASK |\
MML_UART_IER_FFRXIE_MASK |\
MML_UART_IER_OVERIE_MASK ));
mml_uart_interrupt_activate(MML_UART_DEV0, TRUE);
return 0;
}
void serial0_async_recv_init(size_t bufsize) {
char *buffer = malloc(sizeof(char) * bufsize);
ringbuf_init(&_serial0_async_recv_rbuf, buffer, bufsize, NULL, NULL);
bytes_until_callback = -1;
/* enable intterupt */
SET_BIT(UCSR0B, RXCIE0);
}
/*---------------------------------------------------------------------------*/
static int
init(void)
{
uart3_init(0);
uart3_set_input(xbee_input_handler);
ringbuf_init(&rxbuf, rxbuf_data, sizeof(rxbuf_data));
process_start(&xbee_process, NULL);
return 0;
}
int main(int argc, char **argv)
{
int i;
context_t ctx;
char *entry_hook_line =
"{exec {print-str ' entry:'} [var 0 0]"
"\n {while <is-le [var 0] 10>"
"\n {exec"
"\n {print-char 32}"
"\n {print-hex0 [reg [var 0]]}"
"\n {if <is-null [reg [var 0]]>"
"\n (break)"
"\n }"
"\n [var 0 (add [var 0] 1)]"
"\n }"
"\n }"
"\n (print-char 10)"
"\n}";
char *exit_hook_line =
"{exec {print-str ' exit:'} [var 0 0]"
"\n {while <is-le [var 0] 10>"
"\n {exec {print-str ' '} (print-hex0 [reg [var 0]]) [var 0 (add [var 0] 1)]}"
"\n }"
"\n (print-char 10)"
"\n}";
hook_p h;
if (strings_init(STRING_BUFF)
|| atoms_init(MAX_ATOMS)
|| symbols_init(MAX_SYMBOLS)
|| ringbuf_init(4096)
|| hooks_init(4, NULL, NULL)) return -1;
if (argc > 1) entry_hook_line = argv[1];
if (argc > 2) exit_hook_line = argv[2];
h = hook_install((uint_t)funnn, entry_hook_line, exit_hook_line, NULL, ringbuf_dump, splinter_test_mode);
if (!h) {
fprintf(stderr, "%s", splinter_error_get());
return -1;
}
h->enabled = 1;
memset(&ctx, 0, sizeof(ctx));
for(i = 0; i < 1; i++) {
context_call(&h->entry_chain, h, &ctx);
context_call(&h->exit_chain, h, &ctx);
context_close(h, &ctx);
}
dump_ringbuffer();
return 0;
}
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
void lufaInit(void)
{
/* activate specific usb config */
SetupHardware();
USB_Init();
//CDC_Device_CreateStream(&VirtualSerial_CDC0_Interface, &stdout);
ringbuf_init(&USARTtoUSB_Buffer, uarttousb, sizeof(uarttousb));
ringbuf_init(&USBtoUSART_Buffer, usbtouart, sizeof(uarttousb));
ringbuf_init(&serialRx_Buffer, serialRx, sizeof(serialRx));
callback = nothing;
/* restart jennic and set to normal mode. XXX needs serial line ops */
Serial_Config(1000000, 8, CDC_LINEENCODING_OneStopBit, CDC_PARITY_None);
Jennic_Set_Mode(false);
}
/**
* Initalize the RS232 port.
*
*/
void
uart1_init(unsigned long ubr)
{
/* RS232 */
P3DIR &= ~0x80; /* Select P37 for input (UART1RX) */
P3DIR |= 0x40; /* Select P36 for output (UART1TX) */
P3SEL |= 0xC0; /* Select P36,P37 for UART1{TX,RX} */
UCTL1 = SWRST | CHAR; /* 8-bit character, UART mode */
#if 0
U1RCTL &= ~URXEIE; /* even erroneous characters trigger interrupts */
#endif
UTCTL1 = SSEL1; /* UCLK = MCLK */
UBR01 = ubr;
UBR11 = ubr >> 8;
/*
* UMCTL1 values calculated using
* http://mspgcc.sourceforge.net/baudrate.html
* Table assumes that F_CPU = 2,457,600 Hz.
*/
switch(ubr) {
case UART1_BAUD2UBR(115200ul):
UMCTL1 = 0x4a;
break;
case UART1_BAUD2UBR(57600ul):
UMCTL1 = 0x5b;
break;
default:
/* 9600, 19200, 38400 don't require any correction */
UMCTL1 = 0x00;
}
ME2 &= ~USPIE1; /* USART1 SPI module disable */
ME2 |= (UTXE1 | URXE1); /* Enable USART1 TXD/RXD */
UCTL1 &= ~SWRST;
/* XXX Clear pending interrupts before enable!!! */
IFG2 &= ~URXIFG1;
U1TCTL |= URXSE;
rx_in_progress = 0;
transmitting = 0;
IE2 |= URXIE1; /* Enable USART1 RX interrupt */
#if TX_WITH_INTERRUPT
IE2 |= UTXIE1; /* Enable USART1 RX interrupt */
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
#endif /* TX_WITH_INTERRUPT */
}
CONSOLE::INSTANCE::INSTANCE(int t)
{
// init ringbuffers
history = ringbuf_init(history_data, sizeof(history_data), RINGBUF_FLAG_RECYCLE);
backlog = ringbuf_init(backlog_data, sizeof(backlog_data), RINGBUF_FLAG_RECYCLE);
history_entry = 0x0;
type = t;
if(t == 0)
completion_flagmask = CFGFLAG_CLIENT;
else
completion_flagmask = CFGFLAG_SERVER;
completion_buffer[0] = 0;
completion_chosen = -1;
command = 0x0;
}
/**
* Initialize the RS232 port.
*
*/
void
uart0_init(unsigned long ubr)
{
nrf_drv_uart_config_t config = NRF_DRV_UART_DEFAULT_CONFIG;
ret_code_t retcode = nrf_drv_uart_init(&config, uart_event_handler);
APP_ERROR_CHECK(retcode);
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
nrf_drv_uart_rx_enable();
nrf_drv_uart_rx(rx_buffer, 1);
}
static int
gaussian_init(const size_t n, void * vstate)
{
gaussian_state_t * state = (gaussian_state_t *) vstate;
state->n = n;
state->window = (gaussian_type_t *) ((unsigned char *) vstate + sizeof(gaussian_state_t));
state->rbuf = (ringbuf *) ((unsigned char *) state->window + n * sizeof(gaussian_type_t));
ringbuf_init(n, state->rbuf);
return GSL_SUCCESS;
}
int
IIS328DQ::init()
{
int ret = ERROR;
if (probe() != OK)
goto out;
/* do SPI init (and probe) first */
if (CDev::init() != OK)
goto out;
/* allocate basic report buffers */
if (_reports != NULL) {
ringbuf_deinit(_reports);
vPortFree(_reports);
_reports = NULL;
}
/* allocate basic report buffers */
_reports = (ringbuf_t *) pvPortMalloc (sizeof(ringbuf_t));
ringbuf_init(_reports, 2, sizeof(accel_report));
if (_reports == NULL)
goto out;
_class_instance = register_class_devname(ACCEL_BASE_DEVICE_PATH);
reset();
measure();
/* advertise sensor topic, measure manually to initialize valid report */
struct accel_report arp;
ringbuf_get(_reports, &arp, sizeof(arp));
_accel_topic = orb_advertise_multi(ORB_ID(sensor_accel), &arp,
&_orb_class_instance, (is_external()) ? ORB_PRIO_VERY_HIGH : ORB_PRIO_DEFAULT);
if (_accel_topic == NULL) {
DEVICE_DEBUG("failed to create sensor_accel publication");
}
ret = OK;
out:
return ret;
}
void setup() {
// ringbuf:
rb = (ringbuf_t*) malloc(sizeof(ringbuf_t));
// data area:
data = (char*) malloc(ringbuf_size);
ringbuf_init(rb, data, ringbuf_size, NULL, NULL);
// some data
pattern = (char*) malloc(2*ringbuf_size);
for(int i = 0; i < 2*ringbuf_size; ++i) {
pattern[i] = (char) (i%255);
}
overflow_callback_called = 0;
underflow_callback_called = 0;
}
/**
* Initalize the RS232 port.
*
*/
void
uart0_init(unsigned long ubr)
{
/* RS232 */
UCA0CTL1 |= UCSWRST; /* Hold peripheral in reset state */
UCA0CTL1 |= UCSSEL_2; /* CLK = SMCLK */
UCA0BR0 = ubr; /* 8MHz/115200 = 69 = 0x45 */
UCA0BR1 = 0x00;
UCA0MCTL = UCBRS_3; /* Modulation UCBRSx = 3 */
P3DIR &= ~0x20; /* P3.5 = USCI_A0 RXD as input */
P3DIR |= 0x10; /* P3.4 = USCI_A0 TXD as output */
P3SEL |= 0x30; /* P3.4,5 = USCI_A0 TXD/RXD */
/*UCA0CTL1 &= ~UCSWRST;*/ /* Initialize USCI state machine */
transmitting = 0;
/* XXX Clear pending interrupts before enable */
IFG2 &= ~UCA0RXIFG;
IFG2 &= ~UCA0TXIFG;
UCA0CTL1 &= ~UCSWRST; /* Initialize USCI state machine **before** enabling interrupts */
IE2 |= UCA0RXIE; /* Enable UCA0 RX interrupt */
/* Enable USCI_A0 TX interrupts (if TX_WITH_INTERRUPT enabled) */
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
IE2 |= UCA0TXIE; /* Enable UCA0 TX interrupt */
#endif /* TX_WITH_INTERRUPT */
#if RX_WITH_DMA
IE2 &= ~UCA0RXIE; /* disable USART0 RX interrupt */
/* UART0_RX trigger */
DMACTL0 = DMA0TSEL_3;
/* source address = UCA0RXBUF */
DMA0SA = (unsigned int)&UCA0RXBUF;
DMA0DA = (unsigned int)&rxbuf;
DMA0SZ = RXBUFSIZE;
last_size = RXBUFSIZE;
DMA0CTL = DMADT_4 + DMASBDB + DMADSTINCR_3 + DMAEN + DMAREQ;
msp430_add_lpm_req(MSP430_REQUIRE_LPM1);
#endif /* RX_WITH_DMA */
}
/**
* Initalize the RS232 port.
*
*/
void
sci3_init(unsigned long ubr)
{
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
MSTCR1.BYTE &= ~0x20; /* stop mode sci3 cleared */
IO.PMR1.BIT.TXD = 1; /* TXD = 1 */
SCI3.SCR3.BYTE &= ~0x30; /*TE and RE disabled*/
SCI3.SMR.BYTE |= (0x00 & 0x03); /*asynch. mode, 8,N,1 Clock source fixed by n value */
SCI3.BRR = baudrateToBRR(ubr); /* with SMR it selects baud rate */
SCI3.SCR3.BYTE &= ~0x03; /* internal clock, asynchronus mode */
SCI3.SCR3.BYTE |= 0x30; /*TE and RE enabled*/
SCI3.SCR3.BYTE |= 0x44; /*RxI Enabled Teie enabled*/
}
int uart_init(void)
{
#ifndef __USE_UART_PORT3__
fprintf(stderr, "uart: __USE_UART_PORT3__ not defined\n");
return -1;
#else
if(pic32_uart3_init(DEFAULT_BAUDRATE, 0))
{
fprintf(stderr, "uart: Init failed\n");
return -1;
}
current_baud_rate = DEFAULT_BAUDRATE;
ringbuf_init(&uart_ring_buffer, uart_buffer, UART_BUFFER_SIZE);
previous_uart_handler = uart3_input_handler;
uart3_set_input(uart_handler);
return 0;
#endif
}
/**
* Initalize the RS232 port.
*
*/
void
uart1_init(unsigned long ubr)
{
GPIO_PBCFGL &= 0xF00F;
GPIO_PBCFGL |= 0x0490;
u16_t uartper = (u32_t)24e6/(2*ubr);
u32_t rest = (u32_t)24e6%(2*ubr);
SC1_UARTFRAC = 0;
if(rest > (2*ubr)/4 && rest < (3*2*ubr)/4){
SC1_UARTFRAC = 1; // + 0.5
}
else if(rest >= (3*2*ubr)/4){
uartper++; // + 1
}
SC1_UARTPER = uartper;
SC1_UARTCFG = SC_UART8BIT;
SC1_MODE = SC1_MODE_UART;
SC1_INTMODE = SC_RXVALLEVEL | SC_TXFREELEVEL; // Receive buffer has data interrupt mode and Transmit buffer free interrupt mode: Level triggered.
INT_SC1CFG = INT_SCRXVAL; // Receive buffer has data interrupt enable
transmitting = 0;
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
#endif /* TX_WITH_INTERRUPT */
INT_SC1FLAG = 0xFFFF;
INT_CFGSET = INT_SC1;
}
/**
* Initalize the UART for serial communication with a host computer. It is
* currently limited to 9600 baud due to Launchpad limitations.
*/
void
uart0_init(unsigned long ubr)
{
#if _MCU_ == 2553
rx_in_progress = 0;
transmitting = 0;
/* (TI) The recommended USCI initialization/re-configuration process is: */
/* 1. Set UCSWRST (BIS.B #UCSWRST,&UCAxCTL1)*/
UCA0CTL1 = UCSWRST;
/* 2. Initialize all USCI registers with UCSWRST = 1 (including UCAxCTL1)*/
UCA0CTL1 |= UCSSEL_2; /* SMCLK, 4 MHz */
ubr = 4000000ul/9600;
UCA0BR0 = ubr & 0xff;
UCA0BR1 = (ubr & 0xff00) >> 8;
UCA0MCTL = UCBRS_1;
/* 3. Configure ports.*/
/* P12 for input (UART0RX), P11 for output (UART0TX) */
P1SEL |= 1<<1 | 1<<2;
P1SEL2 |= 1<<1 | 1<<2;
/* 4. Clear UCSWRST via software (BIC.B #UCSWRST,&UCAxCTL1)*/
UCA0CTL1 &= ~UCSWRST;
/* 5. Enable interrupts (optional) via UCAxRXIE and/or UCAxTXIE*/
/* Enable USART RX interrupt */
IFG2 &= ~UCA0RXIFG;
IE2 |= UCA0RXIFG;
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
IE2 |= UCA0TXIFG;
#endif /* TX_WITH_INTERRUPT */
#endif /* _MCU_ */
}
/*---------------------------------------------------------------------------*/
void
serial_line_init(void)
{
ringbuf_init(&rxbuf, rxbuf_data, sizeof(rxbuf_data));
process_start(&serial_line_process, NULL);
}
/**
* Initalize the RS232 port.
*
*/
void usart3_init(unsigned long ubr)
{
RCC->APB1ENR |= RCC_APB1ENR_USART3EN; /* Enable USART3 clock */
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; /* Enable GPIOC clock */
GPIOD->MODER &= 0xFFF0FFFF;
GPIOD->MODER |= 0x000A0000;
GPIOD->AFR[1] |= 0x00000077; /* PD8 USART3_Tx, PD9 USART3_Rx (AF7) */
/* Configure USART3: 115200 baud @ 42MHz, 8 bits, 1 stop bit, no parity */
USART3->BRR = (22 << 4) | 12;
USART3->CR3 = 0x0000;
USART3->CR2 = 0x0000;
USART3->CR1 = USART_CR1_UE | USART_CR1_RXNEIE | USART_CR1_RE | USART_CR1_TE;
#ifdef USART3_TX_USE_DMA1_CH4
#warning DMA1 stream3 channel4 is used by USART3 for transmission!
/*********************************************************************************
* DMA Configuration
*********************************************************************************/
uint32_t tmpreg;
RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN; /* enable DMA clock */
/* Get the configuration register from DMA1_Stream3 */
tmpreg = DMA1_Stream3->CR;
/* Clear CHSEL, MBURST, PBURST, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */
tmpreg &= ((uint32_t)~(DMA_SxCR_CHSEL | DMA_SxCR_MBURST | DMA_SxCR_PBURST | \
DMA_SxCR_PL | DMA_SxCR_MSIZE | DMA_SxCR_PSIZE | \
DMA_SxCR_MINC | DMA_SxCR_PINC | DMA_SxCR_CIRC | \
DMA_SxCR_DIR));
/*********************************************************************************
* Configure SPI_DMAx_STREAM_TX:
* Set CHSEL bits to SPI_DMAx_CHANNEL
* Set DIR bits to 01 (Mem->Periph)
* Set PINC bit to 0 (disable)
* Set MINC bit to 1 (enable)
* Set PSIZE bits to 00 (byte)
* Set MSIZE bits to 00 (byte)
* Set CIRC bit to 0 (disable)
* Set PL bits to 00 (low)
* Set MBURST bits to 00 (single)
* Set PBURST bits to 00 (single)
*********************************************************************************/
tmpreg |= DMA_SxCR_CHSEL_2 | DMA_SxCR_DIR_0 | DMA_SxCR_MINC;
/* Write to DMA controller 1 Strem 3 CR register */
DMA1_Stream3->CR = tmpreg;
/* Clear DMDIS and FTH bits in the FCR register */
DMA1_Stream3->FCR &= (uint32_t)~(DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);
/* set the address of uart3 tx register into PAR */
DMA1_Stream3->PAR = USART3_BASE + 0x04;
/* Enable UART DMA mode */
USART3->CR3 |= USART_CR3_DMAT;
DMA1_Stream3->CR |= DMA_SxCR_TCIE;
IRQ_init_enable(DMA1_Stream3_IRQn,0,0);
#endif
transmitting = 0;
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
IRQ_init_enable(USART3_IRQn, 0, 0);
}
/******************************************************************************
* FunctionName : user_init
* Description : entry of user application, init user function here
* Parameters : none
* Returns : none
*******************************************************************************/
void user_init(void) {
#ifdef DOUBLE_CLK_FREQ
system_update_cpu_freq(160);
#endif
#ifdef DEV
//system_uart_swap();
#endif
uart_init_new(BAUD, uart_rx);
DBG("WILOC-MASTER");
printf("SDK version:%s\n", system_get_sdk_version());
unsigned char mac[6];
wifi_get_macaddr(STATION_IF, mac);
printf("MAC-STA:");
printmac(mac, 0);
printf("\n");
wifi_get_macaddr(SOFTAP_IF, mac);
printf("MAC- AP:");
printmac(mac, 0);
printf("\n");
DBG(" ---- set opmode");
if (!wifi_set_opmode(STATIONAP_MODE)) {
DBG(" ---- > failed to set opmode");
}
DBG(" ---- done");
// wifi_softap_set_config(&softapConf);
os_delay_us(300);
char *ssid = SSID;
char *password = PASSWORD;
struct station_config stationConf;
stationConf.bssid_set = 0; //need not check MAC address of AP
memcpy(&stationConf.ssid, ssid, strlen(ssid) + 1);
memcpy(&stationConf.password, password, strlen(password) + 1);
wifi_station_set_config(&stationConf);
wifi_station_set_reconnect_policy(true);
wifi_station_connect();
DBG(" --- trying to connect to AP");
tx_queue = xQueueCreate(1, sizeof(int));
ringbuf_mutex = xSemaphoreCreateMutex();
ringbuf_init(&ringbuf_m, tx_buffer_m, sizeof(tx_buffer_m));
ringbuf_init(&ringbuf_t, tx_buffer_t, sizeof(tx_buffer_t));
synchronize_dev_id();
// wait until wifi is connected
user_wifi_init(connect_to_server);
}
void main(void) {
OSCCON = 0b11110000; // 内部クロックは８ＭＨｚとする
OPTION_REG = 0b00000000; // デジタルI/Oに内部プルアップ抵抗を使用する
ANSELA = 0b00000000; // AN0-AN4は使用しない全てデジタルI/Oとする
ANSELB = 0b00000000; // AN5-AN11は使用しない全てデジタルI/Oとする
TRISA = 0b00000011; // ピン(RA)は全て出力に割当てる(RA5は入力のみとなる)
TRISB = 0b00010110; // ピン(RB)はRB4(SCL1)/RB1(SDA1)のみ入力
WPUB = 0b00010010; // RB1/4は内部プルアップ抵抗を指定する
PORTA = 0b00000000; // RA出力ピンの初期化(全てLOWにする)
PORTB = 0b00000000; // RB出力ピンの初期化(全てLOWにする)
APFCON0bits.RXDTSEL = 1;
APFCON1bits.TXCKSEL = 1;
T1CON = 0x21; //Fosc/4, ps:1/4
TMR1H = 0x00;
TMR1L = 0x00;
PIE1bits.TMR1IE = 1;
I2C_init();
LCD_init();
UART_init(PIC16F1827);
INTCONbits.PEIE = 1;
INTCONbits.GIE = 1;
uint8_t buf[70];
ringbuf_init(&tx_buf, buf, sizeof (buf));
RTC_Write(0x07, 0x00);
while (1) {
display();
if (sw_RA1.flag.press) {
sw_RA1.flag.press=0;
tx_send('2');
tx_send('0');
tx_send(((YY & 0xF0) >> 4) + '0');
tx_send((YY & 0x0F) + '0');
tx_send('/');
tx_send(((MM & 0xF0) >> 4) + '0');
tx_send((MM & 0x0F) + '0');
tx_send('/');
tx_send(((DD & 0xF0) >> 4) + '0');
tx_send((DD & 0x0F) + '0');
tx_send('(');
tx_send((EE & 0x0F) + '0');
tx_send(')');
tx_send(((hh & 0xF0) >> 4) + '0');
tx_send((hh & 0x0F) + '0');
tx_send(':');
tx_send(((mm & 0xF0) >> 4) + '0');
tx_send((mm & 0x0F) + '0');
tx_send('-');
tx_send(((ss & 0xF0) >> 4) + '0');
tx_send((ss & 0x0F) + '0');
tx_send('.');
tx_send('\n');
tx_sends("Real Time Clock\n");
}
if (sw_RA0.flag.long_holding_1) {
sw_RA0.flag.long_holding_1 = 0;
timeset(&YY, 0, 99, 0x06, 0, 0);
timeset(&MM, 1, 12, 0x05, 3, 0);
timeset(&DD, 1, month_length(YY, MM), 0x04, 6, 0);
timeset(&hh, 0, 23, 0x02, 0, 1);
timeset(&mm, 0, 59, 0x01, 3, 1);
timeset(&ss, 0, 59, 0x00, 6, 1);
}
}
static void USB_CDC_buffer_init(void) {
static uint8_t rxbuf[USB_RX_BUFFER_SIZE];
ringbuf_init(&usb_rx, rxbuf, sizeof (rxbuf));
static uint8_t txbuf[USB_TX_BUFFER_SIZE];
ringbuf_init(&usb_tx, txbuf, sizeof (txbuf));
}
int main(void) {
//pin設定
ANSELA = 0x00;
ANSELB = 0x00;
ANSELC = 0x00;
TRISA = 0x00;
TRISB = 0x00;
TRISC = 0xBC;
OSCCONbits.IRCF = 6; // 6 => 8MHz
OSCCON2bits.PLLRDY = 1;
OSCTUNEbits.PLLEN = 1; // clock x 4
T0CONbits.TMR0ON = 1;
T0CONbits.T08BIT = 1; // 8-bit timer
T0CONbits.T0CS = 0; // use intOSC
T0CONbits.PSA = 0; // use prescaler
T0CONbits.T0PS = 2; // 1 => 1:4
INTCONbits.T0IE = 1;
INTCON2bits.TMR0IP = 0; // low priority
T1CONbits.TMR1CS = 0; //Clock = Fosc/4
T1CONbits.T1CKPS = 0; //PreScaler is 1:1
T1CONbits.T1RD16 = 1; //Timer1=16bit timer
T1CONbits.TMR1ON = 1; //enable
IPR1bits.TMR1IP = 0; //low priority
PIE1bits.TMR1IE = 1;
T3CONbits.TMR3CS = 0; //Clock = Fosc/4
T3CONbits.T3CKPS = 0; //PreScaler is 1:1
T3CONbits.T3RD16 = 1; //Timer1=16bit timer
T3CONbits.TMR3ON = 1; //enable
IPR2bits.TMR3IP = 0; //low priority
PIE2bits.TMR3IE = 1;
TXSTA1bits.TX9 = 0; // 8-bit
TXSTA1bits.TXEN = 1; //enable
TXSTA1bits.SYNC = 0; // Asynchronous mode
TXSTA1bits.BRGH = 0;
RCSTA1bits.SPEN = 1; // Serial Port enable
RCSTA1bits.RX9 = 0; // 8-bit
RCSTA1bits.CREN = 1; // continuous receive enable
BAUDCON1bits.BRG16 = 0; // use 8bit SPBRG
SPBRG1 = 51;
IPR1bits.RC1IP = 0; //low priority
PIE1bits.RC1IE = 1;
INTCONbits.PEIE = 1;
INTCONbits.GIE = 0;
uint8_t buf[LENGTH];
ringbuf_init(&tx_buf, buf, sizeof (buf));
uint8_t i;
uint8_t j;
uint8_t preset_memory_char_0[] = "This is an LED bulletin board.";
uint8_t preset_memory_char_1[] = "4 sentences can be memorized.";
uint8_t preset_memory_char_2[] = "When a button is pressed, the sentence which memorized by the button is shown.";
uint8_t preset_memory_char_3[] = "When a button is pressed for a long time, a sentence is memorized.";
uint8_t preset_char[] = "Hello World!";
for (i = 0; preset_char[i]; i++) {
scroll_char[i] = preset_char[i];
scroll_char_pointer++;
}
for (i = 0; preset_memory_char_0[i]; i++) {
memory_char[0][i] = preset_memory_char_0[i];
}
memory_char[0][i] = '\0';
for (i = 0; preset_memory_char_1[i]; i++) {
memory_char[1][i] = preset_memory_char_1[i];
}
memory_char[1][i] = '\0';
for (i = 0; preset_memory_char_2[i]; i++) {
memory_char[2][i] = preset_memory_char_2[i];
}
memory_char[2][i] = '\0';
for (i = 0; preset_memory_char_3[i]; i++) {
memory_char[3][i] = preset_memory_char_3[i];
}
memory_char[3][i] = '\0';
scroll_pointer = 0;
scroll(1);
INTCONbits.GIE = 1;
while (1) {
uint16_t sw_flag = 0;
for (j = 0; j < 4; j++) {
if (sw(j))sw_flag = 1;
if ((long_hold_flag)&(1 << j)) {
long_hold_flag &= ~(1 << j);
scroll(0);
for (i = 0; i < scroll_char_pointer; i++) {
memory_char[j][i] = scroll_char[i];
}
memory_char[j][i]='\0';
print_char[0] = 'M';
print_char[1] = '0' + j + 1;
print(1);
}
if (cnt_sw[j] > 1 && cnt_sw[j] < LONG_HOLD_LEVEL && sw(j) == 0) {
cnt_sw[j] = 0;
scroll_char_pointer = 0;
for (i = 0; memory_char[j][i]; i++) {
scroll_char[i] = memory_char[j][i];
scroll_char_pointer++;
}
scroll_pointer = 0;
return_reset = 1;
scroll(1);
}
}
if (sw_flag == 0 && printON == 1) {
print(0);
scroll(1);
}
}
return 0;
}
static void ringbuf_purge(ringbuf_t *rb)
{
ringbuf_init(rb, 0);
}
int brl_limit_history(brl_t *brl, size_t size)
{
return ringbuf_init(&brl->h, size);
}
int main(void) {
//pin設定
ANSELA = 0x00;
ANSELB = 0x00;
ANSELC = 0x00;
TRISA = 0x00;
TRISB = 0xFF;
TRISC = 0x90;
OSCCONbits.IRCF = 6; // 6 => 8MHz
OSCCON2bits.PLLRDY = 1;
OSCTUNEbits.PLLEN = 1; // clock x 4
T0CONbits.TMR0ON = 1;
T0CONbits.T08BIT = 1; // 8-bit timer
T0CONbits.T0CS = 0; // use intOSC
T0CONbits.PSA = 0; // use prescaler
T0CONbits.T0PS = 2; // 1 => 1:4
INTCONbits.T0IE = 1;
INTCON2bits.TMR0IP = 0; // low priority
T1CONbits.TMR1CS = 0; //Clock = Fosc/4
T1CONbits.T1CKPS = 0; //PreScaler is 1:1
T1CONbits.T1RD16 = 1; //Timer1=16bit timer
T1CONbits.TMR1ON = 1; //enable
IPR1bits.TMR1IP = 0; //low priority
PIE1bits.TMR1IE = 1;
TXSTA1bits.TX9 = 0; // 8-bit
TXSTA1bits.TXEN = 1; //enable
TXSTA1bits.SYNC = 0; // Asynchronous mode
TXSTA1bits.BRGH = 0;
RCSTA1bits.SPEN = 1; // Serial Port enable
RCSTA1bits.RX9 = 0; // 8-bit
RCSTA1bits.CREN = 1; // continuous receive enable
BAUDCON1bits.BRG16 = 0; // use 8bit SPBRG
SPBRG1 = 51;
//IPR1bits.RC1IP = 0; //low priority
//PIE1bits.RC1IE = 1;
INTCONbits.PEIE = 1;
INTCONbits.GIE = 0;
uint8_t buf[255];
ringbuf_init(&tx_buf, buf, sizeof (buf));
uint8_t i;
INTCONbits.GIE = 1;
print(1);
while (1) {
if (cnt_sw > LONG_HOLD_LEVEL2)print_char = '\r';
else if (cnt_sw > LONG_HOLD_LEVEL1)print_char = '\b';
else print_char = PORTB;
if (long_hold_flag1) {
long_hold_flag1 = 0;
tx_send('\b');
}
if (long_hold_flag2) {
long_hold_flag2 = 0;
tx_send('\r');
}
if (press_flag) {
press_flag = 0;
tx_send(PORTB);
}
}
return 0;
}
/**
* Initalize the RS232 port.
*
*/
void
uart1_init(unsigned long ubr)
{
/* RS232 */
P3DIR &= ~0x80; /* Select P37 for input (UART1RX) */
P3DIR |= 0x40; /* Select P36 for output (UART1TX) */
P3SEL |= 0xC0; /* Select P36,P37 for UART1{TX,RX} */
UCTL1 = SWRST | CHAR; /* 8-bit character, UART mode */
#if 0
U1RCTL &= ~URXEIE; /* even erroneous characters trigger interrupts */
#endif
UTCTL1 = SSEL1; /* UCLK = MCLK */
UBR01 = ubr;
UBR11 = ubr >> 8;
/*
* UMCTL1 values calculated using
* http://mspgcc.sourceforge.net/baudrate.html
*/
switch(ubr) {
#if F_CPU == 3900000ul
case UART1_BAUD2UBR(115200ul):
UMCTL1 = 0xF7;
break;
case UART1_BAUD2UBR(57600ul):
UMCTL1 = 0xED;
break;
case UART1_BAUD2UBR(38400ul):
UMCTL1 = 0xD6;
break;
case UART1_BAUD2UBR(19200ul):
UMCTL1 = 0x08;
break;
case UART1_BAUD2UBR(9600ul):
UMCTL1 = 0x22;
break;
#elif F_CPU == 2457600ul
case UART1_BAUD2UBR(115200ul):
UMCTL1 = 0x4A;
break;
case UART1_BAUD2UBR(57600ul):
UMCTL1 = 0x5B;
break;
default:
/* 9600, 19200, 38400 don't require any correction */
UMCTL1 = 0x00;
#else
#error Unsupported CPU speed in uart1.c
#endif
}
ME2 &= ~USPIE1; /* USART1 SPI module disable */
ME2 |= (UTXE1 | URXE1); /* Enable USART1 TXD/RXD */
UCTL1 &= ~SWRST;
/* XXX Clear pending interrupts before enable!!! */
IFG2 &= ~URXIFG1;
U1TCTL |= URXSE;
rx_in_progress = 0;
transmitting = 0;
IE2 |= URXIE1; /* Enable USART1 RX interrupt */
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
IE2 |= UTXIE1; /* Enable USART1 TX interrupt */
#endif /* TX_WITH_INTERRUPT */
#if RX_WITH_DMA
IE2 &= ~URXIE1; /* disable USART1 RX interrupt */
/* UART1_RX trigger */
DMACTL0 = DMA0TSEL_9;
/* source address = RXBUF1 */
DMA0SA = (unsigned int) &RXBUF1;
DMA0DA = (unsigned int) &rxbuf;
DMA0SZ = RXBUFSIZE;
last_size = RXBUFSIZE;
DMA0CTL = DMADT_4 + DMASBDB + DMADSTINCR_3 + DMAEN + DMAREQ;// DMAIE;
msp430_add_lpm_req(MSP430_REQUIRE_LPM1);
#endif /* RX_WITH_DMA */
}
int ringbuf_test()
{
char buffer[256];
RINGBUFFER *rb;
int i, s, k, m;
int count;
int testcount = 0;
void *item;
int before;
for(k = 100; k < sizeof(buffer); k++)
{
if((k%10) == 0)
dbg_msg("ringbuf", "testing at %d", k);
rb = ringbuf_init(buffer, k, 0);
count = 0;
for(s = 1; s < sizeof(buffer); s++)
{
for(i = 0; i < k*8; i++, testcount++)
{
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
before = m;
if(ringbuf_allocate(rb, s))
{
count++;
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
if(before+1 != m) ringbuf_debugdump(rb, "alloc error");
if(count != m) ringbuf_debugdump(rb, "count error");
}
else
{
if(ringbuf_popfirst(rb))
{
count--;
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
if(before-1 != m) dbg_msg("", "popping error %d %d", before, m);
if(count != m) ringbuf_debugdump(rb, "count error");
}
}
/* remove an item every 10 */
if((i%10) == 0)
{
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
before = m;
if(ringbuf_popfirst(rb))
{
count--;
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
if(before-1 != m) dbg_msg("", "popping error %d %d", before, m);
dbg_assert(count == m, "count error");
}
}
/* count items */
for(m = 0, item = ringbuf_first(rb); item; item = ringbuf_next(rb, item), m++);
if(m != count) ringbuf_debugdump(rb, "wrong number of items during forward count");
for(m = 0, item = ringbuf_last(rb); item; item = ringbuf_prev(rb, item), m++);
if(m != count) ringbuf_debugdump(rb, "wrong number of items during backward count");
ringbuf_validate(rb);
}
/* empty the ring buffer */
while(ringbuf_first(rb))
ringbuf_popfirst(rb);
ringbuf_validate(rb);
count = 0;
}
}
return 0;
}
