msp430G2553 launchpad programming - msp430

I am making my program using msp430g2553 launch pad. In this i have taken input from P2.4 and i want my output from P2.0, P2.1 and P2.2.
In this program i have to generate the pulse of 500ms from input. and my output will be three low pulses from the three pins. Meaning whenever i connect my oscilloscope probe to 2.4 i can see the pulse. But the program i made it didn't work. when i connect to the oscilloscope it is showing nothing.
when my input pulse is high i will get the three low pulses output.
here is my code, please check it and tell me what is wrong in the code? since it doesn't contains any error.
code:
#include <msp430g2553.h>
#define CPU_F ((double)16000000)
#define delay_us(x) __delay_cycles((long)(CPU_F*(double)x/1000000.0))
#define delay_ms(x) __delay_cycles((long)(CPU_F*(double)x/1000.0))
char C_1, C_2;
void System_Clock_Init( void )
{
char i;
_NOP();
WDTCTL = WDTPW + WDTHOLD; // Close Watching dog
delay_ms(50);
if( ( CALBC1_16MHZ == 0xff ) || ( CALDCO_16MHZ == 0xff ) )
((void (*)())RESET_VECTOR)();
BCSCTL1 = CALBC1_16MHZ;
DCOCTL = CALDCO_16MHZ; //MCLK=DCOCLK=16MHz
BCSCTL2 = 0x06;//SMCLK=DCOCLK/8=2MHz
BCSCTL3 = 0x00;
IE1 &= ~OFIE;
do
{
IFG1 &= ~OFIFG;
for( i = 0; i < 100; i++ )
{
_NOP();
}
}
while (IFG1 & OFIFG);
_NOP();
}
void IO_INIT(void)
{
NOP();
P2SEL &= ~BIT4;
P2SEL2 &= ~BIT4;
P2REN &= ~BIT4;
/*P2DIR |= BIT2;*/
P2IES |= BIT4;
P2IE |= BIT4;
P2IFG &= ~BIT4;
P2SEL &= ~(BIT0+BIT1);
P2SEL2 &= ~(BIT0+BIT1);
P2REN &= ~(BIT0+BIT1);
//P2DIR &= ~(BIT0+BIT1);
P2OUT &= ~(BIT0+BIT1);
P2SEL &= ~BIT2;
P2SEL2 &= ~BIT2;
P2REN &= ~BIT2;
//P3DIR &= ~BIT1;
P2OUT &= ~BIT2;
}
void main(void)
{
System_Clock_Init();
_NOP();
//WDTCTL = WDT_ARST_1000;
_NOP();
IO_INIT();
_NOP();
_EINT();//open all interrupt
_NOP();
LPM3;
_NOP();
while(1);
}
#pragma vector = PORT2_VECTOR
__interrupt void PORT_C_Interrupt(void)
{
_NOP();
delay_us(20);
if( C_1 == 0xff)
{
if(!( P2IN & BIT4 )) C_2 = 0xff;
}
else
{
if(!( P2IN & BIT4 )) C_1 = 0xff;
}
if(( C_1 == 0xff) && ( C_2 == 0xff))
{
//output A B D
P2OUT |= BIT0;
delay_ms(2);
P2OUT |= BIT1;
P2OUT &= ~BIT0;
delay_ms(2);
P2OUT |= BIT2;
P2OUT &= ~BIT1;
delay_ms(2);
P2OUT &= ~BIT2;
delay_ms(2);
P2OUT ^= BIT1;
P2IFG &= ~BIT1;
C_1 =0x00;
C_2 =0x00;
}
_NOP();
}

P2IFG &= ~BIT1;
The interrupt came from P2.4. This line does not clear the interrupt for pin 4, so the interrupt handler will be called continuously.
/*P2DIR |= BIT2;*/
//P2DIR &= ~(BIT0+BIT1);
If you actually want those pins to te outputs, it would be a good idea not to comment out their configuration.

Related

Reading temperature values from TMP117 sensor using MSP430FR5969 MCU

