ao_gps_skytrac, ao_gps_ublox: Add explicit casts to quiet -Wconversion

No bugs noted.

Signed-off-by: Keith Packard <keithp@keithp.com>

diff --git a/src/drivers/ao_cc115l.c b/src/drivers/ao_cc115l.c
index dc8e9ff315ad303df49ee0b1ccc151767e8c842e..65ab576712043c84a49290af143dbf4d9212c66c 100644 (file)
--- a/src/drivers/ao_cc115l.c
+++ b/src/drivers/ao_cc115l.c
@@ -449,22 +449,22 @@ ao_radio_set_mode(uint16_t new_mode)
        if (new_mode == ao_radio_mode)
                return;
 
-       changes = new_mode & (~ao_radio_mode);
+       changes = (uint16_t) (new_mode & (~ao_radio_mode));
        if (changes & AO_RADIO_MODE_BITS_PACKET_TX) {
                ao_radio_reg_write(CC115L_MDMCFG4, packet_rate_setup[ao_config.radio_rate].mdmcfg4);
                ao_radio_reg_write(CC115L_DEVIATN, packet_rate_setup[ao_config.radio_rate].deviatn);
 
                for (i = 0; i < sizeof (packet_setup) / sizeof (packet_setup[0]); i += 2)
-                       ao_radio_reg_write(packet_setup[i], packet_setup[i+1]);
+                       ao_radio_reg_write((uint8_t) packet_setup[i], (uint8_t) packet_setup[i+1]);
        }
 
        if (changes & AO_RADIO_MODE_BITS_RDF)
                for (i = 0; i < sizeof (rdf_setup) / sizeof (rdf_setup[0]); i += 2)
-                       ao_radio_reg_write(rdf_setup[i], rdf_setup[i+1]);
+                       ao_radio_reg_write((uint8_t) rdf_setup[i], (uint8_t) rdf_setup[i+1]);
 
        if (changes & AO_RADIO_MODE_BITS_APRS)
                for (i = 0; i < sizeof (aprs_setup) / sizeof (aprs_setup[0]); i += 2)
-                       ao_radio_reg_write(aprs_setup[i], aprs_setup[i+1]);
+                       ao_radio_reg_write((uint8_t) aprs_setup[i], (uint8_t) aprs_setup[i+1]);
 
        if (changes & AO_RADIO_MODE_BITS_INFINITE)
                ao_radio_reg_write(CC115L_PKTCTRL0, AO_PKTCTRL0_INFINITE);
@@ -536,7 +536,7 @@ ao_radio_setup(void)
        ao_delay(AO_MS_TO_TICKS(10));
 
        for (i = 0; i < sizeof (radio_setup) / sizeof (radio_setup[0]); i += 2)
-               ao_radio_reg_write(radio_setup[i], radio_setup[i+1]);
+               ao_radio_reg_write((uint8_t) radio_setup[i], (uint8_t) radio_setup[i+1]);
 
        ao_radio_mode = 0;
 
@@ -570,15 +570,15 @@ ao_radio_get(void)
        if (!ao_radio_configured)
                ao_radio_setup();
        if (ao_config.radio_setting != last_radio_setting) {
-               ao_radio_reg_write(CC115L_FREQ2, ao_config.radio_setting >> 16);
-               ao_radio_reg_write(CC115L_FREQ1, ao_config.radio_setting >> 8);
-               ao_radio_reg_write(CC115L_FREQ0, ao_config.radio_setting);
+               ao_radio_reg_write(CC115L_FREQ2, (uint8_t) (ao_config.radio_setting >> 16));
+               ao_radio_reg_write(CC115L_FREQ1, (uint8_t) (ao_config.radio_setting >> 8));
+               ao_radio_reg_write(CC115L_FREQ0, (uint8_t) (ao_config.radio_setting));
                last_radio_setting = ao_config.radio_setting;
                /* Make sure the RF calibration is current */
                ao_radio_strobe(CC115L_SCAL);
        }
        if (ao_config.radio_rate != last_radio_rate) {
-               ao_radio_mode &= ~AO_RADIO_MODE_BITS_PACKET_TX;
+               ao_radio_mode &= (uint16_t) ~AO_RADIO_MODE_BITS_PACKET_TX;
                last_radio_rate = ao_config.radio_rate;
        }
 }
@@ -614,11 +614,11 @@ ao_radio_tone_fill(uint8_t *buf, int16_t len)
                        this_time = len;
 
                /* queue the data */
-               memset(buf, t->value, this_time);
+               memset(buf, t->value, (size_t) this_time);
 
                /* mark as sent */
                len -= this_time;
-               ao_radio_tone_offset += this_time;
+               ao_radio_tone_offset += (uint8_t) this_time;
                ret += this_time;
 
                if (ao_radio_tone_offset >= t->len) {
@@ -641,7 +641,7 @@ ao_radio_tone_run(struct ao_radio_tone *tones, int ntones)
        ao_radio_tone = tones;
        ao_radio_tone_current = 0;
        ao_radio_tone_offset = 0;
-       ao_radio_tone_count = ntones;
+       ao_radio_tone_count = (uint8_t) ntones;
        _ao_radio_send_lots(ao_radio_tone_fill, AO_RADIO_MODE_RDF);
        ao_radio_put();
 }
@@ -703,7 +703,7 @@ ao_radio_test_cmd(void)
        static uint8_t radio_on;
        ao_cmd_white();
        if (ao_cmd_lex_c != '\n')
-               mode = ao_cmd_decimal();
+               mode = (uint8_t) ao_cmd_decimal();
        mode++;
        if ((mode & 2) && !radio_on) {
 #if HAS_MONITOR
@@ -786,7 +786,7 @@ ao_radio_send_fill(uint8_t *buf, int16_t len)
        this_time = ao_radio_send_len;
        if (this_time > len)
                this_time = len;
-       memcpy(buf, ao_radio_send_buf, this_time);
+       memcpy(buf, ao_radio_send_buf, (size_t) this_time);
        ao_radio_send_buf += this_time;
        ao_radio_send_len -= this_time;
        if (ao_radio_send_len == 0)
@@ -834,7 +834,7 @@ _ao_radio_send_lots(ao_radio_fill_func fill, uint8_t mode)
 
                /* At the last buffer, set the total length */
                if (done) {
-                       ao_radio_set_len(total & 0xff);
+                       ao_radio_set_len((uint8_t) (total & 0xff));
                        ao_radio_set_mode(mode | AO_RADIO_MODE_BITS_FIXED);
                } else {
                        ao_radio_set_len(0xff);
@@ -843,7 +843,7 @@ _ao_radio_send_lots(ao_radio_fill_func fill, uint8_t mode)
 
                b = buf;
                while (cnt) {
-                       uint8_t this_len = cnt;
+                       uint8_t this_len = (uint8_t) cnt;
 
                        /* Wait for some space in the fifo */
                        while (!ao_radio_abort && (fifo_space = ao_radio_tx_fifo_space()) == 0) {

diff --git a/src/drivers/ao_gps_skytraq.c b/src/drivers/ao_gps_skytraq.c
index d90141b693910d9db54fc67a666a34977fa1236f..3a253eea69559fb19731824c46866995e5b75baa 100644 (file)
--- a/src/drivers/ao_gps_skytraq.c
+++ b/src/drivers/ao_gps_skytraq.c
@@ -126,7 +126,7 @@ ao_gps_decimal(uint8_t max_width)
                uint8_t c = ao_gps_char;
                if (c < (uint8_t) '0' || (uint8_t) '9' < c)
                        break;
-               v = v * 10 + (uint8_t) (c - (uint8_t) '0');
+               v = (int16_t) (v * 10 + (uint8_t) (c - (uint8_t) '0'));
                ao_gps_num_width++;
                ao_gps_lexchar();
        }
@@ -145,16 +145,15 @@ ao_gps_hex(void)
        ao_gps_num_width = 0;
        while (ao_gps_num_width < 2) {
                uint8_t c = ao_gps_char;
-               uint8_t d;
                if ((uint8_t) '0' <= c && c <= (uint8_t) '9')
-                       d = - '0';
+                       c -= '0';
                else if ((uint8_t) 'A' <= c && c <= (uint8_t) 'F')
-                       d = - 'A' + 10;
+                       c -= 'A' - 10;
                else if ((uint8_t) 'a' <= c && c <= (uint8_t) 'f')
-                       d = - 'a' + 10;
+                       c -= 'a' - 10;
                else
                        break;
-               v = (v << 4) | (c + d);
+               v = (uint8_t) ((v << 4) | c);
                ao_gps_num_width++;
                ao_gps_lexchar();
        }
@@ -164,9 +163,9 @@ ao_gps_hex(void)
 static int32_t
 ao_gps_parse_pos(uint8_t deg_width) 
 {
-       static uint16_t d;
-       static uint8_t  m;
-       static uint16_t f;
+       int16_t         d;
+       int16_t         m;
+       int16_t         f;
        char c;
 
        d = ao_gps_decimal(deg_width);
@@ -256,9 +255,9 @@ ao_nmea_gga(void)
 
        ao_gps_next_tick = ao_time();
        ao_gps_next.flags = AO_GPS_RUNNING | ao_gps_date_flags;
-       ao_gps_next.hour = ao_gps_decimal(2);
-       ao_gps_next.minute = ao_gps_decimal(2);
-       ao_gps_next.second = ao_gps_decimal(2);
+       ao_gps_next.hour = (uint8_t) ao_gps_decimal(2);
+       ao_gps_next.minute = (uint8_t) ao_gps_decimal(2);
+       ao_gps_next.second = (uint8_t) ao_gps_decimal(2);
        ao_gps_skip_field();    /* skip seconds fraction */
 
        ao_gps_next.latitude = ao_gps_parse_pos(2);
@@ -268,17 +267,17 @@ ao_nmea_gga(void)
        if (ao_gps_parse_flag('E', 'W'))
                ao_gps_next.longitude = -ao_gps_next.longitude;
 
-       i = ao_gps_decimal(0xff);
+       i = (uint8_t) ao_gps_decimal(0xff);
        if (i == 1)
                ao_gps_next.flags |= AO_GPS_VALID;
 
-       i = ao_gps_decimal(0xff) << AO_GPS_NUM_SAT_SHIFT;
+       i = (uint8_t) (ao_gps_decimal(0xff) << AO_GPS_NUM_SAT_SHIFT);
        if (i > AO_GPS_NUM_SAT_MASK)
                i = AO_GPS_NUM_SAT_MASK;
        ao_gps_next.flags |= i;
 
        ao_gps_lexchar();
-       i = ao_gps_decimal(0xff);
+       i = (uint8_t) ao_gps_decimal(0xff);
        if (i <= 25) {
                i = (uint8_t) 10 * i;
                if (ao_gps_char == '.')
@@ -307,7 +306,7 @@ ao_nmea_gga(void)
 static void
 ao_nmea_gsv(void)
 {
-       char    c;
+       uint8_t c;
        uint8_t i;
        uint8_t done;
        /* Now read the data into the GPS tracking data record
@@ -326,8 +325,8 @@ ao_nmea_gsv(void)
         *      ...             other SVIDs
         *      72              checksum
         */
-       c = ao_gps_decimal(1);  /* total messages */
-       i = ao_gps_decimal(1);  /* message sequence */
+       c = (uint8_t) ao_gps_decimal(1);        /* total messages */
+       i = (uint8_t) ao_gps_decimal(1);        /* message sequence */
        if (i == 1) {
                ao_gps_tracking_next.channels = 0;
        }
@@ -336,14 +335,14 @@ ao_nmea_gsv(void)
        ao_gps_skip_field();    /* sats in view */
        while (ao_gps_char != '*' && ao_gps_char != '\n' && ao_gps_char != '\r') {
                i = ao_gps_tracking_next.channels;
-               c = ao_gps_decimal(2);  /* SVID */
+               c = (uint8_t) ao_gps_decimal(2);        /* SVID */
                if (i < AO_MAX_GPS_TRACKING)
                        ao_gps_tracking_next.sats[i].svid = c;
                ao_gps_lexchar();
                ao_gps_skip_field();    /* elevation */
                ao_gps_lexchar();
                ao_gps_skip_field();    /* azimuth */
-               c = ao_gps_decimal(2);  /* C/N0 */
+               c = (uint8_t) ao_gps_decimal(2);        /* C/N0 */
                if (i < AO_MAX_GPS_TRACKING) {
                        if ((ao_gps_tracking_next.sats[i].c_n_1 = c) != 0)
                                ao_gps_tracking_next.channels = i + 1;
@@ -366,7 +365,7 @@ ao_nmea_gsv(void)
 static void
 ao_nmea_rmc(void)
 {
-       char    a, c;
+       uint8_t a, c;
        uint8_t i;
        /* Parse the RMC record to read out the current date */
 
@@ -397,9 +396,9 @@ ao_nmea_rmc(void)
                ao_gps_lexchar();
                ao_gps_skip_field();
        }
-       a = ao_gps_decimal(2);
-       c = ao_gps_decimal(2);
-       i = ao_gps_decimal(2);
+       a = (uint8_t) ao_gps_decimal(2);
+       c = (uint8_t) ao_gps_decimal(2);
+       i = (uint8_t) ao_gps_decimal(2);
 
        ao_nmea_finish();
 

diff --git a/src/drivers/ao_gps_ublox.c b/src/drivers/ao_gps_ublox.c
index 2556d314547b08cd91a2a3971bf0166a7697a5ff..57cbf22a77b50245975955925096ba85ac9723f5 100644 (file)
--- a/src/drivers/ao_gps_ublox.c
+++ b/src/drivers/ao_gps_ublox.c
@@ -115,8 +115,8 @@ static void ao_ublox_put_i8(int8_t c)
 
 static void ao_ublox_put_u16(uint16_t c)
 {
-       ao_ublox_put_u8(c);
-       ao_ublox_put_u8(c>>8);
+       ao_ublox_put_u8((uint8_t) c);
+       ao_ublox_put_u8((uint8_t) (c>>8));
 }
 
 #if 0
@@ -128,10 +128,10 @@ static void ao_ublox_put_i16(int16_t c)
 
 static void ao_ublox_put_u32(uint32_t c)
 {
-       ao_ublox_put_u8(c);
-       ao_ublox_put_u8(c>>8);
-       ao_ublox_put_u8(c>>16);
-       ao_ublox_put_u8(c>>24);
+       ao_ublox_put_u8((uint8_t) c);
+       ao_ublox_put_u8((uint8_t) (c>>8));
+       ao_ublox_put_u8((uint8_t) (c>>16));
+       ao_ublox_put_u8((uint8_t) (c>>24));
 }
 
 static void ao_ublox_put_i32(int32_t c)
@@ -160,7 +160,7 @@ static void ublox_u16(uint8_t offset)
        uint16_t val;
 
        val = data_byte();
-       val |= data_byte () << 8;
+       val |= (uint16_t) ((uint16_t) data_byte () << 8);
        *ptr = val;
 }
 
@@ -515,8 +515,8 @@ ao_ublox_putstart(uint8_t class, uint8_t id, uint16_t len)
        ao_gps_putchar(0x62);
        ao_ublox_put_u8(class);
        ao_ublox_put_u8(id);
-       ao_ublox_put_u8(len);
-       ao_ublox_put_u8(len >> 8);
+       ao_ublox_put_u8((uint8_t) len);
+       ao_ublox_put_u8((uint8_t) (len >> 8));
 }
 
 static void
@@ -659,7 +659,7 @@ ao_gps(void)
 
                /* Length */
                ao_ublox_len = header_byte();
-               ao_ublox_len |= header_byte() << 8;
+               ao_ublox_len |= (uint16_t) ((uint16_t) header_byte() << 8);
 
                ao_gps_dbg(DBG_PROTO, "%6u class %02x id %02x len %d\n", packet_start_tick, class, id, ao_ublox_len);
 
@@ -738,7 +738,7 @@ ao_gps(void)
                                ao_gps_data.latitude = nav_posllh.lat;
                                ao_gps_data.longitude = nav_posllh.lon;
 
-                               ao_gps_data.year = nav_timeutc.year - 2000;
+                               ao_gps_data.year = (uint8_t) (nav_timeutc.year - 2000);
                                ao_gps_data.month = nav_timeutc.month;
                                ao_gps_data.day = nav_timeutc.day;
 
@@ -748,13 +748,13 @@ ao_gps(void)
 
                                /* we report dop scaled by 10, but ublox provides dop scaled by 100
                                 */
-                               ao_gps_data.pdop = nav_dop.pdop / 10;
-                               ao_gps_data.hdop = nav_dop.hdop / 10;
-                               ao_gps_data.vdop = nav_dop.vdop / 10;
+                               ao_gps_data.pdop = (uint8_t) (nav_dop.pdop / 10);
+                               ao_gps_data.hdop = (uint8_t) (nav_dop.hdop / 10);
+                               ao_gps_data.vdop = (uint8_t) (nav_dop.vdop / 10);
 
-                               ao_gps_data.ground_speed = nav_velned.g_speed;
-                               ao_gps_data.climb_rate = -nav_velned.vel_d;
-                               ao_gps_data.course = nav_velned.heading / 200000;
+                               ao_gps_data.ground_speed = (uint16_t) nav_velned.g_speed;
+                               ao_gps_data.climb_rate = -(int16_t) nav_velned.vel_d;
+                               ao_gps_data.course = (uint8_t) (nav_velned.heading / 200000);
 
                                ao_gps_tracking_data.channels = 0;