I'm trying to read temperature values from the TMP117 sensor [1] connected to an MSP430FR5969 MCU [2] through the I2C protocol. The data in the result register of the sensor is in two's complement format, has a data width of 16 bits, and a resolution of 0.0078125 °C. I used Code Composer Studio to program the MCU and I've attached the code below:
#include <msp430.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#define SLAVE_ADDR 0x48
#define CONVERSION_READY 0x10
#define TMP117_TEMP_REG 0x00
#define TMP117_CONFIG_REG 0x01
#define TMP117_RESOLUTION 0.0078125f
#define CMD_TYPE_0_SLAVE 0
#define CMD_TYPE_1_SLAVE 1
#define CMD_TYPE_2_SLAVE 2
#define CMD_TYPE_0_MASTER 3
#define CMD_TYPE_1_MASTER 4
#define CMD_TYPE_2_MASTER 5
#define TYPE_0_LENGTH 1
#define TYPE_1_LENGTH 2
#define TYPE_2_LENGTH 6
#define MAX_BUFFER_SIZE 20
char temperature[] = "Temperature is: ";
char dot[] = ".";
char celcuis[] = " degree Celcius\r\n";
int i;
char text[] = " I am an MSP430FR5969\r\n";
char rx_char[5];
volatile int rx_val = 0;
void clockSetup();
void gpioSetup();
void uartSetup();
void i2cSetup();
void ser_output(char *str);
uint8_t MasterType1 [TYPE_1_LENGTH] = {0x02, 0x20};
uint8_t SlaveType1 [TYPE_1_LENGTH] = {0};
typedef enum I2C_ModeEnum{
IDLE_MODE,
NACK_MODE,
TX_REG_ADDRESS_MODE,
RX_REG_ADDRESS_MODE,
TX_DATA_MODE,
RX_DATA_MODE,
SWITCH_TO_RX_MODE,
SWITHC_TO_TX_MODE,
TIMEOUT_MODE
} I2C_Mode;
I2C_Mode MasterMode = IDLE_MODE;
/* The Register Address/Command to use*/
uint8_t TransmitRegAddr = 0;
uint8_t ReceiveBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t RXByteCtr = 0;
uint8_t ReceiveIndex = 0;
uint8_t TransmitBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t TXByteCtr = 0;
uint8_t TransmitIndex = 0;
I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count);
I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count);
void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count);
I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count)
{
MasterMode = TX_REG_ADDRESS_MODE;
TransmitRegAddr = reg_addr;
RXByteCtr = count;
TXByteCtr = 0;
ReceiveIndex = 0;
TransmitIndex = 0;
UCB0I2CSA = dev_addr;
UCB0IFG &= ~(UCTXIFG + UCRXIFG);
UCB0IE &= ~UCRXIE;
UCB0IE |= UCTXIE;
UCB0CTLW0 |= UCTR + UCTXSTT;
__bis_SR_register(LPM0_bits + GIE);
return MasterMode;
}
I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
{
MasterMode = TX_REG_ADDRESS_MODE;
TransmitRegAddr = reg_addr;
CopyArray(reg_data, TransmitBuffer, count);
TXByteCtr = count;
RXByteCtr = 0;
ReceiveIndex = 0;
TransmitIndex = 0;
UCB0I2CSA = dev_addr;
UCB0IFG &= ~(UCTXIFG + UCRXIFG);
UCB0IE &= ~UCRXIE;
UCB0IE |= UCTXIE;
UCB0CTLW0 |= UCTR + UCTXSTT;
__bis_SR_register(LPM0_bits + GIE);
return MasterMode;
}
void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count)
{
uint8_t copyIndex = 0;
for (copyIndex = 0; copyIndex < count; copyIndex++)
{
dest[copyIndex] = source[copyIndex];
}
}
void main(void)
{
WDTCTL = WDTPW | WDTHOLD;
clockSetup();
gpioSetup();
uartSetup();
i2cSetup();
__bis_SR_register(GIE);
while (1)
{
_delay_cycles(500000);
I2C_Master_ReadReg(SLAVE_ADDR, 0x00, TYPE_1_LENGTH);
CopyArray(ReceiveBuffer, SlaveType1, TYPE_1_LENGTH);
if(ReceiveBuffer[1] & CONVERSION_READY)
{
I2C_Master_ReadReg(SLAVE_ADDR, 0x00, TYPE_1_LENGTH);
CopyArray(ReceiveBuffer, SlaveType1, TYPE_1_LENGTH);
_no_operation();
}
ltoa(rx_val, rx_char, 10);
ser_output(temperature);
ser_output(rx_char);
ser_output(dot);
ser_output(celcuis);
}
}
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector = USCI_B0_VECTOR
__interrupt void USCI_B0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
#else
#error Compiler not supported!
#endif
{
//Must read from UCB0RXBUF
//// uint8_t rx_val = 0;
switch(__even_in_range(UCB0IV, USCI_I2C_UCBIT9IFG))
{
case USCI_NONE: break; // Vector 0: No interrupts
case USCI_I2C_UCALIFG: break; // Vector 2: ALIFG
case USCI_I2C_UCNACKIFG: // Vector 4: NACKIFG
break;
case USCI_I2C_UCSTTIFG: break; // Vector 6: STTIFG
case USCI_I2C_UCSTPIFG: break; // Vector 8: STPIFG
case USCI_I2C_UCRXIFG3: break; // Vector 10: RXIFG3
case USCI_I2C_UCTXIFG3: break; // Vector 12: TXIFG3
case USCI_I2C_UCRXIFG2: break; // Vector 14: RXIFG2
case USCI_I2C_UCTXIFG2: break; // Vector 16: TXIFG2
case USCI_I2C_UCRXIFG1: break; // Vector 18: RXIFG1
case USCI_I2C_UCTXIFG1: break; // Vector 20: TXIFG1
case USCI_I2C_UCRXIFG0: // Vector 22: RXIFG0
rx_val = UCB0RXBUF;
if (RXByteCtr)
{
ReceiveBuffer[ReceiveIndex++] = rx_val;
RXByteCtr--;
}
if (RXByteCtr == 1)
{
UCB0CTLW0 |= UCTXSTP;
}
else if (RXByteCtr == 0)
{
UCB0IE &= ~UCRXIE;
MasterMode = IDLE_MODE;
__bic_SR_register_on_exit(CPUOFF); // Exit LPM0
}
break;
case USCI_I2C_UCTXIFG0: // Vector 24: TXIFG0
switch (MasterMode)
{
case TX_REG_ADDRESS_MODE:
UCB0TXBUF = TransmitRegAddr;
if (RXByteCtr)
MasterMode = SWITCH_TO_RX_MODE; // Need to start receiving now
else
MasterMode = TX_DATA_MODE; // Continue to transmision with the data in Transmit Buffer
break;
case SWITCH_TO_RX_MODE:
UCB0IE |= UCRXIE; // Enable RX interrupt
UCB0IE &= ~UCTXIE; // Disable TX interrupt
UCB0CTLW0 &= ~UCTR; // Switch to receiver
MasterMode = RX_DATA_MODE; // State state is to receive data
UCB0CTLW0 |= UCTXSTT; // Send repeated start
if (RXByteCtr == 1)
{
//Must send stop since this is the N-1 byte
while((UCB0CTLW0 & UCTXSTT));
UCB0CTLW0 |= UCTXSTP; // Send stop condition
}
break;
case TX_DATA_MODE:
if (TXByteCtr)
{
UCB0TXBUF = TransmitBuffer[TransmitIndex++];
TXByteCtr--;
}
else
{
//Done with transmission
UCB0CTLW0 |= UCTXSTP; // Send stop condition
MasterMode = IDLE_MODE;
UCB0IE &= ~UCTXIE; // disable TX interrupt
__bic_SR_register_on_exit(CPUOFF); // Exit LPM0
}
break;
default:
__no_operation();
break;
}
break;
default: break;
}
}
void ser_output(char *str)
{
while(*str !=0)
{
while(!(UCA0IFG&UCTXIFG));
UCA0TXBUF = *str++;
}
}
void gpioSetup()
{
P1OUT &= ~BIT0; // Clear P1.0 output latch
P1DIR |= BIT0; // For LED
P1SEL1 |= BIT6 | BIT7; // I2C pins
P2SEL1 |= BIT0 | BIT1; // USCI_A0 UART operation
P2SEL0 &= ~(BIT0 | BIT1);
PM5CTL0 &= ~LOCKLPM5;
}
void clockSetup()
{
FRCTL0 = FRCTLPW | NWAITS_1;
CSCTL0_H = CSKEY >> 8;
CSCTL1 = DCORSEL | DCOFSEL_0;
CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK;
CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;
CSCTL0_H = 0;
}
void uartSetup()
{
UCA0CTL1 |= UCSWRST;
UCA0CTL1 |= UCSSEL_2;
UCA0BR0 = 6;
UCA0BR1 = 0;
UCA0MCTLW = 0xAA;
UCA0MCTLW |= UCOS16 | UCBRF_1;
UCA0CTL1 &= ~UCSWRST;
UCA0IE |= UCRXIE;
}
void i2cSetup()
{
UCB0CTLW0 |= UCSWRST;
UCB0CTLW0 |= UCMODE_3 | UCMST | UCSSEL__SMCLK | UCSYNC;
UCB0CTLW1 |= UCSSEL_2;
UCB0BRW = 10;
UCB0I2CSA = 0x0048;
UCB0CTLW0 &= ~UCSWRST;
UCB0IE |= UCRXIE | UCNACKIE | UCBCNTIE;
}
I get the following data:
Temperature values in ReceviedBuffer, and transmitted value to PuTTY terminal
(i) My first question is that why I'm getting the RecevieBuffer1 values on the terminal and the missing value of the RecevieBuffer[0].
(ii) My second question is that how would I convert the 16-bit raw data to value in Celsius.
Many thanks
To get a 16-bit value from your buffer of bytes you need to cast each byte up to 16-bit values, shift the second byte by 8-bits, and OR the two together. In one line it would look like this:
int16_t value = int16_t(buffer[0]) | int16_t(buffer[1]) << 8;
Based on the value you are reading of 0x0aaf, I would guess the temperature sensor you are using probably outputs the value in in celsius*100 to keep it an integer and still have 100th of degree precision. So to get the value in celsius you'd have to cast to a float or double and divide by 100.0. So 0x0aaf is 2735, meaning 27.35 degrees C.

LED matrix (HUB-75 type)

I'm trying to make the 64x64 LED matrix work without libraries. Started driving it with STM32F103C8T6 chip figured out the problem and tried ATmega328 instead, but nothing changed.
The problem is when I'm trying to lit a LED on specified address it actually lights up with almost 0 brightness, but the LED directly under it (on the next address) lights up with full brightness.
I cut the code to a minimum.
#define CLK 0
#define LAT 1
#define R1 2
uint16_t data [64][4];
void shiftOutLed (void);
int main () {
data [0][0] = 0x0001;
data [0][2] = 0x1800;
DDRC |= 0x0F; //pin 0 - A, pin 1 - B, pin 2 - C, pin3 - D
DDRB |= 0x03; // pin 0 - CLK, pin 1 - LAT
DDRD |= 0x04; // pin 2 - R1
while (1){
shiftOutLed ();
}
}
void shiftOutLed (void){
for (uint8_t _addr = 0; _addr < 16; _addr++){
PORTC &= 0xF0;
PORTC |= _addr;
for (uint8_t _byte = 0; _byte < 4; _byte++){
for (uint8_t _bit = 0; _bit < 16; _bit++){
if (data[_addr][_byte] & (1 << _bit)) PORTD |= (1 << R1);
else PORTD &= ~(1 << R1);
PORTB |= (1 << CLK);
PORTB &= ~(1 << CLK);
}
}
PORTB |= (1 << LAT);
PORTB &= ~(1 << LAT);
PORTD &= ~(1 << R1);
}
}
When I modify the code introducing delays while clocking and latching every bit LEDs light up in right row.
Seems like the matrix needs the address set after clocking the entire row
#define CLK 0
#define LAT 1
#define R1 2
uint16_t data [64][4];
void shiftOutLed (void);
int main () {
data [0][0] = 0x0001;
data [0][2] = 0x1800;
DDRC |= 0x0F; //pin 0 - A, pin 1 - B, pin 2 - C, pin3 - D
DDRB |= 0x03; // pin 0 - CLK, pin 1 - LAT
DDRD |= 0x04; // pin 2 - R1
while (1){
shiftOutLed ();
}
}
void shiftOutLed (void){
for (uint8_t _addr = 0; _addr < 16; _addr++){
PORTC &= 0xF0;
for (uint8_t _byte = 0; _byte < 4; _byte++){
for (uint8_t _bit = 0; _bit < 16; _bit++){
if (data[_addr][_byte] & (1 << _bit)) PORTD |= (1 << R1);
else PORTD &= ~(1 << R1);
PORTB |= (1 << CLK);
PORTB &= ~(1 << CLK);
}
}
PORTC |= _addr;
PORTB |= (1 << LAT);
PORTB &= ~(1 << LAT);
PORTD &= ~(1 << R1);
}
}
Now it works

Convert an arduino library for touchscreen to a general c library

I have been using the adafruit 3.5'' tft touchscreen break out board with arduino. It has arduino library available for this purpose. I have attached the library below. I am trying to make this touchscreen work without the arduino board with atmega16 . I have changed the library into a c file accordingly. I have written a program to just change the screen color, but that also in not happening. I do not understand where is the problem. can some one help me out. pls !!!
This the code after editing in c file .
#define SS PINB4
#define MOSI PINB5
#define MISO PINB6
#define SCK PINB7
#define CS PIND0
#define DC PIND1
#define RST PIND6
void delay(uint8_t a)
{
unsigned int i,j;
for(i=0;i<a;i++)
{
for(j=0;j<1024;j++);
}
}
void Adafruit_HX8357() {
_cs = CS;
_dc = DC;
_rst = RST;
_mosi = MOSI;
_sck = SCK;
}
void Adafruit_GFX(int16_t w, int16_t h)
{
_width = w;
_height = h;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0x001F;
}
void setRotation(uint8_t m) {
writecommand(HX8357_MADCTL);
rotation = m % 4; // can't be higher than 3
switch (rotation) {
case 0:
writedata(MADCTL_MX | MADCTL_MY | MADCTL_RGB);
_width = HX8357_TFTWIDTH;
_height = HX8357_TFTHEIGHT;
break;
case 1:
writedata(MADCTL_MV | MADCTL_MY | MADCTL_RGB);
_width = HX8357_TFTHEIGHT;
_height = HX8357_TFTWIDTH;
break;
case 2:
writedata( MADCTL_RGB);
_width = HX8357_TFTWIDTH;
_height = HX8357_TFTHEIGHT;
break;
case 3:
writedata(MADCTL_MX | MADCTL_MV | MADCTL_RGB);
_width = HX8357_TFTHEIGHT;
_height = HX8357_TFTWIDTH;
break;
}
}
void writecommand(uint8_t c) {
PORTD &= ~(1<<PIND1);//
//dcport &= ~dcpinmask;
//digitalWrite(_dc, LOW);
PORTB &= ~(1<<PINB7);//clkport &= ~clkpinmask;
//digitalWrite(_sclk, LOW);
PORTD &= ~(1<<PIND0);//*csport &= ~cspinmask;
//digitalWrite(_cs, LOW);
spiwrite(c);
//Serial.print("Command 0x"); Serial.println(c, HEX);
PORTD |= (1<<PIND0);//*csport |= cspinmask;
//digitalWrite(_cs, HIGH);
}
void writedata(uint8_t c) {
PORTD |= (1<<PIND1);//
//dcport |= dcpinmask;
//digitalWrite(_dc, HIGH);
PORTB &= ~(1<<PINB7);//clkport &= ~clkpinmask;
//digitalWrite(_sclk, LOW);
PORTD &= ~(1<<PIND0);// *csport &= ~cspinmask;
//digitalWrite(_cs, LOW);
spiwrite(c);
//Serial.print("Data 0x"); Serial.println(c, HEX);
//digitalWrite(_cs, HIGH);
PORTD |= (1<<PIND0);//*csport |= cspinmask;
}
void spiwrite(uint8_t c) {
SPDR = c;
while(!(SPSR & (1<<SPIF) ));
}
void init()
{
DDRB = (1<<PINB5)|(1<<PINB7);
SPCR = 0x50;
SPSR = 0x00;
}
void begins(uint8_t type) {
if (_rst > 0) {
DDRD |= (1<<PIND6);//pinMode(_rst, OUTPUT);
_rst = 0;// reset LOW
}
DDRD |= (1<< PIND1);//pinMode(_dc, OUTPUT);
DDRD |= (1<< PIND0);//pinMode(_cs, OUTPUT);
// toggle RST low to reset
if (_rst > 0) {
_rst = 1;//digitalWrite(_rst, HIGH);
delay(100);
_rst = 0;//digitalWrite(_rst, LOW);
delay(100);
_rst = 1;//digitalWrite(_rst, HIGH);
delay(150);
}
writecommand(HX8357_SWRESET);
// setextc
writecommand(HX8357D_SETC);
writedata(0xFF);
writedata(0x83);
writedata(0x57);
delay(300);
// setRGB which also enables SDO
writecommand(HX8357_SETRGB);
writedata(0x80); //enable SDO pin!
// writedata(0x00); //disable SDO pin!
writedata(0x0);
writedata(0x06);
writedata(0x06);
writecommand(HX8357D_SETCOM);
writedata(0x25); // -1.52V
writecommand(HX8357_SETOSC);
writedata(0x68); // Normal mode 70Hz, Idle mode 55 Hz
writecommand(HX8357_SETPANEL); //Set Panel
writedata(0x05); // BGR, Gate direction swapped
writecommand(HX8357_SETPWR1);
writedata(0x00); // Not deep standby
writedata(0x15); //BT
writedata(0x1C); //VSPR
writedata(0x1C); //VSNR
writedata(0x83); //AP
writedata(0xAA); //FS
writecommand(HX8357D_SETSTBA);
writedata(0x50); //OPON normal
writedata(0x50); //OPON idle
writedata(0x01); //STBA
writedata(0x3C); //STBA
writedata(0x1E); //STBA
writedata(0x08); //GEN
writecommand(HX8357D_SETCYC);
writedata(0x02); //NW 0x02
writedata(0x40); //RTN
writedata(0x00); //DIV
writedata(0x2A); //DUM
writedata(0x2A); //DUM
writedata(0x0D); //GDON
writedata(0x78); //GDOFF
writecommand(HX8357D_SETGAMMA);
writedata(0x02);
writedata(0x0A);
writedata(0x11);
writedata(0x1d);
writedata(0x23);
writedata(0x35);
writedata(0x41);
writedata(0x4b);
writedata(0x4b);
writedata(0x42);
writedata(0x3A);
writedata(0x27);
writedata(0x1B);
writedata(0x08);
writedata(0x09);
writedata(0x03);
writedata(0x02);
writedata(0x0A);
writedata(0x11);
writedata(0x1d);
writedata(0x23);
writedata(0x35);
writedata(0x41);
writedata(0x4b);
writedata(0x4b);
writedata(0x42);
writedata(0x3A);
writedata(0x27);
writedata(0x1B);
writedata(0x08);
writedata(0x09);
writedata(0x03);
writedata(0x00);
writedata(0x01);
writecommand(HX8357_COLMOD);
writedata(0x55); // 16 bit
writecommand(HX8357_MADCTL);
writedata(0xC0);
writecommand(HX8357_TEON); // TE off
writedata(0x00);
writecommand(HX8357_TEARLINE); // tear line
writedata(0x00);
writedata(0x02);
writecommand(HX8357_SLPOUT); //Exit Sleep
delay(150);
writecommand(HX8357_DISPON); // display on
delay(50);
}
void drawPixel(int16_t x, int16_t y, uint16_t color) {
if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;
setAddrWindow(x,y,x+1,y+1);
//digitalWrite(_dc, HIGH);
PORTD |= (1<<PIND1);// dcport |= dcpinmask;
//digitalWrite(_cs, LOW);
PORTD &= ~(1<<PIND0);//csport &= ~cspinmask;
spiwrite(color >> 8);
spiwrite(color);
PORTD |= (1<<PIND0);//*csport |= cspinmask;
//digitalWrite(_cs, HIGH);
}
void drawFastVLine(int16_t x, int16_t y, int16_t h,uint16_t color) {
// Rudimentary clipping
if((x >= _width) || (y >= _height)) return;
if((y+h-1) >= _height)
h = _height-y;
setAddrWindow(x, y, x, y+h-1);
uint8_t hi = color >> 8, lo = color;
PORTD |= (1<<PIND1);//*dcport |= dcpinmask;
//digitalWrite(_dc, HIGH);
PORTD &= ~(1<<PIND0);//*csport &= ~cspinmask;
//digitalWrite(_cs, LOW);
while (h--) {
spiwrite(hi);
spiwrite(lo);
}
PORTD |= (1<<PIND0);//*csport |= cspinmask;
//digitalWrite(_cs, HIGH);
}
void drawRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color){
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
void drawFastHLine(int16_t x, int16_t y, int16_t w,uint16_t color) {
// Rudimentary clipping
if((x >= _width) || (y >= _height)) return;
if((x+w-1) >= _width) w = _width-x;
setAddrWindow(x, y, x+w-1, y);
uint8_t hi = color >> 8, lo = color;
PORTD |= (1<<PIND1);//*dcport |= dcpinmask;
PORTD &= ~(1<<PIND0);//*csport &= ~cspinmask;
//digitalWrite(_dc, HIGH);
//digitalWrite(_cs, LOW);
while (w--) {
spiwrite(hi);
spiwrite(lo);
}
PORTD |= (1<<PIND0);//*csport |= cspinmask;
//digitalWrite(_cs, HIGH);
}
void fillScreen(uint16_t color) {
drawRect(0, 0, _width, _height, color);
}
void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1,uint16_t y1)
{
writecommand(HX8357_CASET); // Column addr set
writedata(x0 >> 8);
writedata(x0 & 0xFF); // XSTART
writedata(x1 >> 8);
writedata(x1 & 0xFF); // XEND
writecommand(HX8357_PASET); // Row addr set
writedata(y0>>8);
writedata(y0); // YSTART
writedata(y1>>8);
writedata(y1); // YEND
writecommand(HX8357_RAMWR); // write to RAM
}
void setCursor(int16_t x, int16_t y) {
cursor_x = x;
cursor_y = y;
}
void setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1;
}
void setTextColor(uint16_t c) {
textcolor = textbgcolor = c;
}
int main(void)
{
init();
Adafruit_HX8357();
begins(HX8357D);
Adafruit_GFX(HX8357_TFTWIDTH, HX8357_TFTHEIGHT);
setRotation(3);
fillScreen(HX8357_RED);
return 0;
}
The link for original library is
https://github.com/adafruit/Adafruit_HX8357_Library
https://github.com/adafruit/Adafruit-GFX-Library

Initializer-string for array of chars is too long error on Arduino

I am trying to run a code below on Arduino but when I verify the code, it shows,
'Initializer-string for array of chars is too long'.
Although I have read previous questions regarding similar issues, I couldn't know where to begin in the code I am trying now. Yes,,, I am very new to C++ world,,, If you can give me a clue to teach myself or a direct answer, it would be amazingly appreciated.
Best,
/**** SET YOUR MAC ADDRESS HERE ****/
char mac[13] = "74-E5-43-BE-42-10";
/***********************************/
#define LED 13
#define BLUESMIRFON 2
#define FACTORYRESETBAUD 57600
#define DEFAULTBAUD 115200
char str[3];
char passkey[5] = "0000";
boolean success = false;
int failOuts[10] = {3,4,5,6,7,8,9,10,11,12};
void setup()
{
//Initialize pins
pinMode(LED, OUTPUT);
pinMode(BLUESMIRFON, OUTPUT);
for (int i=0; i<10; i++) {
pinMode(failOuts[i], OUTPUT);
}
// First reset to factory defaults
while (!success) {
RunBlueSmirfSetup(true);
}
success = false;
// Then set up with the correct mac address
RunBlueSmirfSetup(false);
}
void loop() {
if(success) {
digitalWrite(LED,LOW);
delay(1000);
digitalWrite(LED,HIGH);
delay(1000);
}
}
void RunBlueSmirfSetup(boolean factoryReset) {
//Initialize serial ports
if (factoryReset) {
Serial.begin(FACTORYRESETBAUD);
} else {
Serial.begin(DEFAULTBAUD);
}
digitalWrite(BLUESMIRFON, LOW);
delay(2000);
digitalWrite(BLUESMIRFON, HIGH);
delay(2000); //Wait for BlueSMIRF to turn on
Serial.print('$'); //Send command to put BlueSMIRF into programming mode
Serial.print('$');
Serial.print('$');
delay(100);
Serial.flush();
//Reset the module
if (factoryReset) {
Serial.print('S');
Serial.print('F');
Serial.print(',');
Serial.print('1');
Serial.print('\r');
while(Serial.available() < 3);
str[0] = (char)Serial.read();
str[1] = (char)Serial.read();
str[2] = (char)Serial.read();
if(str[0] == 'A' && str[1] == 'O' && str[2] == 'K') {
success = true;
} else {
success = false;
digitalWrite(failOuts[0],HIGH);
}
delay(100);
Serial.flush();
} else {
//Set the baudrate
Serial.print('S');
Serial.print('U');
Serial.print(',');
Serial.print('5');
Serial.print('7');
Serial.print('\r');
while(Serial.available() < 3);
str[0] = (char)Serial.read();
str[1] = (char)Serial.read();
str[2] = (char)Serial.read();
if(str[0] == 'A' && str[1] == 'O' && str[2] == 'K') {
success = true;
} else {
success = false;
digitalWrite(failOuts[1],HIGH);
}
delay(100);
Serial.flush();
//Set the remote MAC address
Serial.print('S');
Serial.print('R');
Serial.print(',');
for(int i = 0; i < 12; i++) {
Serial.print(mac[i]);
}
Serial.print('\r');
while(Serial.available() < 3);
str[0] = (char)Serial.read();
str[1] = (char)Serial.read();
str[2] = (char)Serial.read();
if(str[0] == 'A' && str[1] == 'O' && str[2] == 'K') {
success = true;
} else {
success = false;
digitalWrite(failOuts[2],HIGH);
}
delay(100);
Serial.flush();
//Set the passkey
Serial.print('S');
Serial.print('P');
Serial.print(',');
for(int i = 0; i < 4; i++) {
Serial.print(passkey[i]);
}
Serial.print('\r');
while(Serial.available() < 3);
str[0] = (char)Serial.read();
str[1] = (char)Serial.read();
str[2] = (char)Serial.read();
if(str[0] == 'A' && str[1] == 'O' && str[2] == 'K') {
success = true;
} else {
success = false;
digitalWrite(failOuts[3],HIGH);
}
delay(100);
Serial.flush();
//Set the BlueSMiRF mode
Serial.print('S');
Serial.print('M');
Serial.print(',');
Serial.print('3');
Serial.print('\r');
while(Serial.available() < 3);
str[0] = (char)Serial.read();
str[1] = (char)Serial.read();
str[2] = (char)Serial.read();
if(str[0] == 'A' && str[1] == 'O' && str[2] == 'K') {
success = true;
} else {
success = false;
digitalWrite(failOuts[4],HIGH);
}
delay(100);
Serial.flush();
delay(100);
//Exit command mode
}
Serial.print('-');
Serial.print('-');
Serial.print('-');
Serial.print('\r');
//delay(100);
//Serial.flush();
//delay(100);
//Serial.end();
//digitalWrite(BLUESMIRFON, LOW);
}
CleanProgramBlueSMiRF CleanProgramBlueSMiRF
It would help if you copied the exact error message including the line number.
I assume it is failing on:
char mac[13] = "74-E5-43-BE-42-10";
since it has 17 chars between the quotes and you allocated 13.

Why does serial communication only work in one direction (chip->PC) with my code?

I am writing code for an Arduino Mega 2560 in C and I am trying to do bidirectional communication over the serial port. However, only sending data from the Arduino to the PC works - the other way doesn't. The RX LED on the arduino shortly lights up, but my code doesn't receive the data (the LED connected to "pin 13" doesn't light up). Does anyone know how to fix this?
Here's the code that's running on the arduino:
#define USART_BAUDRATE 500000
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
static void serial_init(void) {
// load upper 8 bits of the baud rate into the high byte of the UBRR register
UBRR0H = (BAUD_PRESCALE >> 8);
// load lower 8 bits of the baud rate into the low byte of the UBRR register
UBRR0L = BAUD_PRESCALE;
// 8data,1stopbit
UCSR0C = (0 << UMSEL00) | (1 << UCSZ00) | (1 << UCSZ01);
// turn on the transmission and reception circuitry
UCSR0B = (1 << RXEN0) | (1 << TXEN0) | (0 << UCSZ02);
}
static void sendbyte(uint8_t b) {
// do nothing until UDR is ready for more data to be written to it
while ((UCSR0A & (1 << UDRE0)) == 0) {};
// memory was cleared - write to it
UDR0 = b;
}
static void digi_init() {
// configure port B7 (arduino digital port 13) as output and set it low
PORTB = (0<<PB7);
DDRB = (1<<DDB7);
}
static void digi_set(int val) {
PORTB = (val<<PB7);
}
int main(void) {
serial_init();
digi_init();
while (1) {
if ((UCSR0A & (1 << RXC0)) == 1) {
// we got some data, light up the LED!
digi_set(1);
}
_delay_ms(50);
sendbyte('.');
}
}
And here's the code that's running on the PC:
int main(int argc, char *argv[]) {
char *serialdevicepath = "/dev/ttyACM0";
fprintf(stderr, "Connecting to serial device ...\n");
int serial_fd = open(serialdevicepath, O_RDWR | O_NOCTTY);
struct termios config;
if(tcgetattr(serial_fd, &config) < 0) exit(1);
config.c_iflag &= ~(IGNBRK | BRKINT | ICRNL | INLCR | PARMRK | INPCK | ISTRIP | IXON);
config.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG);
config.c_cflag &= ~(CSIZE | PARENB);
config.c_cflag |= CS8;
config.c_cc[VMIN] = 1;
config.c_cc[VTIME] = 0;
if(cfsetispeed(&config, B500000) < 0 || cfsetospeed(&config, B500000) < 0) exit(1);
if(tcsetattr(serial_fd, TCSAFLUSH, &config) < 0) exit(1);
FILE *serial = fdopen(serial_fd, "r");
setbuf(stdin, NULL);
fcntl(0/*stdin*/, F_SETFL, O_NONBLOCK);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
setbuf(serial, NULL);
while (1) {
char c;
while (read(0, &c, 1) == 1) {
if (c != '+' && c != '-') continue;
uint8_t val = (c == '+') ? 42 : 41;
if (write(serial_fd, &val, 1) != 1) {
assert(0);
}
}
char b = fgetc(serial))&0xe0);
fprintf(stderr, "read 0x%x\n", b);
}
return 0;
}
(And yes, I am typing <+> on the PC so that it does send data. Also, I tried turning on the LED from the code directly and it worked.)
if ((UCSR0A & (1 << RXC0)) == 1)
That test is wrong, it will never be 1. The & operator here will produce either 0 or (1 << RXC0). Favor it this way instead:
if ((UCSR0A & (1 << RXC0)) != 0)
Or in C you'd typically write it this way since any non-zero value is logically true:
if (UCSR0A & (1 << RXC0))

Resources